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 (q_data_src
->fourcc
== V4L2_PIX_FMT_H264
||
1248 (q_data_src
->fourcc
== V4L2_PIX_FMT_JPEG
&&
1249 ctx
->dev
->devtype
->product
== CODA_7541
)) {
1250 /* copy the buffers that were queued before streamon */
1251 mutex_lock(&ctx
->bitstream_mutex
);
1252 coda_fill_bitstream(ctx
, false);
1253 mutex_unlock(&ctx
->bitstream_mutex
);
1255 if (coda_get_bitstream_payload(ctx
) < 512) {
1266 ctx
->streamon_out
= 1;
1273 ctx
->streamon_cap
= 1;
1276 /* Don't start the coda unless both queues are on */
1277 if (!(ctx
->streamon_out
& ctx
->streamon_cap
))
1280 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
1281 if ((q_data_src
->width
!= q_data_dst
->width
&&
1282 round_up(q_data_src
->width
, 16) != q_data_dst
->width
) ||
1283 (q_data_src
->height
!= q_data_dst
->height
&&
1284 round_up(q_data_src
->height
, 16) != q_data_dst
->height
)) {
1285 v4l2_err(v4l2_dev
, "can't convert %dx%d to %dx%d\n",
1286 q_data_src
->width
, q_data_src
->height
,
1287 q_data_dst
->width
, q_data_dst
->height
);
1292 /* Allow BIT decoder device_run with no new buffers queued */
1293 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1294 v4l2_m2m_set_src_buffered(ctx
->fh
.m2m_ctx
, true);
1296 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1298 ctx
->codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
1299 q_data_dst
->fourcc
);
1301 v4l2_err(v4l2_dev
, "couldn't tell instance type.\n");
1306 if (q_data_dst
->fourcc
== V4L2_PIX_FMT_JPEG
)
1307 ctx
->params
.gop_size
= 1;
1308 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1310 ret
= ctx
->ops
->start_streaming(ctx
);
1311 if (ctx
->inst_type
== CODA_INST_DECODER
) {
1318 ctx
->initialized
= 1;
1322 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1323 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1324 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1326 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1327 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1332 static void coda_stop_streaming(struct vb2_queue
*q
)
1334 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1335 struct coda_dev
*dev
= ctx
->dev
;
1336 struct vb2_buffer
*buf
;
1339 stop
= ctx
->streamon_out
&& ctx
->streamon_cap
;
1341 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1342 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1343 "%s: output\n", __func__
);
1344 ctx
->streamon_out
= 0;
1346 coda_bit_stream_end_flag(ctx
);
1350 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1351 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1353 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1354 "%s: capture\n", __func__
);
1355 ctx
->streamon_cap
= 0;
1358 ctx
->sequence_offset
= 0;
1360 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1361 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1365 struct coda_buffer_meta
*meta
;
1367 if (ctx
->ops
->seq_end_work
) {
1368 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1369 flush_work(&ctx
->seq_end_work
);
1371 mutex_lock(&ctx
->bitstream_mutex
);
1372 while (!list_empty(&ctx
->buffer_meta_list
)) {
1373 meta
= list_first_entry(&ctx
->buffer_meta_list
,
1374 struct coda_buffer_meta
, list
);
1375 list_del(&meta
->list
);
1378 mutex_unlock(&ctx
->bitstream_mutex
);
1379 kfifo_init(&ctx
->bitstream_fifo
,
1380 ctx
->bitstream
.vaddr
, ctx
->bitstream
.size
);
1381 ctx
->initialized
= 0;
1382 ctx
->runcounter
= 0;
1387 static const struct vb2_ops coda_qops
= {
1388 .queue_setup
= coda_queue_setup
,
1389 .buf_prepare
= coda_buf_prepare
,
1390 .buf_queue
= coda_buf_queue
,
1391 .start_streaming
= coda_start_streaming
,
1392 .stop_streaming
= coda_stop_streaming
,
1393 .wait_prepare
= vb2_ops_wait_prepare
,
1394 .wait_finish
= vb2_ops_wait_finish
,
1397 static int coda_s_ctrl(struct v4l2_ctrl
*ctrl
)
1399 struct coda_ctx
*ctx
=
1400 container_of(ctrl
->handler
, struct coda_ctx
, ctrls
);
1402 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1403 "s_ctrl: id = %d, val = %d\n", ctrl
->id
, ctrl
->val
);
1406 case V4L2_CID_HFLIP
:
1408 ctx
->params
.rot_mode
|= CODA_MIR_HOR
;
1410 ctx
->params
.rot_mode
&= ~CODA_MIR_HOR
;
1412 case V4L2_CID_VFLIP
:
1414 ctx
->params
.rot_mode
|= CODA_MIR_VER
;
1416 ctx
->params
.rot_mode
&= ~CODA_MIR_VER
;
1418 case V4L2_CID_MPEG_VIDEO_BITRATE
:
1419 ctx
->params
.bitrate
= ctrl
->val
/ 1000;
1421 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1422 ctx
->params
.gop_size
= ctrl
->val
;
1424 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
:
1425 ctx
->params
.h264_intra_qp
= ctrl
->val
;
1427 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
:
1428 ctx
->params
.h264_inter_qp
= ctrl
->val
;
1430 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1431 ctx
->params
.h264_min_qp
= ctrl
->val
;
1433 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP
:
1434 ctx
->params
.h264_max_qp
= ctrl
->val
;
1436 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
:
1437 ctx
->params
.h264_deblk_alpha
= ctrl
->val
;
1439 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
:
1440 ctx
->params
.h264_deblk_beta
= ctrl
->val
;
1442 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
:
1443 ctx
->params
.h264_deblk_enabled
= (ctrl
->val
==
1444 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1446 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
:
1447 ctx
->params
.mpeg4_intra_qp
= ctrl
->val
;
1449 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
:
1450 ctx
->params
.mpeg4_inter_qp
= ctrl
->val
;
1452 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
:
1453 ctx
->params
.slice_mode
= ctrl
->val
;
1455 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
:
1456 ctx
->params
.slice_max_mb
= ctrl
->val
;
1458 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
:
1459 ctx
->params
.slice_max_bits
= ctrl
->val
* 8;
1461 case V4L2_CID_MPEG_VIDEO_HEADER_MODE
:
1463 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
:
1464 ctx
->params
.intra_refresh
= ctrl
->val
;
1466 case V4L2_CID_JPEG_COMPRESSION_QUALITY
:
1467 coda_set_jpeg_compression_quality(ctx
, ctrl
->val
);
1469 case V4L2_CID_JPEG_RESTART_INTERVAL
:
1470 ctx
->params
.jpeg_restart_interval
= ctrl
->val
;
1473 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1474 "Invalid control, id=%d, val=%d\n",
1475 ctrl
->id
, ctrl
->val
);
1482 static const struct v4l2_ctrl_ops coda_ctrl_ops
= {
1483 .s_ctrl
= coda_s_ctrl
,
1486 static void coda_encode_ctrls(struct coda_ctx
*ctx
)
1488 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1489 V4L2_CID_MPEG_VIDEO_BITRATE
, 0, 32767000, 1000, 0);
1490 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1491 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 60, 1, 16);
1492 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1493 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
, 0, 51, 1, 25);
1494 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1495 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
, 0, 51, 1, 25);
1496 if (ctx
->dev
->devtype
->product
!= CODA_960
) {
1497 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1498 V4L2_CID_MPEG_VIDEO_H264_MIN_QP
, 0, 51, 1, 12);
1500 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1501 V4L2_CID_MPEG_VIDEO_H264_MAX_QP
, 0, 51, 1, 51);
1502 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1503 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
, 0, 15, 1, 0);
1504 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1505 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
, 0, 15, 1, 0);
1506 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1507 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
,
1508 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED
, 0x0,
1509 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1510 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1511 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
, 1, 31, 1, 2);
1512 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1513 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
, 1, 31, 1, 2);
1514 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1515 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
,
1516 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES
, 0x0,
1517 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
);
1518 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1519 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
, 1, 0x3fffffff, 1, 1);
1520 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1521 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
, 1, 0x3fffffff, 1,
1523 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1524 V4L2_CID_MPEG_VIDEO_HEADER_MODE
,
1525 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
,
1526 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
),
1527 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
);
1528 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1529 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
, 0,
1530 1920 * 1088 / 256, 1, 0);
1533 static void coda_jpeg_encode_ctrls(struct coda_ctx
*ctx
)
1535 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1536 V4L2_CID_JPEG_COMPRESSION_QUALITY
, 5, 100, 1, 50);
1537 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1538 V4L2_CID_JPEG_RESTART_INTERVAL
, 0, 100, 1, 0);
1541 static int coda_ctrls_setup(struct coda_ctx
*ctx
)
1543 v4l2_ctrl_handler_init(&ctx
->ctrls
, 2);
1545 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1546 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1547 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1548 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1549 if (ctx
->inst_type
== CODA_INST_ENCODER
) {
1550 if (ctx
->cvd
->dst_formats
[0] == V4L2_PIX_FMT_JPEG
)
1551 coda_jpeg_encode_ctrls(ctx
);
1553 coda_encode_ctrls(ctx
);
1556 if (ctx
->ctrls
.error
) {
1557 v4l2_err(&ctx
->dev
->v4l2_dev
,
1558 "control initialization error (%d)",
1563 return v4l2_ctrl_handler_setup(&ctx
->ctrls
);
1566 static int coda_queue_init(struct coda_ctx
*ctx
, struct vb2_queue
*vq
)
1569 vq
->ops
= &coda_qops
;
1570 vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
1571 vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
1572 vq
->lock
= &ctx
->dev
->dev_mutex
;
1573 /* One way to indicate end-of-stream for coda is to set the
1574 * bytesused == 0. However by default videobuf2 handles bytesused
1575 * equal to 0 as a special case and changes its value to the size
1576 * of the buffer. Set the allow_zero_bytesused flag, so
1577 * that videobuf2 will keep the value of bytesused intact.
1579 vq
->allow_zero_bytesused
= 1;
1581 return vb2_queue_init(vq
);
1584 int coda_encoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1585 struct vb2_queue
*dst_vq
)
1589 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1590 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1591 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
1593 ret
= coda_queue_init(priv
, src_vq
);
1597 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1598 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1599 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1601 return coda_queue_init(priv
, dst_vq
);
1604 int coda_decoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1605 struct vb2_queue
*dst_vq
)
1609 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1610 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
| VB2_USERPTR
;
1611 src_vq
->mem_ops
= &vb2_vmalloc_memops
;
1613 ret
= coda_queue_init(priv
, src_vq
);
1617 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1618 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1619 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1621 return coda_queue_init(priv
, dst_vq
);
1624 static int coda_next_free_instance(struct coda_dev
*dev
)
1626 int idx
= ffz(dev
->instance_mask
);
1629 (dev
->devtype
->product
== CODA_DX6
&& idx
> CODADX6_MAX_INSTANCES
))
1639 static int coda_open(struct file
*file
)
1641 struct video_device
*vdev
= video_devdata(file
);
1642 struct coda_dev
*dev
= video_get_drvdata(vdev
);
1643 struct coda_ctx
*ctx
= NULL
;
1648 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
1652 idx
= coda_next_free_instance(dev
);
1657 set_bit(idx
, &dev
->instance_mask
);
1659 name
= kasprintf(GFP_KERNEL
, "context%d", idx
);
1662 goto err_coda_name_init
;
1665 ctx
->debugfs_entry
= debugfs_create_dir(name
, dev
->debugfs_root
);
1668 ctx
->cvd
= to_coda_video_device(vdev
);
1669 ctx
->inst_type
= ctx
->cvd
->type
;
1670 ctx
->ops
= ctx
->cvd
->ops
;
1671 ctx
->use_bit
= !ctx
->cvd
->direct
;
1672 init_completion(&ctx
->completion
);
1673 INIT_WORK(&ctx
->pic_run_work
, coda_pic_run_work
);
1674 if (ctx
->ops
->seq_end_work
)
1675 INIT_WORK(&ctx
->seq_end_work
, ctx
->ops
->seq_end_work
);
1676 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
1677 file
->private_data
= &ctx
->fh
;
1678 v4l2_fh_add(&ctx
->fh
);
1681 switch (dev
->devtype
->product
) {
1683 ctx
->frame_mem_ctrl
= 1 << 12;
1692 /* Power up and upload firmware if necessary */
1693 ret
= pm_runtime_get_sync(&dev
->plat_dev
->dev
);
1695 v4l2_err(&dev
->v4l2_dev
, "failed to power up: %d\n", ret
);
1699 ret
= clk_prepare_enable(dev
->clk_per
);
1703 ret
= clk_prepare_enable(dev
->clk_ahb
);
1707 set_default_params(ctx
);
1708 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
,
1709 ctx
->ops
->queue_init
);
1710 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
1711 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
1713 v4l2_err(&dev
->v4l2_dev
, "%s return error (%d)\n",
1718 ret
= coda_ctrls_setup(ctx
);
1720 v4l2_err(&dev
->v4l2_dev
, "failed to setup coda controls\n");
1721 goto err_ctrls_setup
;
1724 ctx
->fh
.ctrl_handler
= &ctx
->ctrls
;
1726 mutex_init(&ctx
->bitstream_mutex
);
1727 mutex_init(&ctx
->buffer_mutex
);
1728 INIT_LIST_HEAD(&ctx
->buffer_meta_list
);
1731 list_add(&ctx
->list
, &dev
->instances
);
1734 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Created instance %d (%p)\n",
1740 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1742 clk_disable_unprepare(dev
->clk_ahb
);
1744 clk_disable_unprepare(dev
->clk_per
);
1746 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1748 v4l2_fh_del(&ctx
->fh
);
1749 v4l2_fh_exit(&ctx
->fh
);
1750 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1757 static int coda_release(struct file
*file
)
1759 struct coda_dev
*dev
= video_drvdata(file
);
1760 struct coda_ctx
*ctx
= fh_to_ctx(file
->private_data
);
1762 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Releasing instance %p\n",
1765 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1766 coda_bit_stream_end_flag(ctx
);
1768 /* If this instance is running, call .job_abort and wait for it to end */
1769 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1771 /* In case the instance was not running, we still need to call SEQ_END */
1772 if (ctx
->initialized
&& ctx
->ops
->seq_end_work
) {
1773 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1774 flush_work(&ctx
->seq_end_work
);
1778 list_del(&ctx
->list
);
1781 if (ctx
->dev
->devtype
->product
== CODA_DX6
)
1782 coda_free_aux_buf(dev
, &ctx
->workbuf
);
1784 v4l2_ctrl_handler_free(&ctx
->ctrls
);
1785 clk_disable_unprepare(dev
->clk_ahb
);
1786 clk_disable_unprepare(dev
->clk_per
);
1787 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1788 v4l2_fh_del(&ctx
->fh
);
1789 v4l2_fh_exit(&ctx
->fh
);
1790 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1791 if (ctx
->ops
->release
)
1792 ctx
->ops
->release(ctx
);
1793 debugfs_remove_recursive(ctx
->debugfs_entry
);
1799 static const struct v4l2_file_operations coda_fops
= {
1800 .owner
= THIS_MODULE
,
1802 .release
= coda_release
,
1803 .poll
= v4l2_m2m_fop_poll
,
1804 .unlocked_ioctl
= video_ioctl2
,
1805 .mmap
= v4l2_m2m_fop_mmap
,
1808 static int coda_hw_init(struct coda_dev
*dev
)
1814 ret
= clk_prepare_enable(dev
->clk_per
);
1818 ret
= clk_prepare_enable(dev
->clk_ahb
);
1823 reset_control_reset(dev
->rstc
);
1826 * Copy the first CODA_ISRAM_SIZE in the internal SRAM.
1827 * The 16-bit chars in the code buffer are in memory access
1828 * order, re-sort them to CODA order for register download.
1829 * Data in this SRAM survives a reboot.
1831 p
= (u16
*)dev
->codebuf
.vaddr
;
1832 if (dev
->devtype
->product
== CODA_DX6
) {
1833 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1834 data
= CODA_DOWN_ADDRESS_SET(i
) |
1835 CODA_DOWN_DATA_SET(p
[i
^ 1]);
1836 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1839 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1840 data
= CODA_DOWN_ADDRESS_SET(i
) |
1841 CODA_DOWN_DATA_SET(p
[round_down(i
, 4) +
1843 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1847 /* Clear registers */
1848 for (i
= 0; i
< 64; i
++)
1849 coda_write(dev
, 0, CODA_REG_BIT_CODE_BUF_ADDR
+ i
* 4);
1851 /* Tell the BIT where to find everything it needs */
1852 if (dev
->devtype
->product
== CODA_960
||
1853 dev
->devtype
->product
== CODA_7541
) {
1854 coda_write(dev
, dev
->tempbuf
.paddr
,
1855 CODA_REG_BIT_TEMP_BUF_ADDR
);
1856 coda_write(dev
, 0, CODA_REG_BIT_BIT_STREAM_PARAM
);
1858 coda_write(dev
, dev
->workbuf
.paddr
,
1859 CODA_REG_BIT_WORK_BUF_ADDR
);
1861 coda_write(dev
, dev
->codebuf
.paddr
,
1862 CODA_REG_BIT_CODE_BUF_ADDR
);
1863 coda_write(dev
, 0, CODA_REG_BIT_CODE_RUN
);
1865 /* Set default values */
1866 switch (dev
->devtype
->product
) {
1868 coda_write(dev
, CODADX6_STREAM_BUF_PIC_FLUSH
,
1869 CODA_REG_BIT_STREAM_CTRL
);
1872 coda_write(dev
, CODA7_STREAM_BUF_PIC_FLUSH
,
1873 CODA_REG_BIT_STREAM_CTRL
);
1875 if (dev
->devtype
->product
== CODA_960
)
1876 coda_write(dev
, 1 << 12, CODA_REG_BIT_FRAME_MEM_CTRL
);
1878 coda_write(dev
, 0, CODA_REG_BIT_FRAME_MEM_CTRL
);
1880 if (dev
->devtype
->product
!= CODA_DX6
)
1881 coda_write(dev
, 0, CODA7_REG_BIT_AXI_SRAM_USE
);
1883 coda_write(dev
, CODA_INT_INTERRUPT_ENABLE
,
1884 CODA_REG_BIT_INT_ENABLE
);
1886 /* Reset VPU and start processor */
1887 data
= coda_read(dev
, CODA_REG_BIT_CODE_RESET
);
1888 data
|= CODA_REG_RESET_ENABLE
;
1889 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1891 data
&= ~CODA_REG_RESET_ENABLE
;
1892 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1893 coda_write(dev
, CODA_REG_RUN_ENABLE
, CODA_REG_BIT_CODE_RUN
);
1895 clk_disable_unprepare(dev
->clk_ahb
);
1896 clk_disable_unprepare(dev
->clk_per
);
1901 clk_disable_unprepare(dev
->clk_per
);
1906 static int coda_register_device(struct coda_dev
*dev
, int i
)
1908 struct video_device
*vfd
= &dev
->vfd
[i
];
1910 if (i
>= dev
->devtype
->num_vdevs
)
1913 strlcpy(vfd
->name
, dev
->devtype
->vdevs
[i
]->name
, sizeof(vfd
->name
));
1914 vfd
->fops
= &coda_fops
;
1915 vfd
->ioctl_ops
= &coda_ioctl_ops
;
1916 vfd
->release
= video_device_release_empty
,
1917 vfd
->lock
= &dev
->dev_mutex
;
1918 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1919 vfd
->vfl_dir
= VFL_DIR_M2M
;
1920 video_set_drvdata(vfd
, dev
);
1922 /* Not applicable, use the selection API instead */
1923 v4l2_disable_ioctl(vfd
, VIDIOC_CROPCAP
);
1924 v4l2_disable_ioctl(vfd
, VIDIOC_G_CROP
);
1925 v4l2_disable_ioctl(vfd
, VIDIOC_S_CROP
);
1927 return video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1930 static void coda_fw_callback(const struct firmware
*fw
, void *context
)
1932 struct coda_dev
*dev
= context
;
1933 struct platform_device
*pdev
= dev
->plat_dev
;
1937 v4l2_err(&dev
->v4l2_dev
, "firmware request failed\n");
1941 /* allocate auxiliary per-device code buffer for the BIT processor */
1942 ret
= coda_alloc_aux_buf(dev
, &dev
->codebuf
, fw
->size
, "codebuf",
1947 /* Copy the whole firmware image to the code buffer */
1948 memcpy(dev
->codebuf
.vaddr
, fw
->data
, fw
->size
);
1949 release_firmware(fw
);
1951 ret
= coda_hw_init(dev
);
1953 v4l2_err(&dev
->v4l2_dev
, "HW initialization failed\n");
1957 ret
= coda_check_firmware(dev
);
1961 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1962 if (IS_ERR(dev
->alloc_ctx
)) {
1963 v4l2_err(&dev
->v4l2_dev
, "Failed to alloc vb2 context\n");
1967 dev
->m2m_dev
= v4l2_m2m_init(&coda_m2m_ops
);
1968 if (IS_ERR(dev
->m2m_dev
)) {
1969 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1973 for (i
= 0; i
< dev
->devtype
->num_vdevs
; i
++) {
1974 ret
= coda_register_device(dev
, i
);
1976 v4l2_err(&dev
->v4l2_dev
,
1977 "Failed to register %s video device: %d\n",
1978 dev
->devtype
->vdevs
[i
]->name
, ret
);
1983 v4l2_info(&dev
->v4l2_dev
, "codec registered as /dev/video[%d-%d]\n",
1984 dev
->vfd
[0].num
, dev
->vfd
[i
- 1].num
);
1986 pm_runtime_put_sync(&pdev
->dev
);
1991 video_unregister_device(&dev
->vfd
[i
]);
1992 v4l2_m2m_release(dev
->m2m_dev
);
1994 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
1996 pm_runtime_put_sync(&pdev
->dev
);
1999 static int coda_firmware_request(struct coda_dev
*dev
)
2001 char *fw
= dev
->devtype
->firmware
;
2003 dev_dbg(&dev
->plat_dev
->dev
, "requesting firmware '%s' for %s\n", fw
,
2004 coda_product_name(dev
->devtype
->product
));
2006 return request_firmware_nowait(THIS_MODULE
, true,
2007 fw
, &dev
->plat_dev
->dev
, GFP_KERNEL
, dev
, coda_fw_callback
);
2010 enum coda_platform
{
2017 static const struct coda_devtype coda_devdata
[] = {
2019 .firmware
= "v4l-codadx6-imx27.bin",
2020 .product
= CODA_DX6
,
2021 .codecs
= codadx6_codecs
,
2022 .num_codecs
= ARRAY_SIZE(codadx6_codecs
),
2023 .vdevs
= codadx6_video_devices
,
2024 .num_vdevs
= ARRAY_SIZE(codadx6_video_devices
),
2025 .workbuf_size
= 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE
* 8 * 1024,
2026 .iram_size
= 0xb000,
2029 .firmware
= "v4l-coda7541-imx53.bin",
2030 .product
= CODA_7541
,
2031 .codecs
= coda7_codecs
,
2032 .num_codecs
= ARRAY_SIZE(coda7_codecs
),
2033 .vdevs
= coda7_video_devices
,
2034 .num_vdevs
= ARRAY_SIZE(coda7_video_devices
),
2035 .workbuf_size
= 128 * 1024,
2036 .tempbuf_size
= 304 * 1024,
2037 .iram_size
= 0x14000,
2040 .firmware
= "v4l-coda960-imx6q.bin",
2041 .product
= CODA_960
,
2042 .codecs
= coda9_codecs
,
2043 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2044 .vdevs
= coda9_video_devices
,
2045 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2046 .workbuf_size
= 80 * 1024,
2047 .tempbuf_size
= 204 * 1024,
2048 .iram_size
= 0x21000,
2051 .firmware
= "v4l-coda960-imx6dl.bin",
2052 .product
= CODA_960
,
2053 .codecs
= coda9_codecs
,
2054 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2055 .vdevs
= coda9_video_devices
,
2056 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2057 .workbuf_size
= 80 * 1024,
2058 .tempbuf_size
= 204 * 1024,
2059 .iram_size
= 0x20000,
2063 static struct platform_device_id coda_platform_ids
[] = {
2064 { .name
= "coda-imx27", .driver_data
= CODA_IMX27
},
2067 MODULE_DEVICE_TABLE(platform
, coda_platform_ids
);
2070 static const struct of_device_id coda_dt_ids
[] = {
2071 { .compatible
= "fsl,imx27-vpu", .data
= &coda_devdata
[CODA_IMX27
] },
2072 { .compatible
= "fsl,imx53-vpu", .data
= &coda_devdata
[CODA_IMX53
] },
2073 { .compatible
= "fsl,imx6q-vpu", .data
= &coda_devdata
[CODA_IMX6Q
] },
2074 { .compatible
= "fsl,imx6dl-vpu", .data
= &coda_devdata
[CODA_IMX6DL
] },
2077 MODULE_DEVICE_TABLE(of
, coda_dt_ids
);
2080 static int coda_probe(struct platform_device
*pdev
)
2082 const struct of_device_id
*of_id
=
2083 of_match_device(of_match_ptr(coda_dt_ids
), &pdev
->dev
);
2084 const struct platform_device_id
*pdev_id
;
2085 struct coda_platform_data
*pdata
= pdev
->dev
.platform_data
;
2086 struct device_node
*np
= pdev
->dev
.of_node
;
2087 struct gen_pool
*pool
;
2088 struct coda_dev
*dev
;
2089 struct resource
*res
;
2092 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
2096 pdev_id
= of_id
? of_id
->data
: platform_get_device_id(pdev
);
2099 dev
->devtype
= of_id
->data
;
2100 } else if (pdev_id
) {
2101 dev
->devtype
= &coda_devdata
[pdev_id
->driver_data
];
2104 goto err_v4l2_register
;
2107 spin_lock_init(&dev
->irqlock
);
2108 INIT_LIST_HEAD(&dev
->instances
);
2110 dev
->plat_dev
= pdev
;
2111 dev
->clk_per
= devm_clk_get(&pdev
->dev
, "per");
2112 if (IS_ERR(dev
->clk_per
)) {
2113 dev_err(&pdev
->dev
, "Could not get per clock\n");
2114 return PTR_ERR(dev
->clk_per
);
2117 dev
->clk_ahb
= devm_clk_get(&pdev
->dev
, "ahb");
2118 if (IS_ERR(dev
->clk_ahb
)) {
2119 dev_err(&pdev
->dev
, "Could not get ahb clock\n");
2120 return PTR_ERR(dev
->clk_ahb
);
2123 /* Get memory for physical registers */
2124 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2125 dev
->regs_base
= devm_ioremap_resource(&pdev
->dev
, res
);
2126 if (IS_ERR(dev
->regs_base
))
2127 return PTR_ERR(dev
->regs_base
);
2130 irq
= platform_get_irq_byname(pdev
, "bit");
2132 irq
= platform_get_irq(pdev
, 0);
2134 dev_err(&pdev
->dev
, "failed to get irq resource\n");
2138 ret
= devm_request_threaded_irq(&pdev
->dev
, irq
, NULL
, coda_irq_handler
,
2139 IRQF_ONESHOT
, dev_name(&pdev
->dev
), dev
);
2141 dev_err(&pdev
->dev
, "failed to request irq: %d\n", ret
);
2145 dev
->rstc
= devm_reset_control_get_optional(&pdev
->dev
, NULL
);
2146 if (IS_ERR(dev
->rstc
)) {
2147 ret
= PTR_ERR(dev
->rstc
);
2148 if (ret
== -ENOENT
|| ret
== -ENOSYS
) {
2151 dev_err(&pdev
->dev
, "failed get reset control: %d\n",
2157 /* Get IRAM pool from device tree or platform data */
2158 pool
= of_gen_pool_get(np
, "iram", 0);
2160 pool
= gen_pool_get(pdata
->iram_dev
);
2162 dev_err(&pdev
->dev
, "iram pool not available\n");
2165 dev
->iram_pool
= pool
;
2167 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
2171 mutex_init(&dev
->dev_mutex
);
2172 mutex_init(&dev
->coda_mutex
);
2174 dev
->debugfs_root
= debugfs_create_dir("coda", NULL
);
2175 if (!dev
->debugfs_root
)
2176 dev_warn(&pdev
->dev
, "failed to create debugfs root\n");
2178 /* allocate auxiliary per-device buffers for the BIT processor */
2179 if (dev
->devtype
->product
== CODA_DX6
) {
2180 ret
= coda_alloc_aux_buf(dev
, &dev
->workbuf
,
2181 dev
->devtype
->workbuf_size
, "workbuf",
2184 goto err_v4l2_register
;
2187 if (dev
->devtype
->tempbuf_size
) {
2188 ret
= coda_alloc_aux_buf(dev
, &dev
->tempbuf
,
2189 dev
->devtype
->tempbuf_size
, "tempbuf",
2192 goto err_v4l2_register
;
2195 dev
->iram
.size
= dev
->devtype
->iram_size
;
2196 dev
->iram
.vaddr
= gen_pool_dma_alloc(dev
->iram_pool
, dev
->iram
.size
,
2198 if (!dev
->iram
.vaddr
) {
2199 dev_warn(&pdev
->dev
, "unable to alloc iram\n");
2201 memset(dev
->iram
.vaddr
, 0, dev
->iram
.size
);
2202 dev
->iram
.blob
.data
= dev
->iram
.vaddr
;
2203 dev
->iram
.blob
.size
= dev
->iram
.size
;
2204 dev
->iram
.dentry
= debugfs_create_blob("iram", 0644,
2209 dev
->workqueue
= alloc_workqueue("coda", WQ_UNBOUND
| WQ_MEM_RECLAIM
, 1);
2210 if (!dev
->workqueue
) {
2211 dev_err(&pdev
->dev
, "unable to alloc workqueue\n");
2213 goto err_v4l2_register
;
2216 platform_set_drvdata(pdev
, dev
);
2219 * Start activated so we can directly call coda_hw_init in
2220 * coda_fw_callback regardless of whether CONFIG_PM is
2221 * enabled or whether the device is associated with a PM domain.
2223 pm_runtime_get_noresume(&pdev
->dev
);
2224 pm_runtime_set_active(&pdev
->dev
);
2225 pm_runtime_enable(&pdev
->dev
);
2227 return coda_firmware_request(dev
);
2230 v4l2_device_unregister(&dev
->v4l2_dev
);
2234 static int coda_remove(struct platform_device
*pdev
)
2236 struct coda_dev
*dev
= platform_get_drvdata(pdev
);
2239 for (i
= 0; i
< ARRAY_SIZE(dev
->vfd
); i
++) {
2240 if (video_get_drvdata(&dev
->vfd
[i
]))
2241 video_unregister_device(&dev
->vfd
[i
]);
2244 v4l2_m2m_release(dev
->m2m_dev
);
2245 pm_runtime_disable(&pdev
->dev
);
2247 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
2248 v4l2_device_unregister(&dev
->v4l2_dev
);
2249 destroy_workqueue(dev
->workqueue
);
2250 if (dev
->iram
.vaddr
)
2251 gen_pool_free(dev
->iram_pool
, (unsigned long)dev
->iram
.vaddr
,
2253 coda_free_aux_buf(dev
, &dev
->codebuf
);
2254 coda_free_aux_buf(dev
, &dev
->tempbuf
);
2255 coda_free_aux_buf(dev
, &dev
->workbuf
);
2256 debugfs_remove_recursive(dev
->debugfs_root
);
2261 static int coda_runtime_resume(struct device
*dev
)
2263 struct coda_dev
*cdev
= dev_get_drvdata(dev
);
2266 if (dev
->pm_domain
&& cdev
->codebuf
.vaddr
) {
2267 ret
= coda_hw_init(cdev
);
2269 v4l2_err(&cdev
->v4l2_dev
, "HW initialization failed\n");
2276 static const struct dev_pm_ops coda_pm_ops
= {
2277 SET_RUNTIME_PM_OPS(NULL
, coda_runtime_resume
, NULL
)
2280 static struct platform_driver coda_driver
= {
2281 .probe
= coda_probe
,
2282 .remove
= coda_remove
,
2285 .of_match_table
= of_match_ptr(coda_dt_ids
),
2288 .id_table
= coda_platform_ids
,
2291 module_platform_driver(coda_driver
);
2293 MODULE_LICENSE("GPL");
2294 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
2295 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");