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/genalloc.h>
19 #include <linux/interrupt.h>
21 #include <linux/irq.h>
22 #include <linux/kfifo.h>
23 #include <linux/module.h>
24 #include <linux/of_device.h>
25 #include <linux/platform_device.h>
26 #include <linux/pm_runtime.h>
27 #include <linux/slab.h>
28 #include <linux/videodev2.h>
30 #include <linux/platform_data/coda.h>
31 #include <linux/reset.h>
33 #include <media/v4l2-ctrls.h>
34 #include <media/v4l2-device.h>
35 #include <media/v4l2-event.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/v4l2-mem2mem.h>
38 #include <media/videobuf2-core.h>
39 #include <media/videobuf2-dma-contig.h>
40 #include <media/videobuf2-vmalloc.h>
44 #define CODA_NAME "coda"
46 #define CODADX6_MAX_INSTANCES 4
47 #define CODA_MAX_FORMATS 4
49 #define CODA_ISRAM_SIZE (2048 * 2)
54 #define S_ALIGN 1 /* multiple of 2 */
55 #define W_ALIGN 1 /* multiple of 2 */
56 #define H_ALIGN 1 /* multiple of 2 */
58 #define fh_to_ctx(__fh) container_of(__fh, struct coda_ctx, fh)
61 module_param(coda_debug
, int, 0644);
62 MODULE_PARM_DESC(coda_debug
, "Debug level (0-2)");
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_buffer
*buf
, unsigned int reg_y
)
89 u32 base_y
= vb2_dma_contig_plane_dma_addr(buf
, 0);
92 switch (q_data
->fourcc
) {
93 case V4L2_PIX_FMT_YVU420
:
94 /* Switch Cb and Cr for YVU420 format */
95 base_cr
= base_y
+ q_data
->bytesperline
* q_data
->height
;
96 base_cb
= base_cr
+ q_data
->bytesperline
* q_data
->height
/ 4;
98 case V4L2_PIX_FMT_YUV420
:
99 case V4L2_PIX_FMT_NV12
:
101 base_cb
= base_y
+ q_data
->bytesperline
* q_data
->height
;
102 base_cr
= base_cb
+ 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);
115 * Array of all formats supported by any version of Coda:
117 static const struct coda_fmt coda_formats
[] = {
119 .name
= "YUV 4:2:0 Planar, YCbCr",
120 .fourcc
= V4L2_PIX_FMT_YUV420
,
123 .name
= "YUV 4:2:0 Planar, YCrCb",
124 .fourcc
= V4L2_PIX_FMT_YVU420
,
127 .name
= "YUV 4:2:0 Partial interleaved Y/CbCr",
128 .fourcc
= V4L2_PIX_FMT_NV12
,
131 .name
= "YUV 4:2:2 Planar, YCbCr",
132 .fourcc
= V4L2_PIX_FMT_YUV422P
,
135 .name
= "H264 Encoded Stream",
136 .fourcc
= V4L2_PIX_FMT_H264
,
139 .name
= "MPEG4 Encoded Stream",
140 .fourcc
= V4L2_PIX_FMT_MPEG4
,
143 .name
= "JPEG Encoded Images",
144 .fourcc
= V4L2_PIX_FMT_JPEG
,
148 #define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \
149 { mode, src_fourcc, dst_fourcc, max_w, max_h }
152 * Arrays of codecs supported by each given version of Coda:
156 * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants
158 static const struct coda_codec codadx6_codecs
[] = {
159 CODA_CODEC(CODADX6_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 720, 576),
160 CODA_CODEC(CODADX6_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 720, 576),
163 static const struct coda_codec coda7_codecs
[] = {
164 CODA_CODEC(CODA7_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 1280, 720),
165 CODA_CODEC(CODA7_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 1280, 720),
166 CODA_CODEC(CODA7_MODE_ENCODE_MJPG
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_JPEG
, 8192, 8192),
167 CODA_CODEC(CODA7_MODE_DECODE_H264
, V4L2_PIX_FMT_H264
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
168 CODA_CODEC(CODA7_MODE_DECODE_MP4
, V4L2_PIX_FMT_MPEG4
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
169 CODA_CODEC(CODA7_MODE_DECODE_MJPG
, V4L2_PIX_FMT_JPEG
, V4L2_PIX_FMT_YUV420
, 8192, 8192),
172 static const struct coda_codec coda9_codecs
[] = {
173 CODA_CODEC(CODA9_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 1920, 1088),
174 CODA_CODEC(CODA9_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 1920, 1088),
175 CODA_CODEC(CODA9_MODE_DECODE_H264
, V4L2_PIX_FMT_H264
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
176 CODA_CODEC(CODA9_MODE_DECODE_MP4
, V4L2_PIX_FMT_MPEG4
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
179 struct coda_video_device
{
181 enum coda_inst_type type
;
182 const struct coda_context_ops
*ops
;
184 u32 src_formats
[CODA_MAX_FORMATS
];
185 u32 dst_formats
[CODA_MAX_FORMATS
];
188 static const struct coda_video_device coda_bit_encoder
= {
189 .name
= "coda-encoder",
190 .type
= CODA_INST_ENCODER
,
191 .ops
= &coda_bit_encode_ops
,
203 static const struct coda_video_device coda_bit_jpeg_encoder
= {
204 .name
= "coda-jpeg-encoder",
205 .type
= CODA_INST_ENCODER
,
206 .ops
= &coda_bit_encode_ops
,
211 V4L2_PIX_FMT_YUV422P
,
218 static const struct coda_video_device coda_bit_decoder
= {
219 .name
= "coda-decoder",
220 .type
= CODA_INST_DECODER
,
221 .ops
= &coda_bit_decode_ops
,
233 static const struct coda_video_device coda_bit_jpeg_decoder
= {
234 .name
= "coda-jpeg-decoder",
235 .type
= CODA_INST_DECODER
,
236 .ops
= &coda_bit_decode_ops
,
244 V4L2_PIX_FMT_YUV422P
,
248 static const struct coda_video_device
*codadx6_video_devices
[] = {
252 static const struct coda_video_device
*coda7_video_devices
[] = {
253 &coda_bit_jpeg_encoder
,
254 &coda_bit_jpeg_decoder
,
259 static const struct coda_video_device
*coda9_video_devices
[] = {
264 static bool coda_format_is_yuv(u32 fourcc
)
267 case V4L2_PIX_FMT_YUV420
:
268 case V4L2_PIX_FMT_YVU420
:
269 case V4L2_PIX_FMT_NV12
:
270 case V4L2_PIX_FMT_YUV422P
:
277 static const char *coda_format_name(u32 fourcc
)
281 for (i
= 0; i
< ARRAY_SIZE(coda_formats
); i
++) {
282 if (coda_formats
[i
].fourcc
== fourcc
)
283 return coda_formats
[i
].name
;
290 * Normalize all supported YUV 4:2:0 formats to the value used in the codec
293 static u32
coda_format_normalize_yuv(u32 fourcc
)
295 return coda_format_is_yuv(fourcc
) ? V4L2_PIX_FMT_YUV420
: fourcc
;
298 static const struct coda_codec
*coda_find_codec(struct coda_dev
*dev
,
299 int src_fourcc
, int dst_fourcc
)
301 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
302 int num_codecs
= dev
->devtype
->num_codecs
;
305 src_fourcc
= coda_format_normalize_yuv(src_fourcc
);
306 dst_fourcc
= coda_format_normalize_yuv(dst_fourcc
);
307 if (src_fourcc
== dst_fourcc
)
310 for (k
= 0; k
< num_codecs
; k
++) {
311 if (codecs
[k
].src_fourcc
== src_fourcc
&&
312 codecs
[k
].dst_fourcc
== dst_fourcc
)
322 static void coda_get_max_dimensions(struct coda_dev
*dev
,
323 const struct coda_codec
*codec
,
324 int *max_w
, int *max_h
)
326 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
327 int num_codecs
= dev
->devtype
->num_codecs
;
335 for (k
= 0, w
= 0, h
= 0; k
< num_codecs
; k
++) {
336 w
= max(w
, codecs
[k
].max_w
);
337 h
= max(h
, codecs
[k
].max_h
);
347 const struct coda_video_device
*to_coda_video_device(struct video_device
*vdev
)
349 struct coda_dev
*dev
= video_get_drvdata(vdev
);
350 unsigned int i
= vdev
- dev
->vfd
;
352 if (i
>= dev
->devtype
->num_vdevs
)
355 return dev
->devtype
->vdevs
[i
];
358 const char *coda_product_name(int product
)
370 snprintf(buf
, sizeof(buf
), "(0x%04x)", product
);
376 * V4L2 ioctl() operations.
378 static int coda_querycap(struct file
*file
, void *priv
,
379 struct v4l2_capability
*cap
)
381 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
383 strlcpy(cap
->driver
, CODA_NAME
, sizeof(cap
->driver
));
384 strlcpy(cap
->card
, coda_product_name(ctx
->dev
->devtype
->product
),
386 strlcpy(cap
->bus_info
, "platform:" CODA_NAME
, sizeof(cap
->bus_info
));
387 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
388 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
393 static int coda_enum_fmt(struct file
*file
, void *priv
,
394 struct v4l2_fmtdesc
*f
)
396 struct video_device
*vdev
= video_devdata(file
);
397 const struct coda_video_device
*cvd
= to_coda_video_device(vdev
);
401 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
402 formats
= cvd
->src_formats
;
403 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
404 formats
= cvd
->dst_formats
;
408 if (f
->index
>= CODA_MAX_FORMATS
|| formats
[f
->index
] == 0)
411 name
= coda_format_name(formats
[f
->index
]);
412 strlcpy(f
->description
, name
, sizeof(f
->description
));
413 f
->pixelformat
= formats
[f
->index
];
414 if (!coda_format_is_yuv(formats
[f
->index
]))
415 f
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
420 static int coda_g_fmt(struct file
*file
, void *priv
,
421 struct v4l2_format
*f
)
423 struct coda_q_data
*q_data
;
424 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
426 q_data
= get_q_data(ctx
, f
->type
);
430 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
431 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
432 f
->fmt
.pix
.width
= q_data
->width
;
433 f
->fmt
.pix
.height
= q_data
->height
;
434 f
->fmt
.pix
.bytesperline
= q_data
->bytesperline
;
436 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
437 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
438 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
440 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
445 static int coda_try_pixelformat(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
447 struct coda_q_data
*q_data
;
451 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
452 formats
= ctx
->cvd
->src_formats
;
453 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
454 formats
= ctx
->cvd
->dst_formats
;
458 for (i
= 0; i
< CODA_MAX_FORMATS
; i
++) {
459 if (formats
[i
] == f
->fmt
.pix
.pixelformat
) {
460 f
->fmt
.pix
.pixelformat
= formats
[i
];
465 /* Fall back to currently set pixelformat */
466 q_data
= get_q_data(ctx
, f
->type
);
467 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
472 static unsigned int coda_estimate_sizeimage(struct coda_ctx
*ctx
, u32 sizeimage
,
473 u32 width
, u32 height
)
476 * This is a rough estimate for sensible compressed buffer
477 * sizes (between 1 and 16 bits per pixel). This could be
478 * improved by better format specific worst case estimates.
480 return round_up(clamp(sizeimage
, width
* height
/ 8,
481 width
* height
* 2), PAGE_SIZE
);
484 static int coda_try_fmt(struct coda_ctx
*ctx
, const struct coda_codec
*codec
,
485 struct v4l2_format
*f
)
487 struct coda_dev
*dev
= ctx
->dev
;
488 unsigned int max_w
, max_h
;
489 enum v4l2_field field
;
491 field
= f
->fmt
.pix
.field
;
492 if (field
== V4L2_FIELD_ANY
)
493 field
= V4L2_FIELD_NONE
;
494 else if (V4L2_FIELD_NONE
!= field
)
497 /* V4L2 specification suggests the driver corrects the format struct
498 * if any of the dimensions is unsupported */
499 f
->fmt
.pix
.field
= field
;
501 coda_get_max_dimensions(dev
, codec
, &max_w
, &max_h
);
502 v4l_bound_align_image(&f
->fmt
.pix
.width
, MIN_W
, max_w
, W_ALIGN
,
503 &f
->fmt
.pix
.height
, MIN_H
, max_h
, H_ALIGN
,
506 switch (f
->fmt
.pix
.pixelformat
) {
507 case V4L2_PIX_FMT_YUV420
:
508 case V4L2_PIX_FMT_YVU420
:
509 case V4L2_PIX_FMT_NV12
:
511 * Frame stride must be at least multiple of 8,
512 * but multiple of 16 for h.264 or JPEG 4:2:x
514 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
515 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
516 f
->fmt
.pix
.height
* 3 / 2;
518 case V4L2_PIX_FMT_YUV422P
:
519 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
520 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
521 f
->fmt
.pix
.height
* 2;
523 case V4L2_PIX_FMT_JPEG
:
524 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
526 case V4L2_PIX_FMT_H264
:
527 case V4L2_PIX_FMT_MPEG4
:
528 f
->fmt
.pix
.bytesperline
= 0;
529 f
->fmt
.pix
.sizeimage
= coda_estimate_sizeimage(ctx
,
530 f
->fmt
.pix
.sizeimage
,
541 static int coda_try_fmt_vid_cap(struct file
*file
, void *priv
,
542 struct v4l2_format
*f
)
544 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
545 const struct coda_q_data
*q_data_src
;
546 const struct coda_codec
*codec
;
547 struct vb2_queue
*src_vq
;
550 ret
= coda_try_pixelformat(ctx
, f
);
554 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
557 * If the source format is already fixed, only allow the same output
560 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
561 if (vb2_is_streaming(src_vq
)) {
562 f
->fmt
.pix
.width
= q_data_src
->width
;
563 f
->fmt
.pix
.height
= q_data_src
->height
;
566 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
568 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
569 codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
570 f
->fmt
.pix
.pixelformat
);
574 ret
= coda_try_fmt(ctx
, codec
, f
);
578 /* The h.264 decoder only returns complete 16x16 macroblocks */
579 if (codec
&& codec
->src_fourcc
== V4L2_PIX_FMT_H264
) {
580 f
->fmt
.pix
.width
= f
->fmt
.pix
.width
;
581 f
->fmt
.pix
.height
= round_up(f
->fmt
.pix
.height
, 16);
582 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
583 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
584 f
->fmt
.pix
.height
* 3 / 2;
590 static int coda_try_fmt_vid_out(struct file
*file
, void *priv
,
591 struct v4l2_format
*f
)
593 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
594 struct coda_dev
*dev
= ctx
->dev
;
595 const struct coda_q_data
*q_data_dst
;
596 const struct coda_codec
*codec
;
599 ret
= coda_try_pixelformat(ctx
, f
);
603 switch (f
->fmt
.pix
.colorspace
) {
604 case V4L2_COLORSPACE_REC709
:
605 case V4L2_COLORSPACE_JPEG
:
608 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
609 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
611 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
614 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
615 codec
= coda_find_codec(dev
, f
->fmt
.pix
.pixelformat
, q_data_dst
->fourcc
);
617 return coda_try_fmt(ctx
, codec
, f
);
620 static int coda_s_fmt(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
622 struct coda_q_data
*q_data
;
623 struct vb2_queue
*vq
;
625 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
629 q_data
= get_q_data(ctx
, f
->type
);
633 if (vb2_is_busy(vq
)) {
634 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
638 q_data
->fourcc
= f
->fmt
.pix
.pixelformat
;
639 q_data
->width
= f
->fmt
.pix
.width
;
640 q_data
->height
= f
->fmt
.pix
.height
;
641 q_data
->bytesperline
= f
->fmt
.pix
.bytesperline
;
642 q_data
->sizeimage
= f
->fmt
.pix
.sizeimage
;
643 q_data
->rect
.left
= 0;
644 q_data
->rect
.top
= 0;
645 q_data
->rect
.width
= f
->fmt
.pix
.width
;
646 q_data
->rect
.height
= f
->fmt
.pix
.height
;
648 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
649 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
650 f
->type
, q_data
->width
, q_data
->height
, q_data
->fourcc
);
655 static int coda_s_fmt_vid_cap(struct file
*file
, void *priv
,
656 struct v4l2_format
*f
)
658 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
661 ret
= coda_try_fmt_vid_cap(file
, priv
, f
);
665 return coda_s_fmt(ctx
, f
);
668 static int coda_s_fmt_vid_out(struct file
*file
, void *priv
,
669 struct v4l2_format
*f
)
671 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
672 struct v4l2_format f_cap
;
675 ret
= coda_try_fmt_vid_out(file
, priv
, f
);
679 ret
= coda_s_fmt(ctx
, f
);
683 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
685 memset(&f_cap
, 0, sizeof(f_cap
));
686 f_cap
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
687 coda_g_fmt(file
, priv
, &f_cap
);
688 f_cap
.fmt
.pix
.width
= f
->fmt
.pix
.width
;
689 f_cap
.fmt
.pix
.height
= f
->fmt
.pix
.height
;
691 ret
= coda_try_fmt_vid_cap(file
, priv
, &f_cap
);
695 return coda_s_fmt(ctx
, &f_cap
);
698 static int coda_reqbufs(struct file
*file
, void *priv
,
699 struct v4l2_requestbuffers
*rb
)
701 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
704 ret
= v4l2_m2m_reqbufs(file
, ctx
->fh
.m2m_ctx
, rb
);
709 * Allow to allocate instance specific per-context buffers, such as
710 * bitstream ringbuffer, slice buffer, work buffer, etc. if needed.
712 if (rb
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&& ctx
->ops
->reqbufs
)
713 return ctx
->ops
->reqbufs(ctx
, rb
);
718 static int coda_qbuf(struct file
*file
, void *priv
,
719 struct v4l2_buffer
*buf
)
721 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
723 return v4l2_m2m_qbuf(file
, ctx
->fh
.m2m_ctx
, buf
);
726 static bool coda_buf_is_end_of_stream(struct coda_ctx
*ctx
,
727 struct vb2_buffer
*buf
)
729 struct vb2_queue
*src_vq
;
731 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
733 return ((ctx
->bit_stream_param
& CODA_BIT_STREAM_END_FLAG
) &&
734 (buf
->v4l2_buf
.sequence
== (ctx
->qsequence
- 1)));
737 void coda_m2m_buf_done(struct coda_ctx
*ctx
, struct vb2_buffer
*buf
,
738 enum vb2_buffer_state state
)
740 const struct v4l2_event eos_event
= {
741 .type
= V4L2_EVENT_EOS
744 if (coda_buf_is_end_of_stream(ctx
, buf
)) {
745 buf
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_LAST
;
747 v4l2_event_queue_fh(&ctx
->fh
, &eos_event
);
750 v4l2_m2m_buf_done(buf
, state
);
753 static int coda_g_selection(struct file
*file
, void *fh
,
754 struct v4l2_selection
*s
)
756 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
757 struct coda_q_data
*q_data
;
758 struct v4l2_rect r
, *rsel
;
760 q_data
= get_q_data(ctx
, s
->type
);
766 r
.width
= q_data
->width
;
767 r
.height
= q_data
->height
;
768 rsel
= &q_data
->rect
;
771 case V4L2_SEL_TGT_CROP_DEFAULT
:
772 case V4L2_SEL_TGT_CROP_BOUNDS
:
775 case V4L2_SEL_TGT_CROP
:
776 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
779 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
780 case V4L2_SEL_TGT_COMPOSE_PADDED
:
783 case V4L2_SEL_TGT_COMPOSE
:
784 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
785 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
797 static int coda_try_decoder_cmd(struct file
*file
, void *fh
,
798 struct v4l2_decoder_cmd
*dc
)
800 if (dc
->cmd
!= V4L2_DEC_CMD_STOP
)
803 if (dc
->flags
& V4L2_DEC_CMD_STOP_TO_BLACK
)
806 if (!(dc
->flags
& V4L2_DEC_CMD_STOP_IMMEDIATELY
) && (dc
->stop
.pts
!= 0))
812 static int coda_decoder_cmd(struct file
*file
, void *fh
,
813 struct v4l2_decoder_cmd
*dc
)
815 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
818 ret
= coda_try_decoder_cmd(file
, fh
, dc
);
822 /* Ignore decoder stop command silently in encoder context */
823 if (ctx
->inst_type
!= CODA_INST_DECODER
)
826 /* Set the stream-end flag on this context */
827 coda_bit_stream_end_flag(ctx
);
829 v4l2_m2m_try_schedule(ctx
->fh
.m2m_ctx
);
834 static int coda_subscribe_event(struct v4l2_fh
*fh
,
835 const struct v4l2_event_subscription
*sub
)
839 return v4l2_event_subscribe(fh
, sub
, 0, NULL
);
841 return v4l2_ctrl_subscribe_event(fh
, sub
);
845 static const struct v4l2_ioctl_ops coda_ioctl_ops
= {
846 .vidioc_querycap
= coda_querycap
,
848 .vidioc_enum_fmt_vid_cap
= coda_enum_fmt
,
849 .vidioc_g_fmt_vid_cap
= coda_g_fmt
,
850 .vidioc_try_fmt_vid_cap
= coda_try_fmt_vid_cap
,
851 .vidioc_s_fmt_vid_cap
= coda_s_fmt_vid_cap
,
853 .vidioc_enum_fmt_vid_out
= coda_enum_fmt
,
854 .vidioc_g_fmt_vid_out
= coda_g_fmt
,
855 .vidioc_try_fmt_vid_out
= coda_try_fmt_vid_out
,
856 .vidioc_s_fmt_vid_out
= coda_s_fmt_vid_out
,
858 .vidioc_reqbufs
= coda_reqbufs
,
859 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
861 .vidioc_qbuf
= coda_qbuf
,
862 .vidioc_expbuf
= v4l2_m2m_ioctl_expbuf
,
863 .vidioc_dqbuf
= v4l2_m2m_ioctl_dqbuf
,
864 .vidioc_create_bufs
= v4l2_m2m_ioctl_create_bufs
,
866 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
867 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
869 .vidioc_g_selection
= coda_g_selection
,
871 .vidioc_try_decoder_cmd
= coda_try_decoder_cmd
,
872 .vidioc_decoder_cmd
= coda_decoder_cmd
,
874 .vidioc_subscribe_event
= coda_subscribe_event
,
875 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
878 void coda_set_gdi_regs(struct coda_ctx
*ctx
)
880 struct gdi_tiled_map
*tiled_map
= &ctx
->tiled_map
;
881 struct coda_dev
*dev
= ctx
->dev
;
884 for (i
= 0; i
< 16; i
++)
885 coda_write(dev
, tiled_map
->xy2ca_map
[i
],
886 CODA9_GDI_XY2_CAS_0
+ 4 * i
);
887 for (i
= 0; i
< 4; i
++)
888 coda_write(dev
, tiled_map
->xy2ba_map
[i
],
889 CODA9_GDI_XY2_BA_0
+ 4 * i
);
890 for (i
= 0; i
< 16; i
++)
891 coda_write(dev
, tiled_map
->xy2ra_map
[i
],
892 CODA9_GDI_XY2_RAS_0
+ 4 * i
);
893 coda_write(dev
, tiled_map
->xy2rbc_config
, CODA9_GDI_XY2_RBC_CONFIG
);
894 for (i
= 0; i
< 32; i
++)
895 coda_write(dev
, tiled_map
->rbc2axi_map
[i
],
896 CODA9_GDI_RBC2_AXI_0
+ 4 * i
);
900 * Mem-to-mem operations.
903 static void coda_device_run(void *m2m_priv
)
905 struct coda_ctx
*ctx
= m2m_priv
;
906 struct coda_dev
*dev
= ctx
->dev
;
908 queue_work(dev
->workqueue
, &ctx
->pic_run_work
);
911 static void coda_pic_run_work(struct work_struct
*work
)
913 struct coda_ctx
*ctx
= container_of(work
, struct coda_ctx
, pic_run_work
);
914 struct coda_dev
*dev
= ctx
->dev
;
917 mutex_lock(&ctx
->buffer_mutex
);
918 mutex_lock(&dev
->coda_mutex
);
920 ret
= ctx
->ops
->prepare_run(ctx
);
921 if (ret
< 0 && ctx
->inst_type
== CODA_INST_DECODER
) {
922 mutex_unlock(&dev
->coda_mutex
);
923 mutex_unlock(&ctx
->buffer_mutex
);
924 /* job_finish scheduled by prepare_decode */
928 if (!wait_for_completion_timeout(&ctx
->completion
,
929 msecs_to_jiffies(1000))) {
930 dev_err(&dev
->plat_dev
->dev
, "CODA PIC_RUN timeout\n");
935 } else if (!ctx
->aborting
) {
936 ctx
->ops
->finish_run(ctx
);
939 if ((ctx
->aborting
|| (!ctx
->streamon_cap
&& !ctx
->streamon_out
)) &&
940 ctx
->ops
->seq_end_work
)
941 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
943 mutex_unlock(&dev
->coda_mutex
);
944 mutex_unlock(&ctx
->buffer_mutex
);
946 v4l2_m2m_job_finish(ctx
->dev
->m2m_dev
, ctx
->fh
.m2m_ctx
);
949 static int coda_job_ready(void *m2m_priv
)
951 struct coda_ctx
*ctx
= m2m_priv
;
954 * For both 'P' and 'key' frame cases 1 picture
955 * and 1 frame are needed. In the decoder case,
956 * the compressed frame can be in the bitstream.
958 if (!v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
) &&
959 ctx
->inst_type
!= CODA_INST_DECODER
) {
960 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
961 "not ready: not enough video buffers.\n");
965 if (!v4l2_m2m_num_dst_bufs_ready(ctx
->fh
.m2m_ctx
)) {
966 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
967 "not ready: not enough video capture buffers.\n");
971 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
) {
972 struct list_head
*meta
;
977 if (ctx
->hold
&& !v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
)) {
978 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
979 "%d: not ready: on hold for more buffers.\n",
984 stream_end
= ctx
->bit_stream_param
&
985 CODA_BIT_STREAM_END_FLAG
;
988 list_for_each(meta
, &ctx
->buffer_meta_list
)
991 src_bufs
= v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
);
993 if (!stream_end
&& (num_metas
+ src_bufs
) < 2) {
994 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
995 "%d: not ready: need 2 buffers available (%d, %d)\n",
996 ctx
->idx
, num_metas
, src_bufs
);
1001 if (!v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
) &&
1002 !stream_end
&& (coda_get_bitstream_payload(ctx
) < 512)) {
1003 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1004 "%d: not ready: not enough bitstream data (%d).\n",
1005 ctx
->idx
, coda_get_bitstream_payload(ctx
));
1010 if (ctx
->aborting
) {
1011 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1012 "not ready: aborting\n");
1016 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1021 static void coda_job_abort(void *priv
)
1023 struct coda_ctx
*ctx
= priv
;
1027 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1031 static void coda_lock(void *m2m_priv
)
1033 struct coda_ctx
*ctx
= m2m_priv
;
1034 struct coda_dev
*pcdev
= ctx
->dev
;
1036 mutex_lock(&pcdev
->dev_mutex
);
1039 static void coda_unlock(void *m2m_priv
)
1041 struct coda_ctx
*ctx
= m2m_priv
;
1042 struct coda_dev
*pcdev
= ctx
->dev
;
1044 mutex_unlock(&pcdev
->dev_mutex
);
1047 static const struct v4l2_m2m_ops coda_m2m_ops
= {
1048 .device_run
= coda_device_run
,
1049 .job_ready
= coda_job_ready
,
1050 .job_abort
= coda_job_abort
,
1052 .unlock
= coda_unlock
,
1055 static void coda_set_tiled_map_type(struct coda_ctx
*ctx
, int tiled_map_type
)
1057 struct gdi_tiled_map
*tiled_map
= &ctx
->tiled_map
;
1058 int luma_map
, chro_map
, i
;
1060 memset(tiled_map
, 0, sizeof(*tiled_map
));
1064 tiled_map
->map_type
= tiled_map_type
;
1065 for (i
= 0; i
< 16; i
++)
1066 tiled_map
->xy2ca_map
[i
] = luma_map
<< 8 | chro_map
;
1067 for (i
= 0; i
< 4; i
++)
1068 tiled_map
->xy2ba_map
[i
] = luma_map
<< 8 | chro_map
;
1069 for (i
= 0; i
< 16; i
++)
1070 tiled_map
->xy2ra_map
[i
] = luma_map
<< 8 | chro_map
;
1072 if (tiled_map_type
== GDI_LINEAR_FRAME_MAP
) {
1073 tiled_map
->xy2rbc_config
= 0;
1075 dev_err(&ctx
->dev
->plat_dev
->dev
, "invalid map type: %d\n",
1081 static void set_default_params(struct coda_ctx
*ctx
)
1083 unsigned int max_w
, max_h
, usize
, csize
;
1085 ctx
->codec
= coda_find_codec(ctx
->dev
, ctx
->cvd
->src_formats
[0],
1086 ctx
->cvd
->dst_formats
[0]);
1087 max_w
= min(ctx
->codec
->max_w
, 1920U);
1088 max_h
= min(ctx
->codec
->max_h
, 1088U);
1089 usize
= max_w
* max_h
* 3 / 2;
1090 csize
= coda_estimate_sizeimage(ctx
, usize
, max_w
, max_h
);
1092 ctx
->params
.codec_mode
= ctx
->codec
->mode
;
1093 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
1094 ctx
->params
.framerate
= 30;
1096 /* Default formats for output and input queues */
1097 ctx
->q_data
[V4L2_M2M_SRC
].fourcc
= ctx
->codec
->src_fourcc
;
1098 ctx
->q_data
[V4L2_M2M_DST
].fourcc
= ctx
->codec
->dst_fourcc
;
1099 ctx
->q_data
[V4L2_M2M_SRC
].width
= max_w
;
1100 ctx
->q_data
[V4L2_M2M_SRC
].height
= max_h
;
1101 ctx
->q_data
[V4L2_M2M_DST
].width
= max_w
;
1102 ctx
->q_data
[V4L2_M2M_DST
].height
= max_h
;
1103 if (ctx
->codec
->src_fourcc
== V4L2_PIX_FMT_YUV420
) {
1104 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= max_w
;
1105 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= usize
;
1106 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= 0;
1107 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= csize
;
1109 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= 0;
1110 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= csize
;
1111 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= max_w
;
1112 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= usize
;
1114 ctx
->q_data
[V4L2_M2M_SRC
].rect
.width
= max_w
;
1115 ctx
->q_data
[V4L2_M2M_SRC
].rect
.height
= max_h
;
1116 ctx
->q_data
[V4L2_M2M_DST
].rect
.width
= max_w
;
1117 ctx
->q_data
[V4L2_M2M_DST
].rect
.height
= max_h
;
1119 if (ctx
->dev
->devtype
->product
== CODA_960
)
1120 coda_set_tiled_map_type(ctx
, GDI_LINEAR_FRAME_MAP
);
1126 static int coda_queue_setup(struct vb2_queue
*vq
,
1127 const struct v4l2_format
*fmt
,
1128 unsigned int *nbuffers
, unsigned int *nplanes
,
1129 unsigned int sizes
[], void *alloc_ctxs
[])
1131 struct coda_ctx
*ctx
= vb2_get_drv_priv(vq
);
1132 struct coda_q_data
*q_data
;
1135 q_data
= get_q_data(ctx
, vq
->type
);
1136 size
= q_data
->sizeimage
;
1141 /* Set to vb2-dma-contig allocator context, ignored by vb2-vmalloc */
1142 alloc_ctxs
[0] = ctx
->dev
->alloc_ctx
;
1144 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1145 "get %d buffer(s) of size %d each.\n", *nbuffers
, size
);
1150 static int coda_buf_prepare(struct vb2_buffer
*vb
)
1152 struct coda_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
1153 struct coda_q_data
*q_data
;
1155 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
1157 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
1158 v4l2_warn(&ctx
->dev
->v4l2_dev
,
1159 "%s data will not fit into plane (%lu < %lu)\n",
1160 __func__
, vb2_plane_size(vb
, 0),
1161 (long)q_data
->sizeimage
);
1168 static void coda_buf_queue(struct vb2_buffer
*vb
)
1170 struct coda_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
1171 struct vb2_queue
*vq
= vb
->vb2_queue
;
1172 struct coda_q_data
*q_data
;
1174 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
1177 * In the decoder case, immediately try to copy the buffer into the
1178 * bitstream ringbuffer and mark it as ready to be dequeued.
1180 if (ctx
->bitstream
.size
&& vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1182 * For backwards compatibility, queuing an empty buffer marks
1185 if (vb2_get_plane_payload(vb
, 0) == 0)
1186 coda_bit_stream_end_flag(ctx
);
1187 mutex_lock(&ctx
->bitstream_mutex
);
1188 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
1189 if (vb2_is_streaming(vb
->vb2_queue
))
1190 coda_fill_bitstream(ctx
, true);
1191 mutex_unlock(&ctx
->bitstream_mutex
);
1193 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
1197 int coda_alloc_aux_buf(struct coda_dev
*dev
, struct coda_aux_buf
*buf
,
1198 size_t size
, const char *name
, struct dentry
*parent
)
1200 buf
->vaddr
= dma_alloc_coherent(&dev
->plat_dev
->dev
, size
, &buf
->paddr
,
1203 v4l2_err(&dev
->v4l2_dev
,
1204 "Failed to allocate %s buffer of size %u\n",
1211 if (name
&& parent
) {
1212 buf
->blob
.data
= buf
->vaddr
;
1213 buf
->blob
.size
= size
;
1214 buf
->dentry
= debugfs_create_blob(name
, 0644, parent
,
1217 dev_warn(&dev
->plat_dev
->dev
,
1218 "failed to create debugfs entry %s\n", name
);
1224 void coda_free_aux_buf(struct coda_dev
*dev
,
1225 struct coda_aux_buf
*buf
)
1228 dma_free_coherent(&dev
->plat_dev
->dev
, buf
->size
,
1229 buf
->vaddr
, buf
->paddr
);
1232 debugfs_remove(buf
->dentry
);
1237 static int coda_start_streaming(struct vb2_queue
*q
, unsigned int count
)
1239 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1240 struct v4l2_device
*v4l2_dev
= &ctx
->dev
->v4l2_dev
;
1241 struct coda_q_data
*q_data_src
, *q_data_dst
;
1242 struct vb2_buffer
*buf
;
1245 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1246 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1247 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
) {
1248 /* copy the buffers that were queued before streamon */
1249 mutex_lock(&ctx
->bitstream_mutex
);
1250 coda_fill_bitstream(ctx
, false);
1251 mutex_unlock(&ctx
->bitstream_mutex
);
1253 if (coda_get_bitstream_payload(ctx
) < 512) {
1264 ctx
->streamon_out
= 1;
1271 ctx
->streamon_cap
= 1;
1274 /* Don't start the coda unless both queues are on */
1275 if (!(ctx
->streamon_out
& ctx
->streamon_cap
))
1278 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
1279 if ((q_data_src
->width
!= q_data_dst
->width
&&
1280 round_up(q_data_src
->width
, 16) != q_data_dst
->width
) ||
1281 (q_data_src
->height
!= q_data_dst
->height
&&
1282 round_up(q_data_src
->height
, 16) != q_data_dst
->height
)) {
1283 v4l2_err(v4l2_dev
, "can't convert %dx%d to %dx%d\n",
1284 q_data_src
->width
, q_data_src
->height
,
1285 q_data_dst
->width
, q_data_dst
->height
);
1290 /* Allow BIT decoder device_run with no new buffers queued */
1291 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1292 v4l2_m2m_set_src_buffered(ctx
->fh
.m2m_ctx
, true);
1294 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1296 ctx
->codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
1297 q_data_dst
->fourcc
);
1299 v4l2_err(v4l2_dev
, "couldn't tell instance type.\n");
1304 if (q_data_dst
->fourcc
== V4L2_PIX_FMT_JPEG
)
1305 ctx
->params
.gop_size
= 1;
1306 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1308 ret
= ctx
->ops
->start_streaming(ctx
);
1309 if (ctx
->inst_type
== CODA_INST_DECODER
) {
1319 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1320 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1321 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1323 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1324 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1329 static void coda_stop_streaming(struct vb2_queue
*q
)
1331 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1332 struct coda_dev
*dev
= ctx
->dev
;
1333 struct vb2_buffer
*buf
;
1336 stop
= ctx
->streamon_out
&& ctx
->streamon_cap
;
1338 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1339 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1340 "%s: output\n", __func__
);
1341 ctx
->streamon_out
= 0;
1343 coda_bit_stream_end_flag(ctx
);
1347 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1348 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1350 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1351 "%s: capture\n", __func__
);
1352 ctx
->streamon_cap
= 0;
1355 ctx
->sequence_offset
= 0;
1357 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1358 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1362 struct coda_buffer_meta
*meta
;
1364 if (ctx
->ops
->seq_end_work
) {
1365 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1366 flush_work(&ctx
->seq_end_work
);
1368 mutex_lock(&ctx
->bitstream_mutex
);
1369 while (!list_empty(&ctx
->buffer_meta_list
)) {
1370 meta
= list_first_entry(&ctx
->buffer_meta_list
,
1371 struct coda_buffer_meta
, list
);
1372 list_del(&meta
->list
);
1375 mutex_unlock(&ctx
->bitstream_mutex
);
1376 kfifo_init(&ctx
->bitstream_fifo
,
1377 ctx
->bitstream
.vaddr
, ctx
->bitstream
.size
);
1378 ctx
->runcounter
= 0;
1382 if (!ctx
->streamon_out
&& !ctx
->streamon_cap
)
1383 ctx
->bit_stream_param
&= ~CODA_BIT_STREAM_END_FLAG
;
1386 static const struct vb2_ops coda_qops
= {
1387 .queue_setup
= coda_queue_setup
,
1388 .buf_prepare
= coda_buf_prepare
,
1389 .buf_queue
= coda_buf_queue
,
1390 .start_streaming
= coda_start_streaming
,
1391 .stop_streaming
= coda_stop_streaming
,
1392 .wait_prepare
= vb2_ops_wait_prepare
,
1393 .wait_finish
= vb2_ops_wait_finish
,
1396 static int coda_s_ctrl(struct v4l2_ctrl
*ctrl
)
1398 struct coda_ctx
*ctx
=
1399 container_of(ctrl
->handler
, struct coda_ctx
, ctrls
);
1401 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1402 "s_ctrl: id = %d, val = %d\n", ctrl
->id
, ctrl
->val
);
1405 case V4L2_CID_HFLIP
:
1407 ctx
->params
.rot_mode
|= CODA_MIR_HOR
;
1409 ctx
->params
.rot_mode
&= ~CODA_MIR_HOR
;
1411 case V4L2_CID_VFLIP
:
1413 ctx
->params
.rot_mode
|= CODA_MIR_VER
;
1415 ctx
->params
.rot_mode
&= ~CODA_MIR_VER
;
1417 case V4L2_CID_MPEG_VIDEO_BITRATE
:
1418 ctx
->params
.bitrate
= ctrl
->val
/ 1000;
1420 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1421 ctx
->params
.gop_size
= ctrl
->val
;
1423 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
:
1424 ctx
->params
.h264_intra_qp
= ctrl
->val
;
1426 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
:
1427 ctx
->params
.h264_inter_qp
= ctrl
->val
;
1429 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1430 ctx
->params
.h264_min_qp
= ctrl
->val
;
1432 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP
:
1433 ctx
->params
.h264_max_qp
= ctrl
->val
;
1435 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
:
1436 ctx
->params
.h264_deblk_alpha
= ctrl
->val
;
1438 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
:
1439 ctx
->params
.h264_deblk_beta
= ctrl
->val
;
1441 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
:
1442 ctx
->params
.h264_deblk_enabled
= (ctrl
->val
==
1443 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1445 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
:
1446 ctx
->params
.mpeg4_intra_qp
= ctrl
->val
;
1448 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
:
1449 ctx
->params
.mpeg4_inter_qp
= ctrl
->val
;
1451 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
:
1452 ctx
->params
.slice_mode
= ctrl
->val
;
1454 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
:
1455 ctx
->params
.slice_max_mb
= ctrl
->val
;
1457 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
:
1458 ctx
->params
.slice_max_bits
= ctrl
->val
* 8;
1460 case V4L2_CID_MPEG_VIDEO_HEADER_MODE
:
1462 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
:
1463 ctx
->params
.intra_refresh
= ctrl
->val
;
1465 case V4L2_CID_JPEG_COMPRESSION_QUALITY
:
1466 coda_set_jpeg_compression_quality(ctx
, ctrl
->val
);
1468 case V4L2_CID_JPEG_RESTART_INTERVAL
:
1469 ctx
->params
.jpeg_restart_interval
= ctrl
->val
;
1472 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1473 "Invalid control, id=%d, val=%d\n",
1474 ctrl
->id
, ctrl
->val
);
1481 static const struct v4l2_ctrl_ops coda_ctrl_ops
= {
1482 .s_ctrl
= coda_s_ctrl
,
1485 static void coda_encode_ctrls(struct coda_ctx
*ctx
)
1487 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1488 V4L2_CID_MPEG_VIDEO_BITRATE
, 0, 32767000, 1000, 0);
1489 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1490 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 60, 1, 16);
1491 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1492 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
, 0, 51, 1, 25);
1493 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1494 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
, 0, 51, 1, 25);
1495 if (ctx
->dev
->devtype
->product
!= CODA_960
) {
1496 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1497 V4L2_CID_MPEG_VIDEO_H264_MIN_QP
, 0, 51, 1, 12);
1499 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1500 V4L2_CID_MPEG_VIDEO_H264_MAX_QP
, 0, 51, 1, 51);
1501 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1502 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
, 0, 15, 1, 0);
1503 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1504 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
, 0, 15, 1, 0);
1505 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1506 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
,
1507 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED
, 0x0,
1508 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1509 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1510 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
, 1, 31, 1, 2);
1511 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1512 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
, 1, 31, 1, 2);
1513 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1514 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
,
1515 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES
, 0x0,
1516 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
);
1517 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1518 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
, 1, 0x3fffffff, 1, 1);
1519 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1520 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
, 1, 0x3fffffff, 1,
1522 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1523 V4L2_CID_MPEG_VIDEO_HEADER_MODE
,
1524 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
,
1525 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
),
1526 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
);
1527 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1528 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
, 0,
1529 1920 * 1088 / 256, 1, 0);
1532 static void coda_jpeg_encode_ctrls(struct coda_ctx
*ctx
)
1534 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1535 V4L2_CID_JPEG_COMPRESSION_QUALITY
, 5, 100, 1, 50);
1536 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1537 V4L2_CID_JPEG_RESTART_INTERVAL
, 0, 100, 1, 0);
1540 static int coda_ctrls_setup(struct coda_ctx
*ctx
)
1542 v4l2_ctrl_handler_init(&ctx
->ctrls
, 2);
1544 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1545 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1546 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1547 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1548 if (ctx
->inst_type
== CODA_INST_ENCODER
) {
1549 if (ctx
->cvd
->dst_formats
[0] == V4L2_PIX_FMT_JPEG
)
1550 coda_jpeg_encode_ctrls(ctx
);
1552 coda_encode_ctrls(ctx
);
1555 if (ctx
->ctrls
.error
) {
1556 v4l2_err(&ctx
->dev
->v4l2_dev
,
1557 "control initialization error (%d)",
1562 return v4l2_ctrl_handler_setup(&ctx
->ctrls
);
1565 static int coda_queue_init(struct coda_ctx
*ctx
, struct vb2_queue
*vq
)
1568 vq
->ops
= &coda_qops
;
1569 vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
1570 vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
1571 vq
->lock
= &ctx
->dev
->dev_mutex
;
1572 /* One way to indicate end-of-stream for coda is to set the
1573 * bytesused == 0. However by default videobuf2 handles bytesused
1574 * equal to 0 as a special case and changes its value to the size
1575 * of the buffer. Set the allow_zero_bytesused flag, so
1576 * that videobuf2 will keep the value of bytesused intact.
1578 vq
->allow_zero_bytesused
= 1;
1580 return vb2_queue_init(vq
);
1583 int coda_encoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1584 struct vb2_queue
*dst_vq
)
1588 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1589 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1590 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
1592 ret
= coda_queue_init(priv
, src_vq
);
1596 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1597 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1598 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1600 return coda_queue_init(priv
, dst_vq
);
1603 int coda_decoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1604 struct vb2_queue
*dst_vq
)
1608 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1609 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
| VB2_USERPTR
;
1610 src_vq
->mem_ops
= &vb2_vmalloc_memops
;
1612 ret
= coda_queue_init(priv
, src_vq
);
1616 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1617 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1618 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1620 return coda_queue_init(priv
, dst_vq
);
1623 static int coda_next_free_instance(struct coda_dev
*dev
)
1625 int idx
= ffz(dev
->instance_mask
);
1628 (dev
->devtype
->product
== CODA_DX6
&& idx
> CODADX6_MAX_INSTANCES
))
1638 static int coda_open(struct file
*file
)
1640 struct video_device
*vdev
= video_devdata(file
);
1641 struct coda_dev
*dev
= video_get_drvdata(vdev
);
1642 struct coda_ctx
*ctx
= NULL
;
1647 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
1651 idx
= coda_next_free_instance(dev
);
1656 set_bit(idx
, &dev
->instance_mask
);
1658 name
= kasprintf(GFP_KERNEL
, "context%d", idx
);
1661 goto err_coda_name_init
;
1664 ctx
->debugfs_entry
= debugfs_create_dir(name
, dev
->debugfs_root
);
1667 ctx
->cvd
= to_coda_video_device(vdev
);
1668 ctx
->inst_type
= ctx
->cvd
->type
;
1669 ctx
->ops
= ctx
->cvd
->ops
;
1670 ctx
->use_bit
= !ctx
->cvd
->direct
;
1671 init_completion(&ctx
->completion
);
1672 INIT_WORK(&ctx
->pic_run_work
, coda_pic_run_work
);
1673 if (ctx
->ops
->seq_end_work
)
1674 INIT_WORK(&ctx
->seq_end_work
, ctx
->ops
->seq_end_work
);
1675 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
1676 file
->private_data
= &ctx
->fh
;
1677 v4l2_fh_add(&ctx
->fh
);
1680 switch (dev
->devtype
->product
) {
1682 ctx
->frame_mem_ctrl
= 1 << 12;
1691 /* Power up and upload firmware if necessary */
1692 ret
= pm_runtime_get_sync(&dev
->plat_dev
->dev
);
1694 v4l2_err(&dev
->v4l2_dev
, "failed to power up: %d\n", ret
);
1698 ret
= clk_prepare_enable(dev
->clk_per
);
1702 ret
= clk_prepare_enable(dev
->clk_ahb
);
1706 set_default_params(ctx
);
1707 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
,
1708 ctx
->ops
->queue_init
);
1709 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
1710 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
1712 v4l2_err(&dev
->v4l2_dev
, "%s return error (%d)\n",
1717 ret
= coda_ctrls_setup(ctx
);
1719 v4l2_err(&dev
->v4l2_dev
, "failed to setup coda controls\n");
1720 goto err_ctrls_setup
;
1723 ctx
->fh
.ctrl_handler
= &ctx
->ctrls
;
1725 mutex_init(&ctx
->bitstream_mutex
);
1726 mutex_init(&ctx
->buffer_mutex
);
1727 INIT_LIST_HEAD(&ctx
->buffer_meta_list
);
1730 list_add(&ctx
->list
, &dev
->instances
);
1733 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Created instance %d (%p)\n",
1739 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1741 clk_disable_unprepare(dev
->clk_ahb
);
1743 clk_disable_unprepare(dev
->clk_per
);
1745 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1747 v4l2_fh_del(&ctx
->fh
);
1748 v4l2_fh_exit(&ctx
->fh
);
1749 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1756 static int coda_release(struct file
*file
)
1758 struct coda_dev
*dev
= video_drvdata(file
);
1759 struct coda_ctx
*ctx
= fh_to_ctx(file
->private_data
);
1761 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Releasing instance %p\n",
1764 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1765 coda_bit_stream_end_flag(ctx
);
1767 /* If this instance is running, call .job_abort and wait for it to end */
1768 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1770 /* In case the instance was not running, we still need to call SEQ_END */
1771 if (ctx
->ops
->seq_end_work
) {
1772 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1773 flush_work(&ctx
->seq_end_work
);
1777 list_del(&ctx
->list
);
1780 if (ctx
->dev
->devtype
->product
== CODA_DX6
)
1781 coda_free_aux_buf(dev
, &ctx
->workbuf
);
1783 v4l2_ctrl_handler_free(&ctx
->ctrls
);
1784 clk_disable_unprepare(dev
->clk_ahb
);
1785 clk_disable_unprepare(dev
->clk_per
);
1786 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1787 v4l2_fh_del(&ctx
->fh
);
1788 v4l2_fh_exit(&ctx
->fh
);
1789 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1790 if (ctx
->ops
->release
)
1791 ctx
->ops
->release(ctx
);
1792 debugfs_remove_recursive(ctx
->debugfs_entry
);
1798 static const struct v4l2_file_operations coda_fops
= {
1799 .owner
= THIS_MODULE
,
1801 .release
= coda_release
,
1802 .poll
= v4l2_m2m_fop_poll
,
1803 .unlocked_ioctl
= video_ioctl2
,
1804 .mmap
= v4l2_m2m_fop_mmap
,
1807 static int coda_hw_init(struct coda_dev
*dev
)
1813 ret
= clk_prepare_enable(dev
->clk_per
);
1817 ret
= clk_prepare_enable(dev
->clk_ahb
);
1822 reset_control_reset(dev
->rstc
);
1825 * Copy the first CODA_ISRAM_SIZE in the internal SRAM.
1826 * The 16-bit chars in the code buffer are in memory access
1827 * order, re-sort them to CODA order for register download.
1828 * Data in this SRAM survives a reboot.
1830 p
= (u16
*)dev
->codebuf
.vaddr
;
1831 if (dev
->devtype
->product
== CODA_DX6
) {
1832 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1833 data
= CODA_DOWN_ADDRESS_SET(i
) |
1834 CODA_DOWN_DATA_SET(p
[i
^ 1]);
1835 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1838 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1839 data
= CODA_DOWN_ADDRESS_SET(i
) |
1840 CODA_DOWN_DATA_SET(p
[round_down(i
, 4) +
1842 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1846 /* Clear registers */
1847 for (i
= 0; i
< 64; i
++)
1848 coda_write(dev
, 0, CODA_REG_BIT_CODE_BUF_ADDR
+ i
* 4);
1850 /* Tell the BIT where to find everything it needs */
1851 if (dev
->devtype
->product
== CODA_960
||
1852 dev
->devtype
->product
== CODA_7541
) {
1853 coda_write(dev
, dev
->tempbuf
.paddr
,
1854 CODA_REG_BIT_TEMP_BUF_ADDR
);
1855 coda_write(dev
, 0, CODA_REG_BIT_BIT_STREAM_PARAM
);
1857 coda_write(dev
, dev
->workbuf
.paddr
,
1858 CODA_REG_BIT_WORK_BUF_ADDR
);
1860 coda_write(dev
, dev
->codebuf
.paddr
,
1861 CODA_REG_BIT_CODE_BUF_ADDR
);
1862 coda_write(dev
, 0, CODA_REG_BIT_CODE_RUN
);
1864 /* Set default values */
1865 switch (dev
->devtype
->product
) {
1867 coda_write(dev
, CODADX6_STREAM_BUF_PIC_FLUSH
,
1868 CODA_REG_BIT_STREAM_CTRL
);
1871 coda_write(dev
, CODA7_STREAM_BUF_PIC_FLUSH
,
1872 CODA_REG_BIT_STREAM_CTRL
);
1874 if (dev
->devtype
->product
== CODA_960
)
1875 coda_write(dev
, 1 << 12, CODA_REG_BIT_FRAME_MEM_CTRL
);
1877 coda_write(dev
, 0, CODA_REG_BIT_FRAME_MEM_CTRL
);
1879 if (dev
->devtype
->product
!= CODA_DX6
)
1880 coda_write(dev
, 0, CODA7_REG_BIT_AXI_SRAM_USE
);
1882 coda_write(dev
, CODA_INT_INTERRUPT_ENABLE
,
1883 CODA_REG_BIT_INT_ENABLE
);
1885 /* Reset VPU and start processor */
1886 data
= coda_read(dev
, CODA_REG_BIT_CODE_RESET
);
1887 data
|= CODA_REG_RESET_ENABLE
;
1888 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1890 data
&= ~CODA_REG_RESET_ENABLE
;
1891 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1892 coda_write(dev
, CODA_REG_RUN_ENABLE
, CODA_REG_BIT_CODE_RUN
);
1894 clk_disable_unprepare(dev
->clk_ahb
);
1895 clk_disable_unprepare(dev
->clk_per
);
1900 clk_disable_unprepare(dev
->clk_per
);
1905 static int coda_register_device(struct coda_dev
*dev
, int i
)
1907 struct video_device
*vfd
= &dev
->vfd
[i
];
1909 if (i
>= dev
->devtype
->num_vdevs
)
1912 strlcpy(vfd
->name
, dev
->devtype
->vdevs
[i
]->name
, sizeof(vfd
->name
));
1913 vfd
->fops
= &coda_fops
;
1914 vfd
->ioctl_ops
= &coda_ioctl_ops
;
1915 vfd
->release
= video_device_release_empty
,
1916 vfd
->lock
= &dev
->dev_mutex
;
1917 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1918 vfd
->vfl_dir
= VFL_DIR_M2M
;
1919 video_set_drvdata(vfd
, dev
);
1921 /* Not applicable, use the selection API instead */
1922 v4l2_disable_ioctl(vfd
, VIDIOC_CROPCAP
);
1923 v4l2_disable_ioctl(vfd
, VIDIOC_G_CROP
);
1924 v4l2_disable_ioctl(vfd
, VIDIOC_S_CROP
);
1926 return video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1929 static void coda_fw_callback(const struct firmware
*fw
, void *context
)
1931 struct coda_dev
*dev
= context
;
1932 struct platform_device
*pdev
= dev
->plat_dev
;
1936 v4l2_err(&dev
->v4l2_dev
, "firmware request failed\n");
1940 /* allocate auxiliary per-device code buffer for the BIT processor */
1941 ret
= coda_alloc_aux_buf(dev
, &dev
->codebuf
, fw
->size
, "codebuf",
1946 /* Copy the whole firmware image to the code buffer */
1947 memcpy(dev
->codebuf
.vaddr
, fw
->data
, fw
->size
);
1948 release_firmware(fw
);
1950 ret
= coda_hw_init(dev
);
1952 v4l2_err(&dev
->v4l2_dev
, "HW initialization failed\n");
1956 ret
= coda_check_firmware(dev
);
1960 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1961 if (IS_ERR(dev
->alloc_ctx
)) {
1962 v4l2_err(&dev
->v4l2_dev
, "Failed to alloc vb2 context\n");
1966 dev
->m2m_dev
= v4l2_m2m_init(&coda_m2m_ops
);
1967 if (IS_ERR(dev
->m2m_dev
)) {
1968 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1972 for (i
= 0; i
< dev
->devtype
->num_vdevs
; i
++) {
1973 ret
= coda_register_device(dev
, i
);
1975 v4l2_err(&dev
->v4l2_dev
,
1976 "Failed to register %s video device: %d\n",
1977 dev
->devtype
->vdevs
[i
]->name
, ret
);
1982 v4l2_info(&dev
->v4l2_dev
, "codec registered as /dev/video[%d-%d]\n",
1983 dev
->vfd
[0].num
, dev
->vfd
[i
- 1].num
);
1985 pm_runtime_put_sync(&pdev
->dev
);
1990 video_unregister_device(&dev
->vfd
[i
]);
1991 v4l2_m2m_release(dev
->m2m_dev
);
1993 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
1995 pm_runtime_put_sync(&pdev
->dev
);
1998 static int coda_firmware_request(struct coda_dev
*dev
)
2000 char *fw
= dev
->devtype
->firmware
;
2002 dev_dbg(&dev
->plat_dev
->dev
, "requesting firmware '%s' for %s\n", fw
,
2003 coda_product_name(dev
->devtype
->product
));
2005 return request_firmware_nowait(THIS_MODULE
, true,
2006 fw
, &dev
->plat_dev
->dev
, GFP_KERNEL
, dev
, coda_fw_callback
);
2009 enum coda_platform
{
2016 static const struct coda_devtype coda_devdata
[] = {
2018 .firmware
= "v4l-codadx6-imx27.bin",
2019 .product
= CODA_DX6
,
2020 .codecs
= codadx6_codecs
,
2021 .num_codecs
= ARRAY_SIZE(codadx6_codecs
),
2022 .vdevs
= codadx6_video_devices
,
2023 .num_vdevs
= ARRAY_SIZE(codadx6_video_devices
),
2024 .workbuf_size
= 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE
* 8 * 1024,
2025 .iram_size
= 0xb000,
2028 .firmware
= "v4l-coda7541-imx53.bin",
2029 .product
= CODA_7541
,
2030 .codecs
= coda7_codecs
,
2031 .num_codecs
= ARRAY_SIZE(coda7_codecs
),
2032 .vdevs
= coda7_video_devices
,
2033 .num_vdevs
= ARRAY_SIZE(coda7_video_devices
),
2034 .workbuf_size
= 128 * 1024,
2035 .tempbuf_size
= 304 * 1024,
2036 .iram_size
= 0x14000,
2039 .firmware
= "v4l-coda960-imx6q.bin",
2040 .product
= CODA_960
,
2041 .codecs
= coda9_codecs
,
2042 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2043 .vdevs
= coda9_video_devices
,
2044 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2045 .workbuf_size
= 80 * 1024,
2046 .tempbuf_size
= 204 * 1024,
2047 .iram_size
= 0x21000,
2050 .firmware
= "v4l-coda960-imx6dl.bin",
2051 .product
= CODA_960
,
2052 .codecs
= coda9_codecs
,
2053 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2054 .vdevs
= coda9_video_devices
,
2055 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2056 .workbuf_size
= 80 * 1024,
2057 .tempbuf_size
= 204 * 1024,
2058 .iram_size
= 0x20000,
2062 static struct platform_device_id coda_platform_ids
[] = {
2063 { .name
= "coda-imx27", .driver_data
= CODA_IMX27
},
2066 MODULE_DEVICE_TABLE(platform
, coda_platform_ids
);
2069 static const struct of_device_id coda_dt_ids
[] = {
2070 { .compatible
= "fsl,imx27-vpu", .data
= &coda_devdata
[CODA_IMX27
] },
2071 { .compatible
= "fsl,imx53-vpu", .data
= &coda_devdata
[CODA_IMX53
] },
2072 { .compatible
= "fsl,imx6q-vpu", .data
= &coda_devdata
[CODA_IMX6Q
] },
2073 { .compatible
= "fsl,imx6dl-vpu", .data
= &coda_devdata
[CODA_IMX6DL
] },
2076 MODULE_DEVICE_TABLE(of
, coda_dt_ids
);
2079 static int coda_probe(struct platform_device
*pdev
)
2081 const struct of_device_id
*of_id
=
2082 of_match_device(of_match_ptr(coda_dt_ids
), &pdev
->dev
);
2083 const struct platform_device_id
*pdev_id
;
2084 struct coda_platform_data
*pdata
= pdev
->dev
.platform_data
;
2085 struct device_node
*np
= pdev
->dev
.of_node
;
2086 struct gen_pool
*pool
;
2087 struct coda_dev
*dev
;
2088 struct resource
*res
;
2091 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
2095 pdev_id
= of_id
? of_id
->data
: platform_get_device_id(pdev
);
2098 dev
->devtype
= of_id
->data
;
2099 } else if (pdev_id
) {
2100 dev
->devtype
= &coda_devdata
[pdev_id
->driver_data
];
2103 goto err_v4l2_register
;
2106 spin_lock_init(&dev
->irqlock
);
2107 INIT_LIST_HEAD(&dev
->instances
);
2109 dev
->plat_dev
= pdev
;
2110 dev
->clk_per
= devm_clk_get(&pdev
->dev
, "per");
2111 if (IS_ERR(dev
->clk_per
)) {
2112 dev_err(&pdev
->dev
, "Could not get per clock\n");
2113 return PTR_ERR(dev
->clk_per
);
2116 dev
->clk_ahb
= devm_clk_get(&pdev
->dev
, "ahb");
2117 if (IS_ERR(dev
->clk_ahb
)) {
2118 dev_err(&pdev
->dev
, "Could not get ahb clock\n");
2119 return PTR_ERR(dev
->clk_ahb
);
2122 /* Get memory for physical registers */
2123 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2124 dev
->regs_base
= devm_ioremap_resource(&pdev
->dev
, res
);
2125 if (IS_ERR(dev
->regs_base
))
2126 return PTR_ERR(dev
->regs_base
);
2129 irq
= platform_get_irq_byname(pdev
, "bit");
2131 irq
= platform_get_irq(pdev
, 0);
2133 dev_err(&pdev
->dev
, "failed to get irq resource\n");
2137 ret
= devm_request_threaded_irq(&pdev
->dev
, irq
, NULL
, coda_irq_handler
,
2138 IRQF_ONESHOT
, dev_name(&pdev
->dev
), dev
);
2140 dev_err(&pdev
->dev
, "failed to request irq: %d\n", ret
);
2144 dev
->rstc
= devm_reset_control_get_optional(&pdev
->dev
, NULL
);
2145 if (IS_ERR(dev
->rstc
)) {
2146 ret
= PTR_ERR(dev
->rstc
);
2147 if (ret
== -ENOENT
|| ret
== -ENOSYS
) {
2150 dev_err(&pdev
->dev
, "failed get reset control: %d\n",
2156 /* Get IRAM pool from device tree or platform data */
2157 pool
= of_gen_pool_get(np
, "iram", 0);
2159 pool
= gen_pool_get(pdata
->iram_dev
);
2161 dev_err(&pdev
->dev
, "iram pool not available\n");
2164 dev
->iram_pool
= pool
;
2166 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
2170 mutex_init(&dev
->dev_mutex
);
2171 mutex_init(&dev
->coda_mutex
);
2173 dev
->debugfs_root
= debugfs_create_dir("coda", NULL
);
2174 if (!dev
->debugfs_root
)
2175 dev_warn(&pdev
->dev
, "failed to create debugfs root\n");
2177 /* allocate auxiliary per-device buffers for the BIT processor */
2178 if (dev
->devtype
->product
== CODA_DX6
) {
2179 ret
= coda_alloc_aux_buf(dev
, &dev
->workbuf
,
2180 dev
->devtype
->workbuf_size
, "workbuf",
2183 goto err_v4l2_register
;
2186 if (dev
->devtype
->tempbuf_size
) {
2187 ret
= coda_alloc_aux_buf(dev
, &dev
->tempbuf
,
2188 dev
->devtype
->tempbuf_size
, "tempbuf",
2191 goto err_v4l2_register
;
2194 dev
->iram
.size
= dev
->devtype
->iram_size
;
2195 dev
->iram
.vaddr
= gen_pool_dma_alloc(dev
->iram_pool
, dev
->iram
.size
,
2197 if (!dev
->iram
.vaddr
) {
2198 dev_warn(&pdev
->dev
, "unable to alloc iram\n");
2200 memset(dev
->iram
.vaddr
, 0, dev
->iram
.size
);
2201 dev
->iram
.blob
.data
= dev
->iram
.vaddr
;
2202 dev
->iram
.blob
.size
= dev
->iram
.size
;
2203 dev
->iram
.dentry
= debugfs_create_blob("iram", 0644,
2208 dev
->workqueue
= alloc_workqueue("coda", WQ_UNBOUND
| WQ_MEM_RECLAIM
, 1);
2209 if (!dev
->workqueue
) {
2210 dev_err(&pdev
->dev
, "unable to alloc workqueue\n");
2212 goto err_v4l2_register
;
2215 platform_set_drvdata(pdev
, dev
);
2218 * Start activated so we can directly call coda_hw_init in
2219 * coda_fw_callback regardless of whether CONFIG_PM is
2220 * enabled or whether the device is associated with a PM domain.
2222 pm_runtime_get_noresume(&pdev
->dev
);
2223 pm_runtime_set_active(&pdev
->dev
);
2224 pm_runtime_enable(&pdev
->dev
);
2226 return coda_firmware_request(dev
);
2229 v4l2_device_unregister(&dev
->v4l2_dev
);
2233 static int coda_remove(struct platform_device
*pdev
)
2235 struct coda_dev
*dev
= platform_get_drvdata(pdev
);
2238 for (i
= 0; i
< ARRAY_SIZE(dev
->vfd
); i
++) {
2239 if (video_get_drvdata(&dev
->vfd
[i
]))
2240 video_unregister_device(&dev
->vfd
[i
]);
2243 v4l2_m2m_release(dev
->m2m_dev
);
2244 pm_runtime_disable(&pdev
->dev
);
2246 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
2247 v4l2_device_unregister(&dev
->v4l2_dev
);
2248 destroy_workqueue(dev
->workqueue
);
2249 if (dev
->iram
.vaddr
)
2250 gen_pool_free(dev
->iram_pool
, (unsigned long)dev
->iram
.vaddr
,
2252 coda_free_aux_buf(dev
, &dev
->codebuf
);
2253 coda_free_aux_buf(dev
, &dev
->tempbuf
);
2254 coda_free_aux_buf(dev
, &dev
->workbuf
);
2255 debugfs_remove_recursive(dev
->debugfs_root
);
2260 static int coda_runtime_resume(struct device
*dev
)
2262 struct coda_dev
*cdev
= dev_get_drvdata(dev
);
2265 if (dev
->pm_domain
&& cdev
->codebuf
.vaddr
) {
2266 ret
= coda_hw_init(cdev
);
2268 v4l2_err(&cdev
->v4l2_dev
, "HW initialization failed\n");
2275 static const struct dev_pm_ops coda_pm_ops
= {
2276 SET_RUNTIME_PM_OPS(NULL
, coda_runtime_resume
, NULL
)
2279 static struct platform_driver coda_driver
= {
2280 .probe
= coda_probe
,
2281 .remove
= coda_remove
,
2284 .of_match_table
= of_match_ptr(coda_dt_ids
),
2287 .id_table
= coda_platform_ids
,
2290 module_platform_driver(coda_driver
);
2292 MODULE_LICENSE("GPL");
2293 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
2294 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");