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>
43 #define CODA_NAME "coda"
45 #define CODADX6_MAX_INSTANCES 4
46 #define CODA_MAX_FORMATS 4
48 #define CODA_PARA_BUF_SIZE (10 * 1024)
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
;
183 u32 src_formats
[CODA_MAX_FORMATS
];
184 u32 dst_formats
[CODA_MAX_FORMATS
];
187 static const struct coda_video_device coda_bit_encoder
= {
188 .name
= "coda-encoder",
189 .type
= CODA_INST_ENCODER
,
190 .ops
= &coda_bit_encode_ops
,
202 static const struct coda_video_device coda_bit_jpeg_encoder
= {
203 .name
= "coda-jpeg-encoder",
204 .type
= CODA_INST_ENCODER
,
205 .ops
= &coda_bit_encode_ops
,
210 V4L2_PIX_FMT_YUV422P
,
217 static const struct coda_video_device coda_bit_decoder
= {
218 .name
= "coda-decoder",
219 .type
= CODA_INST_DECODER
,
220 .ops
= &coda_bit_decode_ops
,
232 static const struct coda_video_device coda_bit_jpeg_decoder
= {
233 .name
= "coda-jpeg-decoder",
234 .type
= CODA_INST_DECODER
,
235 .ops
= &coda_bit_decode_ops
,
243 V4L2_PIX_FMT_YUV422P
,
247 static const struct coda_video_device
*codadx6_video_devices
[] = {
251 static const struct coda_video_device
*coda7_video_devices
[] = {
252 &coda_bit_jpeg_encoder
,
253 &coda_bit_jpeg_decoder
,
258 static const struct coda_video_device
*coda9_video_devices
[] = {
263 static bool coda_format_is_yuv(u32 fourcc
)
266 case V4L2_PIX_FMT_YUV420
:
267 case V4L2_PIX_FMT_YVU420
:
268 case V4L2_PIX_FMT_NV12
:
269 case V4L2_PIX_FMT_YUV422P
:
276 static const char *coda_format_name(u32 fourcc
)
280 for (i
= 0; i
< ARRAY_SIZE(coda_formats
); i
++) {
281 if (coda_formats
[i
].fourcc
== fourcc
)
282 return coda_formats
[i
].name
;
289 * Normalize all supported YUV 4:2:0 formats to the value used in the codec
292 static u32
coda_format_normalize_yuv(u32 fourcc
)
294 return coda_format_is_yuv(fourcc
) ? V4L2_PIX_FMT_YUV420
: fourcc
;
297 static const struct coda_codec
*coda_find_codec(struct coda_dev
*dev
,
298 int src_fourcc
, int dst_fourcc
)
300 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
301 int num_codecs
= dev
->devtype
->num_codecs
;
304 src_fourcc
= coda_format_normalize_yuv(src_fourcc
);
305 dst_fourcc
= coda_format_normalize_yuv(dst_fourcc
);
306 if (src_fourcc
== dst_fourcc
)
309 for (k
= 0; k
< num_codecs
; k
++) {
310 if (codecs
[k
].src_fourcc
== src_fourcc
&&
311 codecs
[k
].dst_fourcc
== dst_fourcc
)
321 static void coda_get_max_dimensions(struct coda_dev
*dev
,
322 const struct coda_codec
*codec
,
323 int *max_w
, int *max_h
)
325 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
326 int num_codecs
= dev
->devtype
->num_codecs
;
334 for (k
= 0, w
= 0, h
= 0; k
< num_codecs
; k
++) {
335 w
= max(w
, codecs
[k
].max_w
);
336 h
= max(h
, codecs
[k
].max_h
);
346 const struct coda_video_device
*to_coda_video_device(struct video_device
*vdev
)
348 struct coda_dev
*dev
= video_get_drvdata(vdev
);
349 unsigned int i
= vdev
- dev
->vfd
;
351 if (i
>= dev
->devtype
->num_vdevs
)
354 return dev
->devtype
->vdevs
[i
];
357 const char *coda_product_name(int product
)
369 snprintf(buf
, sizeof(buf
), "(0x%04x)", product
);
375 * V4L2 ioctl() operations.
377 static int coda_querycap(struct file
*file
, void *priv
,
378 struct v4l2_capability
*cap
)
380 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
382 strlcpy(cap
->driver
, CODA_NAME
, sizeof(cap
->driver
));
383 strlcpy(cap
->card
, coda_product_name(ctx
->dev
->devtype
->product
),
385 strlcpy(cap
->bus_info
, "platform:" CODA_NAME
, sizeof(cap
->bus_info
));
386 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
387 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
392 static int coda_enum_fmt(struct file
*file
, void *priv
,
393 struct v4l2_fmtdesc
*f
)
395 struct video_device
*vdev
= video_devdata(file
);
396 const struct coda_video_device
*cvd
= to_coda_video_device(vdev
);
400 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
401 formats
= cvd
->src_formats
;
402 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
403 formats
= cvd
->dst_formats
;
407 if (f
->index
>= CODA_MAX_FORMATS
|| formats
[f
->index
] == 0)
410 name
= coda_format_name(formats
[f
->index
]);
411 strlcpy(f
->description
, name
, sizeof(f
->description
));
412 f
->pixelformat
= formats
[f
->index
];
413 if (!coda_format_is_yuv(formats
[f
->index
]))
414 f
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
419 static int coda_g_fmt(struct file
*file
, void *priv
,
420 struct v4l2_format
*f
)
422 struct coda_q_data
*q_data
;
423 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
425 q_data
= get_q_data(ctx
, f
->type
);
429 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
430 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
431 f
->fmt
.pix
.width
= q_data
->width
;
432 f
->fmt
.pix
.height
= q_data
->height
;
433 f
->fmt
.pix
.bytesperline
= q_data
->bytesperline
;
435 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
436 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
437 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
439 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
444 static int coda_try_pixelformat(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
446 struct coda_q_data
*q_data
;
450 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
451 formats
= ctx
->cvd
->src_formats
;
452 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
453 formats
= ctx
->cvd
->dst_formats
;
457 for (i
= 0; i
< CODA_MAX_FORMATS
; i
++) {
458 if (formats
[i
] == f
->fmt
.pix
.pixelformat
) {
459 f
->fmt
.pix
.pixelformat
= formats
[i
];
464 /* Fall back to currently set pixelformat */
465 q_data
= get_q_data(ctx
, f
->type
);
466 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
471 static unsigned int coda_estimate_sizeimage(struct coda_ctx
*ctx
, u32 sizeimage
,
472 u32 width
, u32 height
)
475 * This is a rough estimate for sensible compressed buffer
476 * sizes (between 1 and 16 bits per pixel). This could be
477 * improved by better format specific worst case estimates.
479 return round_up(clamp(sizeimage
, width
* height
/ 8,
480 width
* height
* 2), PAGE_SIZE
);
483 static int coda_try_fmt(struct coda_ctx
*ctx
, const struct coda_codec
*codec
,
484 struct v4l2_format
*f
)
486 struct coda_dev
*dev
= ctx
->dev
;
487 unsigned int max_w
, max_h
;
488 enum v4l2_field field
;
490 field
= f
->fmt
.pix
.field
;
491 if (field
== V4L2_FIELD_ANY
)
492 field
= V4L2_FIELD_NONE
;
493 else if (V4L2_FIELD_NONE
!= field
)
496 /* V4L2 specification suggests the driver corrects the format struct
497 * if any of the dimensions is unsupported */
498 f
->fmt
.pix
.field
= field
;
500 coda_get_max_dimensions(dev
, codec
, &max_w
, &max_h
);
501 v4l_bound_align_image(&f
->fmt
.pix
.width
, MIN_W
, max_w
, W_ALIGN
,
502 &f
->fmt
.pix
.height
, MIN_H
, max_h
, H_ALIGN
,
505 switch (f
->fmt
.pix
.pixelformat
) {
506 case V4L2_PIX_FMT_YUV420
:
507 case V4L2_PIX_FMT_YVU420
:
508 case V4L2_PIX_FMT_NV12
:
510 * Frame stride must be at least multiple of 8,
511 * but multiple of 16 for h.264 or JPEG 4:2:x
513 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
514 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
515 f
->fmt
.pix
.height
* 3 / 2;
517 case V4L2_PIX_FMT_YUV422P
:
518 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
519 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
520 f
->fmt
.pix
.height
* 2;
522 case V4L2_PIX_FMT_JPEG
:
523 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
525 case V4L2_PIX_FMT_H264
:
526 case V4L2_PIX_FMT_MPEG4
:
527 f
->fmt
.pix
.bytesperline
= 0;
528 f
->fmt
.pix
.sizeimage
= coda_estimate_sizeimage(ctx
,
529 f
->fmt
.pix
.sizeimage
,
540 static int coda_try_fmt_vid_cap(struct file
*file
, void *priv
,
541 struct v4l2_format
*f
)
543 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
544 const struct coda_q_data
*q_data_src
;
545 const struct coda_codec
*codec
;
546 struct vb2_queue
*src_vq
;
549 ret
= coda_try_pixelformat(ctx
, f
);
553 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
556 * If the source format is already fixed, only allow the same output
559 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
560 if (vb2_is_streaming(src_vq
)) {
561 f
->fmt
.pix
.width
= q_data_src
->width
;
562 f
->fmt
.pix
.height
= q_data_src
->height
;
565 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
567 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
568 codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
569 f
->fmt
.pix
.pixelformat
);
573 ret
= coda_try_fmt(ctx
, codec
, f
);
577 /* The h.264 decoder only returns complete 16x16 macroblocks */
578 if (codec
&& codec
->src_fourcc
== V4L2_PIX_FMT_H264
) {
579 f
->fmt
.pix
.width
= f
->fmt
.pix
.width
;
580 f
->fmt
.pix
.height
= round_up(f
->fmt
.pix
.height
, 16);
581 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
582 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
583 f
->fmt
.pix
.height
* 3 / 2;
589 static int coda_try_fmt_vid_out(struct file
*file
, void *priv
,
590 struct v4l2_format
*f
)
592 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
593 struct coda_dev
*dev
= ctx
->dev
;
594 const struct coda_q_data
*q_data_dst
;
595 const struct coda_codec
*codec
;
598 ret
= coda_try_pixelformat(ctx
, f
);
602 switch (f
->fmt
.pix
.colorspace
) {
603 case V4L2_COLORSPACE_REC709
:
604 case V4L2_COLORSPACE_JPEG
:
607 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
608 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
610 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
613 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
614 codec
= coda_find_codec(dev
, f
->fmt
.pix
.pixelformat
, q_data_dst
->fourcc
);
616 return coda_try_fmt(ctx
, codec
, f
);
619 static int coda_s_fmt(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
621 struct coda_q_data
*q_data
;
622 struct vb2_queue
*vq
;
624 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
628 q_data
= get_q_data(ctx
, f
->type
);
632 if (vb2_is_busy(vq
)) {
633 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
637 q_data
->fourcc
= f
->fmt
.pix
.pixelformat
;
638 q_data
->width
= f
->fmt
.pix
.width
;
639 q_data
->height
= f
->fmt
.pix
.height
;
640 q_data
->bytesperline
= f
->fmt
.pix
.bytesperline
;
641 q_data
->sizeimage
= f
->fmt
.pix
.sizeimage
;
642 q_data
->rect
.left
= 0;
643 q_data
->rect
.top
= 0;
644 q_data
->rect
.width
= f
->fmt
.pix
.width
;
645 q_data
->rect
.height
= f
->fmt
.pix
.height
;
647 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
648 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
649 f
->type
, q_data
->width
, q_data
->height
, q_data
->fourcc
);
654 static int coda_s_fmt_vid_cap(struct file
*file
, void *priv
,
655 struct v4l2_format
*f
)
657 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
660 ret
= coda_try_fmt_vid_cap(file
, priv
, f
);
664 return coda_s_fmt(ctx
, f
);
667 static int coda_s_fmt_vid_out(struct file
*file
, void *priv
,
668 struct v4l2_format
*f
)
670 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
671 struct v4l2_format f_cap
;
674 ret
= coda_try_fmt_vid_out(file
, priv
, f
);
678 ret
= coda_s_fmt(ctx
, f
);
682 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
684 memset(&f_cap
, 0, sizeof(f_cap
));
685 f_cap
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
686 coda_g_fmt(file
, priv
, &f_cap
);
687 f_cap
.fmt
.pix
.width
= f
->fmt
.pix
.width
;
688 f_cap
.fmt
.pix
.height
= f
->fmt
.pix
.height
;
690 ret
= coda_try_fmt_vid_cap(file
, priv
, &f_cap
);
694 return coda_s_fmt(ctx
, &f_cap
);
697 static int coda_qbuf(struct file
*file
, void *priv
,
698 struct v4l2_buffer
*buf
)
700 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
702 return v4l2_m2m_qbuf(file
, ctx
->fh
.m2m_ctx
, buf
);
705 static bool coda_buf_is_end_of_stream(struct coda_ctx
*ctx
,
706 struct v4l2_buffer
*buf
)
708 struct vb2_queue
*src_vq
;
710 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
712 return ((ctx
->bit_stream_param
& CODA_BIT_STREAM_END_FLAG
) &&
713 (buf
->sequence
== (ctx
->qsequence
- 1)));
716 static int coda_dqbuf(struct file
*file
, void *priv
,
717 struct v4l2_buffer
*buf
)
719 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
722 ret
= v4l2_m2m_dqbuf(file
, ctx
->fh
.m2m_ctx
, buf
);
724 /* If this is the last capture buffer, emit an end-of-stream event */
725 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
726 coda_buf_is_end_of_stream(ctx
, buf
)) {
727 const struct v4l2_event eos_event
= {
728 .type
= V4L2_EVENT_EOS
731 v4l2_event_queue_fh(&ctx
->fh
, &eos_event
);
737 static int coda_g_selection(struct file
*file
, void *fh
,
738 struct v4l2_selection
*s
)
740 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
741 struct coda_q_data
*q_data
;
742 struct v4l2_rect r
, *rsel
;
744 q_data
= get_q_data(ctx
, s
->type
);
750 r
.width
= q_data
->width
;
751 r
.height
= q_data
->height
;
752 rsel
= &q_data
->rect
;
755 case V4L2_SEL_TGT_CROP_DEFAULT
:
756 case V4L2_SEL_TGT_CROP_BOUNDS
:
759 case V4L2_SEL_TGT_CROP
:
760 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
763 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
764 case V4L2_SEL_TGT_COMPOSE_PADDED
:
767 case V4L2_SEL_TGT_COMPOSE
:
768 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
769 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
781 static int coda_try_decoder_cmd(struct file
*file
, void *fh
,
782 struct v4l2_decoder_cmd
*dc
)
784 if (dc
->cmd
!= V4L2_DEC_CMD_STOP
)
787 if (dc
->flags
& V4L2_DEC_CMD_STOP_TO_BLACK
)
790 if (!(dc
->flags
& V4L2_DEC_CMD_STOP_IMMEDIATELY
) && (dc
->stop
.pts
!= 0))
796 static int coda_decoder_cmd(struct file
*file
, void *fh
,
797 struct v4l2_decoder_cmd
*dc
)
799 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
802 ret
= coda_try_decoder_cmd(file
, fh
, dc
);
806 /* Ignore decoder stop command silently in encoder context */
807 if (ctx
->inst_type
!= CODA_INST_DECODER
)
810 /* Set the stream-end flag on this context */
811 coda_bit_stream_end_flag(ctx
);
813 v4l2_m2m_try_schedule(ctx
->fh
.m2m_ctx
);
818 static int coda_subscribe_event(struct v4l2_fh
*fh
,
819 const struct v4l2_event_subscription
*sub
)
823 return v4l2_event_subscribe(fh
, sub
, 0, NULL
);
825 return v4l2_ctrl_subscribe_event(fh
, sub
);
829 static const struct v4l2_ioctl_ops coda_ioctl_ops
= {
830 .vidioc_querycap
= coda_querycap
,
832 .vidioc_enum_fmt_vid_cap
= coda_enum_fmt
,
833 .vidioc_g_fmt_vid_cap
= coda_g_fmt
,
834 .vidioc_try_fmt_vid_cap
= coda_try_fmt_vid_cap
,
835 .vidioc_s_fmt_vid_cap
= coda_s_fmt_vid_cap
,
837 .vidioc_enum_fmt_vid_out
= coda_enum_fmt
,
838 .vidioc_g_fmt_vid_out
= coda_g_fmt
,
839 .vidioc_try_fmt_vid_out
= coda_try_fmt_vid_out
,
840 .vidioc_s_fmt_vid_out
= coda_s_fmt_vid_out
,
842 .vidioc_reqbufs
= v4l2_m2m_ioctl_reqbufs
,
843 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
845 .vidioc_qbuf
= coda_qbuf
,
846 .vidioc_expbuf
= v4l2_m2m_ioctl_expbuf
,
847 .vidioc_dqbuf
= coda_dqbuf
,
848 .vidioc_create_bufs
= v4l2_m2m_ioctl_create_bufs
,
850 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
851 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
853 .vidioc_g_selection
= coda_g_selection
,
855 .vidioc_try_decoder_cmd
= coda_try_decoder_cmd
,
856 .vidioc_decoder_cmd
= coda_decoder_cmd
,
858 .vidioc_subscribe_event
= coda_subscribe_event
,
859 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
862 void coda_set_gdi_regs(struct coda_ctx
*ctx
)
864 struct gdi_tiled_map
*tiled_map
= &ctx
->tiled_map
;
865 struct coda_dev
*dev
= ctx
->dev
;
868 for (i
= 0; i
< 16; i
++)
869 coda_write(dev
, tiled_map
->xy2ca_map
[i
],
870 CODA9_GDI_XY2_CAS_0
+ 4 * i
);
871 for (i
= 0; i
< 4; i
++)
872 coda_write(dev
, tiled_map
->xy2ba_map
[i
],
873 CODA9_GDI_XY2_BA_0
+ 4 * i
);
874 for (i
= 0; i
< 16; i
++)
875 coda_write(dev
, tiled_map
->xy2ra_map
[i
],
876 CODA9_GDI_XY2_RAS_0
+ 4 * i
);
877 coda_write(dev
, tiled_map
->xy2rbc_config
, CODA9_GDI_XY2_RBC_CONFIG
);
878 for (i
= 0; i
< 32; i
++)
879 coda_write(dev
, tiled_map
->rbc2axi_map
[i
],
880 CODA9_GDI_RBC2_AXI_0
+ 4 * i
);
884 * Mem-to-mem operations.
887 static void coda_device_run(void *m2m_priv
)
889 struct coda_ctx
*ctx
= m2m_priv
;
890 struct coda_dev
*dev
= ctx
->dev
;
892 queue_work(dev
->workqueue
, &ctx
->pic_run_work
);
895 static void coda_pic_run_work(struct work_struct
*work
)
897 struct coda_ctx
*ctx
= container_of(work
, struct coda_ctx
, pic_run_work
);
898 struct coda_dev
*dev
= ctx
->dev
;
901 mutex_lock(&ctx
->buffer_mutex
);
902 mutex_lock(&dev
->coda_mutex
);
904 ret
= ctx
->ops
->prepare_run(ctx
);
905 if (ret
< 0 && ctx
->inst_type
== CODA_INST_DECODER
) {
906 mutex_unlock(&dev
->coda_mutex
);
907 mutex_unlock(&ctx
->buffer_mutex
);
908 /* job_finish scheduled by prepare_decode */
912 if (!wait_for_completion_timeout(&ctx
->completion
,
913 msecs_to_jiffies(1000))) {
914 dev_err(&dev
->plat_dev
->dev
, "CODA PIC_RUN timeout\n");
919 } else if (!ctx
->aborting
) {
920 ctx
->ops
->finish_run(ctx
);
923 if (ctx
->aborting
|| (!ctx
->streamon_cap
&& !ctx
->streamon_out
))
924 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
926 mutex_unlock(&dev
->coda_mutex
);
927 mutex_unlock(&ctx
->buffer_mutex
);
929 v4l2_m2m_job_finish(ctx
->dev
->m2m_dev
, ctx
->fh
.m2m_ctx
);
932 static int coda_job_ready(void *m2m_priv
)
934 struct coda_ctx
*ctx
= m2m_priv
;
937 * For both 'P' and 'key' frame cases 1 picture
938 * and 1 frame are needed. In the decoder case,
939 * the compressed frame can be in the bitstream.
941 if (!v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
) &&
942 ctx
->inst_type
!= CODA_INST_DECODER
) {
943 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
944 "not ready: not enough video buffers.\n");
948 if (!v4l2_m2m_num_dst_bufs_ready(ctx
->fh
.m2m_ctx
)) {
949 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
950 "not ready: not enough video capture buffers.\n");
954 if (ctx
->inst_type
== CODA_INST_DECODER
) {
955 struct list_head
*meta
;
960 if (ctx
->hold
&& !v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
)) {
961 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
962 "%d: not ready: on hold for more buffers.\n",
967 stream_end
= ctx
->bit_stream_param
&
968 CODA_BIT_STREAM_END_FLAG
;
971 list_for_each(meta
, &ctx
->buffer_meta_list
)
974 src_bufs
= v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
);
976 if (!stream_end
&& (num_metas
+ src_bufs
) < 2) {
977 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
978 "%d: not ready: need 2 buffers available (%d, %d)\n",
979 ctx
->idx
, num_metas
, src_bufs
);
984 if (!v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
) &&
985 !stream_end
&& (coda_get_bitstream_payload(ctx
) < 512)) {
986 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
987 "%d: not ready: not enough bitstream data (%d).\n",
988 ctx
->idx
, coda_get_bitstream_payload(ctx
));
994 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
995 "not ready: aborting\n");
999 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1004 static void coda_job_abort(void *priv
)
1006 struct coda_ctx
*ctx
= priv
;
1010 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1014 static void coda_lock(void *m2m_priv
)
1016 struct coda_ctx
*ctx
= m2m_priv
;
1017 struct coda_dev
*pcdev
= ctx
->dev
;
1019 mutex_lock(&pcdev
->dev_mutex
);
1022 static void coda_unlock(void *m2m_priv
)
1024 struct coda_ctx
*ctx
= m2m_priv
;
1025 struct coda_dev
*pcdev
= ctx
->dev
;
1027 mutex_unlock(&pcdev
->dev_mutex
);
1030 static const struct v4l2_m2m_ops coda_m2m_ops
= {
1031 .device_run
= coda_device_run
,
1032 .job_ready
= coda_job_ready
,
1033 .job_abort
= coda_job_abort
,
1035 .unlock
= coda_unlock
,
1038 static void coda_set_tiled_map_type(struct coda_ctx
*ctx
, int tiled_map_type
)
1040 struct gdi_tiled_map
*tiled_map
= &ctx
->tiled_map
;
1041 int luma_map
, chro_map
, i
;
1043 memset(tiled_map
, 0, sizeof(*tiled_map
));
1047 tiled_map
->map_type
= tiled_map_type
;
1048 for (i
= 0; i
< 16; i
++)
1049 tiled_map
->xy2ca_map
[i
] = luma_map
<< 8 | chro_map
;
1050 for (i
= 0; i
< 4; i
++)
1051 tiled_map
->xy2ba_map
[i
] = luma_map
<< 8 | chro_map
;
1052 for (i
= 0; i
< 16; i
++)
1053 tiled_map
->xy2ra_map
[i
] = luma_map
<< 8 | chro_map
;
1055 if (tiled_map_type
== GDI_LINEAR_FRAME_MAP
) {
1056 tiled_map
->xy2rbc_config
= 0;
1058 dev_err(&ctx
->dev
->plat_dev
->dev
, "invalid map type: %d\n",
1064 static void set_default_params(struct coda_ctx
*ctx
)
1066 unsigned int max_w
, max_h
, usize
, csize
;
1068 ctx
->codec
= coda_find_codec(ctx
->dev
, ctx
->cvd
->src_formats
[0],
1069 ctx
->cvd
->dst_formats
[0]);
1070 max_w
= min(ctx
->codec
->max_w
, 1920U);
1071 max_h
= min(ctx
->codec
->max_h
, 1088U);
1072 usize
= max_w
* max_h
* 3 / 2;
1073 csize
= coda_estimate_sizeimage(ctx
, usize
, max_w
, max_h
);
1075 ctx
->params
.codec_mode
= ctx
->codec
->mode
;
1076 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
1077 ctx
->params
.framerate
= 30;
1079 /* Default formats for output and input queues */
1080 ctx
->q_data
[V4L2_M2M_SRC
].fourcc
= ctx
->codec
->src_fourcc
;
1081 ctx
->q_data
[V4L2_M2M_DST
].fourcc
= ctx
->codec
->dst_fourcc
;
1082 ctx
->q_data
[V4L2_M2M_SRC
].width
= max_w
;
1083 ctx
->q_data
[V4L2_M2M_SRC
].height
= max_h
;
1084 ctx
->q_data
[V4L2_M2M_DST
].width
= max_w
;
1085 ctx
->q_data
[V4L2_M2M_DST
].height
= max_h
;
1086 if (ctx
->codec
->src_fourcc
== V4L2_PIX_FMT_YUV420
) {
1087 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= max_w
;
1088 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= usize
;
1089 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= 0;
1090 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= csize
;
1092 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= 0;
1093 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= csize
;
1094 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= max_w
;
1095 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= usize
;
1097 ctx
->q_data
[V4L2_M2M_SRC
].rect
.width
= max_w
;
1098 ctx
->q_data
[V4L2_M2M_SRC
].rect
.height
= max_h
;
1099 ctx
->q_data
[V4L2_M2M_DST
].rect
.width
= max_w
;
1100 ctx
->q_data
[V4L2_M2M_DST
].rect
.height
= max_h
;
1102 if (ctx
->dev
->devtype
->product
== CODA_960
)
1103 coda_set_tiled_map_type(ctx
, GDI_LINEAR_FRAME_MAP
);
1109 static int coda_queue_setup(struct vb2_queue
*vq
,
1110 const struct v4l2_format
*fmt
,
1111 unsigned int *nbuffers
, unsigned int *nplanes
,
1112 unsigned int sizes
[], void *alloc_ctxs
[])
1114 struct coda_ctx
*ctx
= vb2_get_drv_priv(vq
);
1115 struct coda_q_data
*q_data
;
1118 q_data
= get_q_data(ctx
, vq
->type
);
1119 size
= q_data
->sizeimage
;
1124 alloc_ctxs
[0] = ctx
->dev
->alloc_ctx
;
1126 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1127 "get %d buffer(s) of size %d each.\n", *nbuffers
, size
);
1132 static int coda_buf_prepare(struct vb2_buffer
*vb
)
1134 struct coda_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
1135 struct coda_q_data
*q_data
;
1137 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
1139 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
1140 v4l2_warn(&ctx
->dev
->v4l2_dev
,
1141 "%s data will not fit into plane (%lu < %lu)\n",
1142 __func__
, vb2_plane_size(vb
, 0),
1143 (long)q_data
->sizeimage
);
1150 static void coda_buf_queue(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
);
1158 * In the decoder case, immediately try to copy the buffer into the
1159 * bitstream ringbuffer and mark it as ready to be dequeued.
1161 if (ctx
->inst_type
== CODA_INST_DECODER
&&
1162 vb
->vb2_queue
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1164 * For backwards compatibility, queuing an empty buffer marks
1167 if (vb2_get_plane_payload(vb
, 0) == 0)
1168 coda_bit_stream_end_flag(ctx
);
1169 mutex_lock(&ctx
->bitstream_mutex
);
1170 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
1171 if (vb2_is_streaming(vb
->vb2_queue
))
1172 coda_fill_bitstream(ctx
);
1173 mutex_unlock(&ctx
->bitstream_mutex
);
1175 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
1179 int coda_alloc_aux_buf(struct coda_dev
*dev
, struct coda_aux_buf
*buf
,
1180 size_t size
, const char *name
, struct dentry
*parent
)
1182 buf
->vaddr
= dma_alloc_coherent(&dev
->plat_dev
->dev
, size
, &buf
->paddr
,
1185 v4l2_err(&dev
->v4l2_dev
,
1186 "Failed to allocate %s buffer of size %u\n",
1193 if (name
&& parent
) {
1194 buf
->blob
.data
= buf
->vaddr
;
1195 buf
->blob
.size
= size
;
1196 buf
->dentry
= debugfs_create_blob(name
, 0644, parent
,
1199 dev_warn(&dev
->plat_dev
->dev
,
1200 "failed to create debugfs entry %s\n", name
);
1206 void coda_free_aux_buf(struct coda_dev
*dev
,
1207 struct coda_aux_buf
*buf
)
1210 dma_free_coherent(&dev
->plat_dev
->dev
, buf
->size
,
1211 buf
->vaddr
, buf
->paddr
);
1215 debugfs_remove(buf
->dentry
);
1218 static int coda_start_streaming(struct vb2_queue
*q
, unsigned int count
)
1220 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1221 struct v4l2_device
*v4l2_dev
= &ctx
->dev
->v4l2_dev
;
1222 struct coda_q_data
*q_data_src
, *q_data_dst
;
1223 struct vb2_buffer
*buf
;
1226 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1227 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1228 if (q_data_src
->fourcc
== V4L2_PIX_FMT_H264
||
1229 (q_data_src
->fourcc
== V4L2_PIX_FMT_JPEG
&&
1230 ctx
->dev
->devtype
->product
== CODA_7541
)) {
1231 /* copy the buffers that where queued before streamon */
1232 mutex_lock(&ctx
->bitstream_mutex
);
1233 coda_fill_bitstream(ctx
);
1234 mutex_unlock(&ctx
->bitstream_mutex
);
1236 if (coda_get_bitstream_payload(ctx
) < 512) {
1247 ctx
->streamon_out
= 1;
1254 ctx
->streamon_cap
= 1;
1257 /* Don't start the coda unless both queues are on */
1258 if (!(ctx
->streamon_out
& ctx
->streamon_cap
))
1261 /* Allow BIT decoder device_run with no new buffers queued */
1262 if (ctx
->inst_type
== CODA_INST_DECODER
)
1263 v4l2_m2m_set_src_buffered(ctx
->fh
.m2m_ctx
, true);
1265 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1266 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
1268 ctx
->codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
1269 q_data_dst
->fourcc
);
1271 v4l2_err(v4l2_dev
, "couldn't tell instance type.\n");
1276 if (q_data_dst
->fourcc
== V4L2_PIX_FMT_JPEG
)
1277 ctx
->params
.gop_size
= 1;
1278 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1280 ret
= ctx
->ops
->start_streaming(ctx
);
1281 if (ctx
->inst_type
== CODA_INST_DECODER
) {
1288 ctx
->initialized
= 1;
1292 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1293 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1294 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1296 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1297 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1302 static void coda_stop_streaming(struct vb2_queue
*q
)
1304 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1305 struct coda_dev
*dev
= ctx
->dev
;
1306 struct vb2_buffer
*buf
;
1308 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1309 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1310 "%s: output\n", __func__
);
1311 ctx
->streamon_out
= 0;
1313 coda_bit_stream_end_flag(ctx
);
1317 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1318 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1320 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1321 "%s: capture\n", __func__
);
1322 ctx
->streamon_cap
= 0;
1325 ctx
->sequence_offset
= 0;
1327 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1328 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1331 if (!ctx
->streamon_out
&& !ctx
->streamon_cap
) {
1332 struct coda_buffer_meta
*meta
;
1334 if (ctx
->ops
->seq_end_work
) {
1335 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1336 flush_work(&ctx
->seq_end_work
);
1338 mutex_lock(&ctx
->bitstream_mutex
);
1339 while (!list_empty(&ctx
->buffer_meta_list
)) {
1340 meta
= list_first_entry(&ctx
->buffer_meta_list
,
1341 struct coda_buffer_meta
, list
);
1342 list_del(&meta
->list
);
1345 mutex_unlock(&ctx
->bitstream_mutex
);
1346 kfifo_init(&ctx
->bitstream_fifo
,
1347 ctx
->bitstream
.vaddr
, ctx
->bitstream
.size
);
1348 ctx
->initialized
= 0;
1349 ctx
->runcounter
= 0;
1354 static const struct vb2_ops coda_qops
= {
1355 .queue_setup
= coda_queue_setup
,
1356 .buf_prepare
= coda_buf_prepare
,
1357 .buf_queue
= coda_buf_queue
,
1358 .start_streaming
= coda_start_streaming
,
1359 .stop_streaming
= coda_stop_streaming
,
1360 .wait_prepare
= vb2_ops_wait_prepare
,
1361 .wait_finish
= vb2_ops_wait_finish
,
1364 static int coda_s_ctrl(struct v4l2_ctrl
*ctrl
)
1366 struct coda_ctx
*ctx
=
1367 container_of(ctrl
->handler
, struct coda_ctx
, ctrls
);
1369 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1370 "s_ctrl: id = %d, val = %d\n", ctrl
->id
, ctrl
->val
);
1373 case V4L2_CID_HFLIP
:
1375 ctx
->params
.rot_mode
|= CODA_MIR_HOR
;
1377 ctx
->params
.rot_mode
&= ~CODA_MIR_HOR
;
1379 case V4L2_CID_VFLIP
:
1381 ctx
->params
.rot_mode
|= CODA_MIR_VER
;
1383 ctx
->params
.rot_mode
&= ~CODA_MIR_VER
;
1385 case V4L2_CID_MPEG_VIDEO_BITRATE
:
1386 ctx
->params
.bitrate
= ctrl
->val
/ 1000;
1388 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1389 ctx
->params
.gop_size
= ctrl
->val
;
1391 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
:
1392 ctx
->params
.h264_intra_qp
= ctrl
->val
;
1394 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
:
1395 ctx
->params
.h264_inter_qp
= ctrl
->val
;
1397 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1398 ctx
->params
.h264_min_qp
= ctrl
->val
;
1400 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP
:
1401 ctx
->params
.h264_max_qp
= ctrl
->val
;
1403 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
:
1404 ctx
->params
.h264_deblk_alpha
= ctrl
->val
;
1406 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
:
1407 ctx
->params
.h264_deblk_beta
= ctrl
->val
;
1409 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
:
1410 ctx
->params
.h264_deblk_enabled
= (ctrl
->val
==
1411 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1413 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
:
1414 ctx
->params
.mpeg4_intra_qp
= ctrl
->val
;
1416 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
:
1417 ctx
->params
.mpeg4_inter_qp
= ctrl
->val
;
1419 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
:
1420 ctx
->params
.slice_mode
= ctrl
->val
;
1422 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
:
1423 ctx
->params
.slice_max_mb
= ctrl
->val
;
1425 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
:
1426 ctx
->params
.slice_max_bits
= ctrl
->val
* 8;
1428 case V4L2_CID_MPEG_VIDEO_HEADER_MODE
:
1430 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
:
1431 ctx
->params
.intra_refresh
= ctrl
->val
;
1433 case V4L2_CID_JPEG_COMPRESSION_QUALITY
:
1434 coda_set_jpeg_compression_quality(ctx
, ctrl
->val
);
1436 case V4L2_CID_JPEG_RESTART_INTERVAL
:
1437 ctx
->params
.jpeg_restart_interval
= ctrl
->val
;
1440 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1441 "Invalid control, id=%d, val=%d\n",
1442 ctrl
->id
, ctrl
->val
);
1449 static const struct v4l2_ctrl_ops coda_ctrl_ops
= {
1450 .s_ctrl
= coda_s_ctrl
,
1453 static void coda_encode_ctrls(struct coda_ctx
*ctx
)
1455 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1456 V4L2_CID_MPEG_VIDEO_BITRATE
, 0, 32767000, 1, 0);
1457 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1458 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 60, 1, 16);
1459 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1460 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
, 0, 51, 1, 25);
1461 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1462 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
, 0, 51, 1, 25);
1463 if (ctx
->dev
->devtype
->product
!= CODA_960
) {
1464 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1465 V4L2_CID_MPEG_VIDEO_H264_MIN_QP
, 0, 51, 1, 12);
1467 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1468 V4L2_CID_MPEG_VIDEO_H264_MAX_QP
, 0, 51, 1, 51);
1469 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1470 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
, 0, 15, 1, 0);
1471 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1472 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
, 0, 15, 1, 0);
1473 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1474 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
,
1475 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED
, 0x0,
1476 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1477 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1478 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
, 1, 31, 1, 2);
1479 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1480 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
, 1, 31, 1, 2);
1481 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1482 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
,
1483 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES
, 0x0,
1484 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
);
1485 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1486 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
, 1, 0x3fffffff, 1, 1);
1487 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1488 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
, 1, 0x3fffffff, 1,
1490 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1491 V4L2_CID_MPEG_VIDEO_HEADER_MODE
,
1492 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
,
1493 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
),
1494 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
);
1495 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1496 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
, 0,
1497 1920 * 1088 / 256, 1, 0);
1500 static void coda_jpeg_encode_ctrls(struct coda_ctx
*ctx
)
1502 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1503 V4L2_CID_JPEG_COMPRESSION_QUALITY
, 5, 100, 1, 50);
1504 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1505 V4L2_CID_JPEG_RESTART_INTERVAL
, 0, 100, 1, 0);
1508 static int coda_ctrls_setup(struct coda_ctx
*ctx
)
1510 v4l2_ctrl_handler_init(&ctx
->ctrls
, 2);
1512 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1513 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1514 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1515 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1516 if (ctx
->inst_type
== CODA_INST_ENCODER
) {
1517 if (ctx
->cvd
->dst_formats
[0] == V4L2_PIX_FMT_JPEG
)
1518 coda_jpeg_encode_ctrls(ctx
);
1520 coda_encode_ctrls(ctx
);
1523 if (ctx
->ctrls
.error
) {
1524 v4l2_err(&ctx
->dev
->v4l2_dev
,
1525 "control initialization error (%d)",
1530 return v4l2_ctrl_handler_setup(&ctx
->ctrls
);
1533 static int coda_queue_init(struct coda_ctx
*ctx
, struct vb2_queue
*vq
)
1536 vq
->ops
= &coda_qops
;
1537 vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
1538 vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
1539 vq
->lock
= &ctx
->dev
->dev_mutex
;
1541 return vb2_queue_init(vq
);
1544 int coda_encoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1545 struct vb2_queue
*dst_vq
)
1549 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1550 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1551 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
1553 ret
= coda_queue_init(priv
, src_vq
);
1557 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1558 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1559 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1561 return coda_queue_init(priv
, dst_vq
);
1564 int coda_decoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1565 struct vb2_queue
*dst_vq
)
1569 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1570 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1571 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
1573 ret
= coda_queue_init(priv
, src_vq
);
1577 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1578 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1579 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1581 return coda_queue_init(priv
, dst_vq
);
1584 static int coda_next_free_instance(struct coda_dev
*dev
)
1586 int idx
= ffz(dev
->instance_mask
);
1589 (dev
->devtype
->product
== CODA_DX6
&& idx
> CODADX6_MAX_INSTANCES
))
1599 static int coda_open(struct file
*file
)
1601 struct video_device
*vdev
= video_devdata(file
);
1602 struct coda_dev
*dev
= video_get_drvdata(vdev
);
1603 struct coda_ctx
*ctx
= NULL
;
1608 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
1612 idx
= coda_next_free_instance(dev
);
1617 set_bit(idx
, &dev
->instance_mask
);
1619 name
= kasprintf(GFP_KERNEL
, "context%d", idx
);
1620 ctx
->debugfs_entry
= debugfs_create_dir(name
, dev
->debugfs_root
);
1623 ctx
->cvd
= to_coda_video_device(vdev
);
1624 ctx
->inst_type
= ctx
->cvd
->type
;
1625 ctx
->ops
= ctx
->cvd
->ops
;
1626 init_completion(&ctx
->completion
);
1627 INIT_WORK(&ctx
->pic_run_work
, coda_pic_run_work
);
1628 INIT_WORK(&ctx
->seq_end_work
, ctx
->ops
->seq_end_work
);
1629 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
1630 file
->private_data
= &ctx
->fh
;
1631 v4l2_fh_add(&ctx
->fh
);
1634 switch (dev
->devtype
->product
) {
1636 ctx
->frame_mem_ctrl
= 1 << 12;
1645 /* Power up and upload firmware if necessary */
1646 ret
= pm_runtime_get_sync(&dev
->plat_dev
->dev
);
1648 v4l2_err(&dev
->v4l2_dev
, "failed to power up: %d\n", ret
);
1652 ret
= clk_prepare_enable(dev
->clk_per
);
1656 ret
= clk_prepare_enable(dev
->clk_ahb
);
1660 set_default_params(ctx
);
1661 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
,
1662 ctx
->ops
->queue_init
);
1663 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
1664 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
1666 v4l2_err(&dev
->v4l2_dev
, "%s return error (%d)\n",
1671 ret
= coda_ctrls_setup(ctx
);
1673 v4l2_err(&dev
->v4l2_dev
, "failed to setup coda controls\n");
1674 goto err_ctrls_setup
;
1677 ctx
->fh
.ctrl_handler
= &ctx
->ctrls
;
1679 ret
= coda_alloc_context_buf(ctx
, &ctx
->parabuf
,
1680 CODA_PARA_BUF_SIZE
, "parabuf");
1682 v4l2_err(&dev
->v4l2_dev
, "failed to allocate parabuf");
1686 ctx
->bitstream
.size
= CODA_MAX_FRAME_SIZE
;
1687 ctx
->bitstream
.vaddr
= dma_alloc_writecombine(
1688 &dev
->plat_dev
->dev
, ctx
->bitstream
.size
,
1689 &ctx
->bitstream
.paddr
, GFP_KERNEL
);
1690 if (!ctx
->bitstream
.vaddr
) {
1691 v4l2_err(&dev
->v4l2_dev
,
1692 "failed to allocate bitstream ringbuffer");
1694 goto err_dma_writecombine
;
1696 kfifo_init(&ctx
->bitstream_fifo
,
1697 ctx
->bitstream
.vaddr
, ctx
->bitstream
.size
);
1698 mutex_init(&ctx
->bitstream_mutex
);
1699 mutex_init(&ctx
->buffer_mutex
);
1700 INIT_LIST_HEAD(&ctx
->buffer_meta_list
);
1703 list_add(&ctx
->list
, &dev
->instances
);
1706 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Created instance %d (%p)\n",
1711 err_dma_writecombine
:
1712 if (ctx
->dev
->devtype
->product
== CODA_DX6
)
1713 coda_free_aux_buf(dev
, &ctx
->workbuf
);
1714 coda_free_aux_buf(dev
, &ctx
->parabuf
);
1716 v4l2_ctrl_handler_free(&ctx
->ctrls
);
1718 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1720 clk_disable_unprepare(dev
->clk_ahb
);
1722 clk_disable_unprepare(dev
->clk_per
);
1724 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1726 v4l2_fh_del(&ctx
->fh
);
1727 v4l2_fh_exit(&ctx
->fh
);
1728 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1734 static int coda_release(struct file
*file
)
1736 struct coda_dev
*dev
= video_drvdata(file
);
1737 struct coda_ctx
*ctx
= fh_to_ctx(file
->private_data
);
1739 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Releasing instance %p\n",
1742 if (ctx
->inst_type
== CODA_INST_DECODER
)
1743 coda_bit_stream_end_flag(ctx
);
1745 /* If this instance is running, call .job_abort and wait for it to end */
1746 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1748 /* In case the instance was not running, we still need to call SEQ_END */
1749 if (ctx
->initialized
) {
1750 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1751 flush_work(&ctx
->seq_end_work
);
1755 list_del(&ctx
->list
);
1758 if (ctx
->bitstream
.vaddr
) {
1759 dma_free_writecombine(&dev
->plat_dev
->dev
, ctx
->bitstream
.size
,
1760 ctx
->bitstream
.vaddr
, ctx
->bitstream
.paddr
);
1762 if (ctx
->dev
->devtype
->product
== CODA_DX6
)
1763 coda_free_aux_buf(dev
, &ctx
->workbuf
);
1765 coda_free_aux_buf(dev
, &ctx
->parabuf
);
1766 v4l2_ctrl_handler_free(&ctx
->ctrls
);
1767 clk_disable_unprepare(dev
->clk_ahb
);
1768 clk_disable_unprepare(dev
->clk_per
);
1769 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1770 v4l2_fh_del(&ctx
->fh
);
1771 v4l2_fh_exit(&ctx
->fh
);
1772 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1773 if (ctx
->ops
->release
)
1774 ctx
->ops
->release(ctx
);
1775 debugfs_remove_recursive(ctx
->debugfs_entry
);
1781 static const struct v4l2_file_operations coda_fops
= {
1782 .owner
= THIS_MODULE
,
1784 .release
= coda_release
,
1785 .poll
= v4l2_m2m_fop_poll
,
1786 .unlocked_ioctl
= video_ioctl2
,
1787 .mmap
= v4l2_m2m_fop_mmap
,
1790 static int coda_hw_init(struct coda_dev
*dev
)
1796 ret
= clk_prepare_enable(dev
->clk_per
);
1800 ret
= clk_prepare_enable(dev
->clk_ahb
);
1805 reset_control_reset(dev
->rstc
);
1808 * Copy the first CODA_ISRAM_SIZE in the internal SRAM.
1809 * The 16-bit chars in the code buffer are in memory access
1810 * order, re-sort them to CODA order for register download.
1811 * Data in this SRAM survives a reboot.
1813 p
= (u16
*)dev
->codebuf
.vaddr
;
1814 if (dev
->devtype
->product
== CODA_DX6
) {
1815 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1816 data
= CODA_DOWN_ADDRESS_SET(i
) |
1817 CODA_DOWN_DATA_SET(p
[i
^ 1]);
1818 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1821 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1822 data
= CODA_DOWN_ADDRESS_SET(i
) |
1823 CODA_DOWN_DATA_SET(p
[round_down(i
, 4) +
1825 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1829 /* Clear registers */
1830 for (i
= 0; i
< 64; i
++)
1831 coda_write(dev
, 0, CODA_REG_BIT_CODE_BUF_ADDR
+ i
* 4);
1833 /* Tell the BIT where to find everything it needs */
1834 if (dev
->devtype
->product
== CODA_960
||
1835 dev
->devtype
->product
== CODA_7541
) {
1836 coda_write(dev
, dev
->tempbuf
.paddr
,
1837 CODA_REG_BIT_TEMP_BUF_ADDR
);
1838 coda_write(dev
, 0, CODA_REG_BIT_BIT_STREAM_PARAM
);
1840 coda_write(dev
, dev
->workbuf
.paddr
,
1841 CODA_REG_BIT_WORK_BUF_ADDR
);
1843 coda_write(dev
, dev
->codebuf
.paddr
,
1844 CODA_REG_BIT_CODE_BUF_ADDR
);
1845 coda_write(dev
, 0, CODA_REG_BIT_CODE_RUN
);
1847 /* Set default values */
1848 switch (dev
->devtype
->product
) {
1850 coda_write(dev
, CODADX6_STREAM_BUF_PIC_FLUSH
,
1851 CODA_REG_BIT_STREAM_CTRL
);
1854 coda_write(dev
, CODA7_STREAM_BUF_PIC_FLUSH
,
1855 CODA_REG_BIT_STREAM_CTRL
);
1857 if (dev
->devtype
->product
== CODA_960
)
1858 coda_write(dev
, 1 << 12, CODA_REG_BIT_FRAME_MEM_CTRL
);
1860 coda_write(dev
, 0, CODA_REG_BIT_FRAME_MEM_CTRL
);
1862 if (dev
->devtype
->product
!= CODA_DX6
)
1863 coda_write(dev
, 0, CODA7_REG_BIT_AXI_SRAM_USE
);
1865 coda_write(dev
, CODA_INT_INTERRUPT_ENABLE
,
1866 CODA_REG_BIT_INT_ENABLE
);
1868 /* Reset VPU and start processor */
1869 data
= coda_read(dev
, CODA_REG_BIT_CODE_RESET
);
1870 data
|= CODA_REG_RESET_ENABLE
;
1871 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1873 data
&= ~CODA_REG_RESET_ENABLE
;
1874 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1875 coda_write(dev
, CODA_REG_RUN_ENABLE
, CODA_REG_BIT_CODE_RUN
);
1877 clk_disable_unprepare(dev
->clk_ahb
);
1878 clk_disable_unprepare(dev
->clk_per
);
1883 clk_disable_unprepare(dev
->clk_per
);
1888 static int coda_register_device(struct coda_dev
*dev
, int i
)
1890 struct video_device
*vfd
= &dev
->vfd
[i
];
1892 if (i
>= dev
->devtype
->num_vdevs
)
1895 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s",
1896 dev
->devtype
->vdevs
[i
]->name
);
1897 vfd
->fops
= &coda_fops
;
1898 vfd
->ioctl_ops
= &coda_ioctl_ops
;
1899 vfd
->release
= video_device_release_empty
,
1900 vfd
->lock
= &dev
->dev_mutex
;
1901 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1902 vfd
->vfl_dir
= VFL_DIR_M2M
;
1903 video_set_drvdata(vfd
, dev
);
1905 /* Not applicable, use the selection API instead */
1906 v4l2_disable_ioctl(vfd
, VIDIOC_CROPCAP
);
1907 v4l2_disable_ioctl(vfd
, VIDIOC_G_CROP
);
1908 v4l2_disable_ioctl(vfd
, VIDIOC_S_CROP
);
1910 return video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1913 static void coda_fw_callback(const struct firmware
*fw
, void *context
)
1915 struct coda_dev
*dev
= context
;
1916 struct platform_device
*pdev
= dev
->plat_dev
;
1920 v4l2_err(&dev
->v4l2_dev
, "firmware request failed\n");
1924 /* allocate auxiliary per-device code buffer for the BIT processor */
1925 ret
= coda_alloc_aux_buf(dev
, &dev
->codebuf
, fw
->size
, "codebuf",
1928 dev_err(&pdev
->dev
, "failed to allocate code buffer\n");
1932 /* Copy the whole firmware image to the code buffer */
1933 memcpy(dev
->codebuf
.vaddr
, fw
->data
, fw
->size
);
1934 release_firmware(fw
);
1936 ret
= coda_hw_init(dev
);
1938 v4l2_err(&dev
->v4l2_dev
, "HW initialization failed\n");
1942 ret
= coda_check_firmware(dev
);
1946 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1947 if (IS_ERR(dev
->alloc_ctx
)) {
1948 v4l2_err(&dev
->v4l2_dev
, "Failed to alloc vb2 context\n");
1952 dev
->m2m_dev
= v4l2_m2m_init(&coda_m2m_ops
);
1953 if (IS_ERR(dev
->m2m_dev
)) {
1954 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1958 for (i
= 0; i
< dev
->devtype
->num_vdevs
; i
++) {
1959 ret
= coda_register_device(dev
, i
);
1961 v4l2_err(&dev
->v4l2_dev
,
1962 "Failed to register %s video device: %d\n",
1963 dev
->devtype
->vdevs
[i
]->name
, ret
);
1968 v4l2_info(&dev
->v4l2_dev
, "codec registered as /dev/video[%d-%d]\n",
1969 dev
->vfd
[0].num
, dev
->vfd
[i
- 1].num
);
1971 pm_runtime_put_sync(&pdev
->dev
);
1976 video_unregister_device(&dev
->vfd
[i
]);
1977 v4l2_m2m_release(dev
->m2m_dev
);
1979 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
1981 pm_runtime_put_sync(&pdev
->dev
);
1984 static int coda_firmware_request(struct coda_dev
*dev
)
1986 char *fw
= dev
->devtype
->firmware
;
1988 dev_dbg(&dev
->plat_dev
->dev
, "requesting firmware '%s' for %s\n", fw
,
1989 coda_product_name(dev
->devtype
->product
));
1991 return request_firmware_nowait(THIS_MODULE
, true,
1992 fw
, &dev
->plat_dev
->dev
, GFP_KERNEL
, dev
, coda_fw_callback
);
1995 enum coda_platform
{
2002 static const struct coda_devtype coda_devdata
[] = {
2004 .firmware
= "v4l-codadx6-imx27.bin",
2005 .product
= CODA_DX6
,
2006 .codecs
= codadx6_codecs
,
2007 .num_codecs
= ARRAY_SIZE(codadx6_codecs
),
2008 .vdevs
= codadx6_video_devices
,
2009 .num_vdevs
= ARRAY_SIZE(codadx6_video_devices
),
2010 .workbuf_size
= 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE
* 8 * 1024,
2011 .iram_size
= 0xb000,
2014 .firmware
= "v4l-coda7541-imx53.bin",
2015 .product
= CODA_7541
,
2016 .codecs
= coda7_codecs
,
2017 .num_codecs
= ARRAY_SIZE(coda7_codecs
),
2018 .vdevs
= coda7_video_devices
,
2019 .num_vdevs
= ARRAY_SIZE(coda7_video_devices
),
2020 .workbuf_size
= 128 * 1024,
2021 .tempbuf_size
= 304 * 1024,
2022 .iram_size
= 0x14000,
2025 .firmware
= "v4l-coda960-imx6q.bin",
2026 .product
= CODA_960
,
2027 .codecs
= coda9_codecs
,
2028 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2029 .vdevs
= coda9_video_devices
,
2030 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2031 .workbuf_size
= 80 * 1024,
2032 .tempbuf_size
= 204 * 1024,
2033 .iram_size
= 0x21000,
2036 .firmware
= "v4l-coda960-imx6dl.bin",
2037 .product
= CODA_960
,
2038 .codecs
= coda9_codecs
,
2039 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2040 .vdevs
= coda9_video_devices
,
2041 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2042 .workbuf_size
= 80 * 1024,
2043 .tempbuf_size
= 204 * 1024,
2044 .iram_size
= 0x20000,
2048 static struct platform_device_id coda_platform_ids
[] = {
2049 { .name
= "coda-imx27", .driver_data
= CODA_IMX27
},
2052 MODULE_DEVICE_TABLE(platform
, coda_platform_ids
);
2055 static const struct of_device_id coda_dt_ids
[] = {
2056 { .compatible
= "fsl,imx27-vpu", .data
= &coda_devdata
[CODA_IMX27
] },
2057 { .compatible
= "fsl,imx53-vpu", .data
= &coda_devdata
[CODA_IMX53
] },
2058 { .compatible
= "fsl,imx6q-vpu", .data
= &coda_devdata
[CODA_IMX6Q
] },
2059 { .compatible
= "fsl,imx6dl-vpu", .data
= &coda_devdata
[CODA_IMX6DL
] },
2062 MODULE_DEVICE_TABLE(of
, coda_dt_ids
);
2065 static int coda_probe(struct platform_device
*pdev
)
2067 const struct of_device_id
*of_id
=
2068 of_match_device(of_match_ptr(coda_dt_ids
), &pdev
->dev
);
2069 const struct platform_device_id
*pdev_id
;
2070 struct coda_platform_data
*pdata
= pdev
->dev
.platform_data
;
2071 struct device_node
*np
= pdev
->dev
.of_node
;
2072 struct gen_pool
*pool
;
2073 struct coda_dev
*dev
;
2074 struct resource
*res
;
2077 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
2081 pdev_id
= of_id
? of_id
->data
: platform_get_device_id(pdev
);
2084 dev
->devtype
= of_id
->data
;
2085 } else if (pdev_id
) {
2086 dev
->devtype
= &coda_devdata
[pdev_id
->driver_data
];
2089 goto err_v4l2_register
;
2092 spin_lock_init(&dev
->irqlock
);
2093 INIT_LIST_HEAD(&dev
->instances
);
2095 dev
->plat_dev
= pdev
;
2096 dev
->clk_per
= devm_clk_get(&pdev
->dev
, "per");
2097 if (IS_ERR(dev
->clk_per
)) {
2098 dev_err(&pdev
->dev
, "Could not get per clock\n");
2099 return PTR_ERR(dev
->clk_per
);
2102 dev
->clk_ahb
= devm_clk_get(&pdev
->dev
, "ahb");
2103 if (IS_ERR(dev
->clk_ahb
)) {
2104 dev_err(&pdev
->dev
, "Could not get ahb clock\n");
2105 return PTR_ERR(dev
->clk_ahb
);
2108 /* Get memory for physical registers */
2109 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2110 dev
->regs_base
= devm_ioremap_resource(&pdev
->dev
, res
);
2111 if (IS_ERR(dev
->regs_base
))
2112 return PTR_ERR(dev
->regs_base
);
2115 irq
= platform_get_irq_byname(pdev
, "bit");
2117 irq
= platform_get_irq(pdev
, 0);
2119 dev_err(&pdev
->dev
, "failed to get irq resource\n");
2123 ret
= devm_request_threaded_irq(&pdev
->dev
, irq
, NULL
, coda_irq_handler
,
2124 IRQF_ONESHOT
, dev_name(&pdev
->dev
), dev
);
2126 dev_err(&pdev
->dev
, "failed to request irq: %d\n", ret
);
2130 dev
->rstc
= devm_reset_control_get_optional(&pdev
->dev
, NULL
);
2131 if (IS_ERR(dev
->rstc
)) {
2132 ret
= PTR_ERR(dev
->rstc
);
2133 if (ret
== -ENOENT
|| ret
== -ENOSYS
) {
2136 dev_err(&pdev
->dev
, "failed get reset control: %d\n",
2142 /* Get IRAM pool from device tree or platform data */
2143 pool
= of_get_named_gen_pool(np
, "iram", 0);
2145 pool
= dev_get_gen_pool(pdata
->iram_dev
);
2147 dev_err(&pdev
->dev
, "iram pool not available\n");
2150 dev
->iram_pool
= pool
;
2152 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
2156 mutex_init(&dev
->dev_mutex
);
2157 mutex_init(&dev
->coda_mutex
);
2159 dev
->debugfs_root
= debugfs_create_dir("coda", NULL
);
2160 if (!dev
->debugfs_root
)
2161 dev_warn(&pdev
->dev
, "failed to create debugfs root\n");
2163 /* allocate auxiliary per-device buffers for the BIT processor */
2164 if (dev
->devtype
->product
== CODA_DX6
) {
2165 ret
= coda_alloc_aux_buf(dev
, &dev
->workbuf
,
2166 dev
->devtype
->workbuf_size
, "workbuf",
2169 dev_err(&pdev
->dev
, "failed to allocate work buffer\n");
2170 goto err_v4l2_register
;
2174 if (dev
->devtype
->tempbuf_size
) {
2175 ret
= coda_alloc_aux_buf(dev
, &dev
->tempbuf
,
2176 dev
->devtype
->tempbuf_size
, "tempbuf",
2179 dev_err(&pdev
->dev
, "failed to allocate temp buffer\n");
2180 goto err_v4l2_register
;
2184 dev
->iram
.size
= dev
->devtype
->iram_size
;
2185 dev
->iram
.vaddr
= gen_pool_dma_alloc(dev
->iram_pool
, dev
->iram
.size
,
2187 if (!dev
->iram
.vaddr
) {
2188 dev_warn(&pdev
->dev
, "unable to alloc iram\n");
2190 memset(dev
->iram
.vaddr
, 0, dev
->iram
.size
);
2191 dev
->iram
.blob
.data
= dev
->iram
.vaddr
;
2192 dev
->iram
.blob
.size
= dev
->iram
.size
;
2193 dev
->iram
.dentry
= debugfs_create_blob("iram", 0644,
2198 dev
->workqueue
= alloc_workqueue("coda", WQ_UNBOUND
| WQ_MEM_RECLAIM
, 1);
2199 if (!dev
->workqueue
) {
2200 dev_err(&pdev
->dev
, "unable to alloc workqueue\n");
2202 goto err_v4l2_register
;
2205 platform_set_drvdata(pdev
, dev
);
2208 * Start activated so we can directly call coda_hw_init in
2209 * coda_fw_callback regardless of whether CONFIG_PM is
2210 * enabled or whether the device is associated with a PM domain.
2212 pm_runtime_get_noresume(&pdev
->dev
);
2213 pm_runtime_set_active(&pdev
->dev
);
2214 pm_runtime_enable(&pdev
->dev
);
2216 return coda_firmware_request(dev
);
2219 v4l2_device_unregister(&dev
->v4l2_dev
);
2223 static int coda_remove(struct platform_device
*pdev
)
2225 struct coda_dev
*dev
= platform_get_drvdata(pdev
);
2228 for (i
= 0; i
< ARRAY_SIZE(dev
->vfd
); i
++) {
2229 if (video_get_drvdata(&dev
->vfd
[i
]))
2230 video_unregister_device(&dev
->vfd
[i
]);
2233 v4l2_m2m_release(dev
->m2m_dev
);
2234 pm_runtime_disable(&pdev
->dev
);
2236 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
2237 v4l2_device_unregister(&dev
->v4l2_dev
);
2238 destroy_workqueue(dev
->workqueue
);
2239 if (dev
->iram
.vaddr
)
2240 gen_pool_free(dev
->iram_pool
, (unsigned long)dev
->iram
.vaddr
,
2242 coda_free_aux_buf(dev
, &dev
->codebuf
);
2243 coda_free_aux_buf(dev
, &dev
->tempbuf
);
2244 coda_free_aux_buf(dev
, &dev
->workbuf
);
2245 debugfs_remove_recursive(dev
->debugfs_root
);
2250 static int coda_runtime_resume(struct device
*dev
)
2252 struct coda_dev
*cdev
= dev_get_drvdata(dev
);
2255 if (dev
->pm_domain
&& cdev
->codebuf
.vaddr
) {
2256 ret
= coda_hw_init(cdev
);
2258 v4l2_err(&cdev
->v4l2_dev
, "HW initialization failed\n");
2265 static const struct dev_pm_ops coda_pm_ops
= {
2266 SET_RUNTIME_PM_OPS(NULL
, coda_runtime_resume
, NULL
)
2269 static struct platform_driver coda_driver
= {
2270 .probe
= coda_probe
,
2271 .remove
= coda_remove
,
2274 .of_match_table
= of_match_ptr(coda_dt_ids
),
2277 .id_table
= coda_platform_ids
,
2280 module_platform_driver(coda_driver
);
2282 MODULE_LICENSE("GPL");
2283 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
2284 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");