?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / platform / mtk-vcodec / mtk_vcodec_dec.c
blob0f3e710aed4ed6cbcfe59957bdca22d3a935cd22
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2016 MediaTek Inc.
4 * Author: PC Chen <pc.chen@mediatek.com>
5 * Tiffany Lin <tiffany.lin@mediatek.com>
6 */
7
8 #include <media/v4l2-event.h>
9 #include <media/v4l2-mem2mem.h>
10 #include <media/videobuf2-dma-contig.h>
11
12 #include "mtk_vcodec_drv.h"
13 #include "mtk_vcodec_dec.h"
14 #include "mtk_vcodec_intr.h"
15 #include "mtk_vcodec_util.h"
16 #include "vdec_drv_if.h"
17 #include "mtk_vcodec_dec_pm.h"
18
19 #define OUT_FMT_IDX 0
20 #define CAP_FMT_IDX 3
21
22 #define MTK_VDEC_MIN_W 64U
23 #define MTK_VDEC_MIN_H 64U
24 #define DFT_CFG_WIDTH MTK_VDEC_MIN_W
25 #define DFT_CFG_HEIGHT MTK_VDEC_MIN_H
26
27 static const struct mtk_video_fmt mtk_video_formats[] = {
28 {
29 .fourcc = V4L2_PIX_FMT_H264,
30 .type = MTK_FMT_DEC,
31 .num_planes = 1,
32 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
33 },
34 {
35 .fourcc = V4L2_PIX_FMT_VP8,
36 .type = MTK_FMT_DEC,
37 .num_planes = 1,
38 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
39 },
40 {
41 .fourcc = V4L2_PIX_FMT_VP9,
42 .type = MTK_FMT_DEC,
43 .num_planes = 1,
44 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
45 },
46 {
47 .fourcc = V4L2_PIX_FMT_MT21C,
48 .type = MTK_FMT_FRAME,
49 .num_planes = 2,
50 },
51 };
52
53 static const struct mtk_codec_framesizes mtk_vdec_framesizes[] = {
54 {
55 .fourcc = V4L2_PIX_FMT_H264,
56 .stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
57 MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
58 },
59 {
60 .fourcc = V4L2_PIX_FMT_VP8,
61 .stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
62 MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
63 },
64 {
65 .fourcc = V4L2_PIX_FMT_VP9,
66 .stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
67 MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
68 },
69 };
70
71 #define NUM_SUPPORTED_FRAMESIZE ARRAY_SIZE(mtk_vdec_framesizes)
72 #define NUM_FORMATS ARRAY_SIZE(mtk_video_formats)
73
74 static const struct mtk_video_fmt *mtk_vdec_find_format(struct v4l2_format *f)
75 {
76 const struct mtk_video_fmt *fmt;
77 unsigned int k;
78
79 for (k = 0; k < NUM_FORMATS; k++) {
80 fmt = &mtk_video_formats[k];
81 if (fmt->fourcc == f->fmt.pix_mp.pixelformat)
82 return fmt;
83 }
84
85 return NULL;
86 }
87
88 static struct mtk_q_data *mtk_vdec_get_q_data(struct mtk_vcodec_ctx *ctx,
89 enum v4l2_buf_type type)
90 {
91 if (V4L2_TYPE_IS_OUTPUT(type))
92 return &ctx->q_data[MTK_Q_DATA_SRC];
93
94 return &ctx->q_data[MTK_Q_DATA_DST];
95 }
96
97 /*
98 * This function tries to clean all display buffers, the buffers will return
99 * in display order.
100 * Note the buffers returned from codec driver may still be in driver's
101 * reference list.
102 */
103 static struct vb2_buffer *get_display_buffer(struct mtk_vcodec_ctx *ctx)
104 {
105 struct vdec_fb *disp_frame_buffer = NULL;
106 struct mtk_video_dec_buf *dstbuf;
107 struct vb2_v4l2_buffer *vb;
108
109 mtk_v4l2_debug(3, "[%d]", ctx->id);
110 if (vdec_if_get_param(ctx,
111 GET_PARAM_DISP_FRAME_BUFFER,
112 &disp_frame_buffer)) {
113 mtk_v4l2_err("[%d]Cannot get param : GET_PARAM_DISP_FRAME_BUFFER",
114 ctx->id);
115 return NULL;
116 }
117
118 if (disp_frame_buffer == NULL) {
119 mtk_v4l2_debug(3, "No display frame buffer");
120 return NULL;
121 }
122
123 dstbuf = container_of(disp_frame_buffer, struct mtk_video_dec_buf,
124 frame_buffer);
125 vb = &dstbuf->m2m_buf.vb;
126 mutex_lock(&ctx->lock);
127 if (dstbuf->used) {
128 vb2_set_plane_payload(&vb->vb2_buf, 0,
129 ctx->picinfo.fb_sz[0]);
130 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2)
131 vb2_set_plane_payload(&vb->vb2_buf, 1,
132 ctx->picinfo.fb_sz[1]);
133
134 mtk_v4l2_debug(2,
135 "[%d]status=%x queue id=%d to done_list %d",
136 ctx->id, disp_frame_buffer->status,
137 vb->vb2_buf.index,
138 dstbuf->queued_in_vb2);
139
140 v4l2_m2m_buf_done(vb, VB2_BUF_STATE_DONE);
141 ctx->decoded_frame_cnt++;
142 }
143 mutex_unlock(&ctx->lock);
144 return &vb->vb2_buf;
145 }
146
147 /*
148 * This function tries to clean all capture buffers that are not used as
149 * reference buffers by codec driver any more
150 * In this case, we need re-queue buffer to vb2 buffer if user space
151 * already returns this buffer to v4l2 or this buffer is just the output of
152 * previous sps/pps/resolution change decode, or do nothing if user
153 * space still owns this buffer
154 */
155 static struct vb2_buffer *get_free_buffer(struct mtk_vcodec_ctx *ctx)
156 {
157 struct mtk_video_dec_buf *dstbuf;
158 struct vdec_fb *free_frame_buffer = NULL;
159 struct vb2_v4l2_buffer *vb;
160
161 if (vdec_if_get_param(ctx,
162 GET_PARAM_FREE_FRAME_BUFFER,
163 &free_frame_buffer)) {
164 mtk_v4l2_err("[%d] Error!! Cannot get param", ctx->id);
165 return NULL;
166 }
167 if (free_frame_buffer == NULL) {
168 mtk_v4l2_debug(3, " No free frame buffer");
169 return NULL;
170 }
171
172 mtk_v4l2_debug(3, "[%d] tmp_frame_addr = 0x%p",
173 ctx->id, free_frame_buffer);
174
175 dstbuf = container_of(free_frame_buffer, struct mtk_video_dec_buf,
176 frame_buffer);
177 vb = &dstbuf->m2m_buf.vb;
178
179 mutex_lock(&ctx->lock);
180 if (dstbuf->used) {
181 if ((dstbuf->queued_in_vb2) &&
182 (dstbuf->queued_in_v4l2) &&
183 (free_frame_buffer->status == FB_ST_FREE)) {
184 /*
185 * After decode sps/pps or non-display buffer, we don't
186 * need to return capture buffer to user space, but
187 * just re-queue this capture buffer to vb2 queue.
188 * This reduce overheads that dq/q unused capture
189 * buffer. In this case, queued_in_vb2 = true.
190 */
191 mtk_v4l2_debug(2,
192 "[%d]status=%x queue id=%d to rdy_queue %d",
193 ctx->id, free_frame_buffer->status,
194 vb->vb2_buf.index,
195 dstbuf->queued_in_vb2);
196 v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
197 } else if ((dstbuf->queued_in_vb2 == false) &&
198 (dstbuf->queued_in_v4l2 == true)) {
199 /*
200 * If buffer in v4l2 driver but not in vb2 queue yet,
201 * and we get this buffer from free_list, it means
202 * that codec driver do not use this buffer as
203 * reference buffer anymore. We should q buffer to vb2
204 * queue, so later work thread could get this buffer
205 * for decode. In this case, queued_in_vb2 = false
206 * means this buffer is not from previous decode
207 * output.
208 */
209 mtk_v4l2_debug(2,
210 "[%d]status=%x queue id=%d to rdy_queue",
211 ctx->id, free_frame_buffer->status,
212 vb->vb2_buf.index);
213 v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
214 dstbuf->queued_in_vb2 = true;
215 } else {
216 /*
217 * Codec driver do not need to reference this capture
218 * buffer and this buffer is not in v4l2 driver.
219 * Then we don't need to do any thing, just add log when
220 * we need to debug buffer flow.
221 * When this buffer q from user space, it could
222 * directly q to vb2 buffer
223 */
224 mtk_v4l2_debug(3, "[%d]status=%x err queue id=%d %d %d",
225 ctx->id, free_frame_buffer->status,
226 vb->vb2_buf.index,
227 dstbuf->queued_in_vb2,
228 dstbuf->queued_in_v4l2);
229 }
230 dstbuf->used = false;
231 }
232 mutex_unlock(&ctx->lock);
233 return &vb->vb2_buf;
234 }
235
236 static void clean_display_buffer(struct mtk_vcodec_ctx *ctx)
237 {
238 struct vb2_buffer *framptr;
239
240 do {
241 framptr = get_display_buffer(ctx);
242 } while (framptr);
243 }
244
245 static void clean_free_buffer(struct mtk_vcodec_ctx *ctx)
246 {
247 struct vb2_buffer *framptr;
248
249 do {
250 framptr = get_free_buffer(ctx);
251 } while (framptr);
252 }
253
254 static void mtk_vdec_queue_res_chg_event(struct mtk_vcodec_ctx *ctx)
255 {
256 static const struct v4l2_event ev_src_ch = {
257 .type = V4L2_EVENT_SOURCE_CHANGE,
258 .u.src_change.changes =
259 V4L2_EVENT_SRC_CH_RESOLUTION,
260 };
261
262 mtk_v4l2_debug(1, "[%d]", ctx->id);
263 v4l2_event_queue_fh(&ctx->fh, &ev_src_ch);
264 }
265
266 static void mtk_vdec_flush_decoder(struct mtk_vcodec_ctx *ctx)
267 {
268 bool res_chg;
269 int ret = 0;
270
271 ret = vdec_if_decode(ctx, NULL, NULL, &res_chg);
272 if (ret)
273 mtk_v4l2_err("DecodeFinal failed, ret=%d", ret);
274
275 clean_display_buffer(ctx);
276 clean_free_buffer(ctx);
277 }
278
279 static void mtk_vdec_update_fmt(struct mtk_vcodec_ctx *ctx,
280 unsigned int pixelformat)
281 {
282 const struct mtk_video_fmt *fmt;
283 struct mtk_q_data *dst_q_data;
284 unsigned int k;
285
286 dst_q_data = &ctx->q_data[MTK_Q_DATA_DST];
287 for (k = 0; k < NUM_FORMATS; k++) {
288 fmt = &mtk_video_formats[k];
289 if (fmt->fourcc == pixelformat) {
290 mtk_v4l2_debug(1, "Update cap fourcc(%d -> %d)",
291 dst_q_data->fmt->fourcc, pixelformat);
292 dst_q_data->fmt = fmt;
293 return;
294 }
295 }
296
297 mtk_v4l2_err("Cannot get fourcc(%d), using init value", pixelformat);
298 }
299
300 static int mtk_vdec_pic_info_update(struct mtk_vcodec_ctx *ctx)
301 {
302 unsigned int dpbsize = 0;
303 int ret;
304
305 if (vdec_if_get_param(ctx,
306 GET_PARAM_PIC_INFO,
307 &ctx->last_decoded_picinfo)) {
308 mtk_v4l2_err("[%d]Error!! Cannot get param : GET_PARAM_PICTURE_INFO ERR",
309 ctx->id);
310 return -EINVAL;
311 }
312
313 if (ctx->last_decoded_picinfo.pic_w == 0 ||
314 ctx->last_decoded_picinfo.pic_h == 0 ||
315 ctx->last_decoded_picinfo.buf_w == 0 ||
316 ctx->last_decoded_picinfo.buf_h == 0) {
317 mtk_v4l2_err("Cannot get correct pic info");
318 return -EINVAL;
319 }
320
321 if (ctx->last_decoded_picinfo.cap_fourcc != ctx->picinfo.cap_fourcc &&
322 ctx->picinfo.cap_fourcc != 0)
323 mtk_vdec_update_fmt(ctx, ctx->picinfo.cap_fourcc);
324
325 if ((ctx->last_decoded_picinfo.pic_w == ctx->picinfo.pic_w) ||
326 (ctx->last_decoded_picinfo.pic_h == ctx->picinfo.pic_h))
327 return 0;
328
329 mtk_v4l2_debug(1,
330 "[%d]-> new(%d,%d), old(%d,%d), real(%d,%d)",
331 ctx->id, ctx->last_decoded_picinfo.pic_w,
332 ctx->last_decoded_picinfo.pic_h,
333 ctx->picinfo.pic_w, ctx->picinfo.pic_h,
334 ctx->last_decoded_picinfo.buf_w,
335 ctx->last_decoded_picinfo.buf_h);
336
337 ret = vdec_if_get_param(ctx, GET_PARAM_DPB_SIZE, &dpbsize);
338 if (dpbsize == 0)
339 mtk_v4l2_err("Incorrect dpb size, ret=%d", ret);
340
341 ctx->dpb_size = dpbsize;
342
343 return ret;
344 }
345
346 static void mtk_vdec_worker(struct work_struct *work)
347 {
348 struct mtk_vcodec_ctx *ctx = container_of(work, struct mtk_vcodec_ctx,
349 decode_work);
350 struct mtk_vcodec_dev *dev = ctx->dev;
351 struct vb2_v4l2_buffer *src_buf, *dst_buf;
352 struct mtk_vcodec_mem buf;
353 struct vdec_fb *pfb;
354 bool res_chg = false;
355 int ret;
356 struct mtk_video_dec_buf *dst_buf_info, *src_buf_info;
357
358 src_buf = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
359 if (src_buf == NULL) {
360 v4l2_m2m_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx);
361 mtk_v4l2_debug(1, "[%d] src_buf empty!!", ctx->id);
362 return;
363 }
364
365 dst_buf = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
366 if (dst_buf == NULL) {
367 v4l2_m2m_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx);
368 mtk_v4l2_debug(1, "[%d] dst_buf empty!!", ctx->id);
369 return;
370 }
371
372 src_buf_info = container_of(src_buf, struct mtk_video_dec_buf,
373 m2m_buf.vb);
374 dst_buf_info = container_of(dst_buf, struct mtk_video_dec_buf,
375 m2m_buf.vb);
376
377 pfb = &dst_buf_info->frame_buffer;
378 pfb->base_y.va = vb2_plane_vaddr(&dst_buf->vb2_buf, 0);
379 pfb->base_y.dma_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
380 pfb->base_y.size = ctx->picinfo.fb_sz[0];
381
382 pfb->base_c.va = vb2_plane_vaddr(&dst_buf->vb2_buf, 1);
383 pfb->base_c.dma_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 1);
384 pfb->base_c.size = ctx->picinfo.fb_sz[1];
385 pfb->status = 0;
386 mtk_v4l2_debug(3, "===>[%d] vdec_if_decode() ===>", ctx->id);
387
388 mtk_v4l2_debug(3,
389 "id=%d Framebuf pfb=%p VA=%p Y_DMA=%pad C_DMA=%pad Size=%zx",
390 dst_buf->vb2_buf.index, pfb,
391 pfb->base_y.va, &pfb->base_y.dma_addr,
392 &pfb->base_c.dma_addr, pfb->base_y.size);
393
394 if (src_buf_info->lastframe) {
395 mtk_v4l2_debug(1, "Got empty flush input buffer.");
396 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
397
398 /* update dst buf status */
399 dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
400 mutex_lock(&ctx->lock);
401 dst_buf_info->used = false;
402 mutex_unlock(&ctx->lock);
403
404 vdec_if_decode(ctx, NULL, NULL, &res_chg);
405 clean_display_buffer(ctx);
406 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);
407 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2)
408 vb2_set_plane_payload(&dst_buf->vb2_buf, 1, 0);
409 dst_buf->flags |= V4L2_BUF_FLAG_LAST;
410 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);
411 clean_free_buffer(ctx);
412 v4l2_m2m_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx);
413 return;
414 }
415 buf.va = vb2_plane_vaddr(&src_buf->vb2_buf, 0);
416 buf.dma_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
417 buf.size = (size_t)src_buf->vb2_buf.planes[0].bytesused;
418 if (!buf.va) {
419 v4l2_m2m_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx);
420 mtk_v4l2_err("[%d] id=%d src_addr is NULL!!",
421 ctx->id, src_buf->vb2_buf.index);
422 return;
423 }
424 mtk_v4l2_debug(3, "[%d] Bitstream VA=%p DMA=%pad Size=%zx vb=%p",
425 ctx->id, buf.va, &buf.dma_addr, buf.size, src_buf);
426 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
427 dst_buf->timecode = src_buf->timecode;
428 mutex_lock(&ctx->lock);
429 dst_buf_info->used = true;
430 mutex_unlock(&ctx->lock);
431 src_buf_info->used = true;
432
433 ret = vdec_if_decode(ctx, &buf, pfb, &res_chg);
434
435 if (ret) {
436 mtk_v4l2_err(
437 " <===[%d], src_buf[%d] sz=0x%zx pts=%llu dst_buf[%d] vdec_if_decode() ret=%d res_chg=%d===>",
438 ctx->id,
439 src_buf->vb2_buf.index,
440 buf.size,
441 src_buf->vb2_buf.timestamp,
442 dst_buf->vb2_buf.index,
443 ret, res_chg);
444 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
445 if (ret == -EIO) {
446 mutex_lock(&ctx->lock);
447 src_buf_info->error = true;
448 mutex_unlock(&ctx->lock);
449 }
450 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
451 } else if (res_chg == false) {
452 /*
453 * we only return src buffer with VB2_BUF_STATE_DONE
454 * when decode success without resolution change
455 */
456 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
457 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
458 }
459
460 dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
461 clean_display_buffer(ctx);
462 clean_free_buffer(ctx);
463
464 if (!ret && res_chg) {
465 mtk_vdec_pic_info_update(ctx);
466 /*
467 * On encountering a resolution change in the stream.
468 * The driver must first process and decode all
469 * remaining buffers from before the resolution change
470 * point, so call flush decode here
471 */
472 mtk_vdec_flush_decoder(ctx);
473 /*
474 * After all buffers containing decoded frames from
475 * before the resolution change point ready to be
476 * dequeued on the CAPTURE queue, the driver sends a
477 * V4L2_EVENT_SOURCE_CHANGE event for source change
478 * type V4L2_EVENT_SRC_CH_RESOLUTION
479 */
480 mtk_vdec_queue_res_chg_event(ctx);
481 }
482 v4l2_m2m_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx);
483 }
484
485 static int vidioc_try_decoder_cmd(struct file *file, void *priv,
486 struct v4l2_decoder_cmd *cmd)
487 {
488 switch (cmd->cmd) {
489 case V4L2_DEC_CMD_STOP:
490 case V4L2_DEC_CMD_START:
491 if (cmd->flags != 0) {
492 mtk_v4l2_err("cmd->flags=%u", cmd->flags);
493 return -EINVAL;
494 }
495 break;
496 default:
497 return -EINVAL;
498 }
499 return 0;
500 }
501
502
503 static int vidioc_decoder_cmd(struct file *file, void *priv,
504 struct v4l2_decoder_cmd *cmd)
505 {
506 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
507 struct vb2_queue *src_vq, *dst_vq;
508 int ret;
509
510 ret = vidioc_try_decoder_cmd(file, priv, cmd);
511 if (ret)
512 return ret;
513
514 mtk_v4l2_debug(1, "decoder cmd=%u", cmd->cmd);
515 dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,
516 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
517 switch (cmd->cmd) {
518 case V4L2_DEC_CMD_STOP:
519 src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,
520 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
521 if (!vb2_is_streaming(src_vq)) {
522 mtk_v4l2_debug(1, "Output stream is off. No need to flush.");
523 return 0;
524 }
525 if (!vb2_is_streaming(dst_vq)) {
526 mtk_v4l2_debug(1, "Capture stream is off. No need to flush.");
527 return 0;
528 }
529 v4l2_m2m_buf_queue(ctx->m2m_ctx,
530 &ctx->empty_flush_buf->m2m_buf.vb);
531 v4l2_m2m_try_schedule(ctx->m2m_ctx);
532 break;
533
534 case V4L2_DEC_CMD_START:
535 vb2_clear_last_buffer_dequeued(dst_vq);
536 break;
537
538 default:
539 return -EINVAL;
540 }
541
542 return 0;
543 }
544
545 void mtk_vdec_unlock(struct mtk_vcodec_ctx *ctx)
546 {
547 mutex_unlock(&ctx->dev->dec_mutex);
548 }
549
550 void mtk_vdec_lock(struct mtk_vcodec_ctx *ctx)
551 {
552 mutex_lock(&ctx->dev->dec_mutex);
553 }
554
555 void mtk_vcodec_dec_release(struct mtk_vcodec_ctx *ctx)
556 {
557 vdec_if_deinit(ctx);
558 ctx->state = MTK_STATE_FREE;
559 }
560
561 void mtk_vcodec_dec_set_default_params(struct mtk_vcodec_ctx *ctx)
562 {
563 struct mtk_q_data *q_data;
564
565 ctx->m2m_ctx->q_lock = &ctx->dev->dev_mutex;
566 ctx->fh.m2m_ctx = ctx->m2m_ctx;
567 ctx->fh.ctrl_handler = &ctx->ctrl_hdl;
568 INIT_WORK(&ctx->decode_work, mtk_vdec_worker);
569 ctx->colorspace = V4L2_COLORSPACE_REC709;
570 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
571 ctx->quantization = V4L2_QUANTIZATION_DEFAULT;
572 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT;
573
574 q_data = &ctx->q_data[MTK_Q_DATA_SRC];
575 memset(q_data, 0, sizeof(struct mtk_q_data));
576 q_data->visible_width = DFT_CFG_WIDTH;
577 q_data->visible_height = DFT_CFG_HEIGHT;
578 q_data->fmt = &mtk_video_formats[OUT_FMT_IDX];
579 q_data->field = V4L2_FIELD_NONE;
580
581 q_data->sizeimage[0] = DFT_CFG_WIDTH * DFT_CFG_HEIGHT;
582 q_data->bytesperline[0] = 0;
583
584 q_data = &ctx->q_data[MTK_Q_DATA_DST];
585 memset(q_data, 0, sizeof(struct mtk_q_data));
586 q_data->visible_width = DFT_CFG_WIDTH;
587 q_data->visible_height = DFT_CFG_HEIGHT;
588 q_data->coded_width = DFT_CFG_WIDTH;
589 q_data->coded_height = DFT_CFG_HEIGHT;
590 q_data->fmt = &mtk_video_formats[CAP_FMT_IDX];
591 q_data->field = V4L2_FIELD_NONE;
592
593 v4l_bound_align_image(&q_data->coded_width,
594 MTK_VDEC_MIN_W,
595 MTK_VDEC_MAX_W, 4,
596 &q_data->coded_height,
597 MTK_VDEC_MIN_H,
598 MTK_VDEC_MAX_H, 5, 6);
599
600 q_data->sizeimage[0] = q_data->coded_width * q_data->coded_height;
601 q_data->bytesperline[0] = q_data->coded_width;
602 q_data->sizeimage[1] = q_data->sizeimage[0] / 2;
603 q_data->bytesperline[1] = q_data->coded_width;
604 }
605
606 static int vidioc_vdec_qbuf(struct file *file, void *priv,
607 struct v4l2_buffer *buf)
608 {
609 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
610
611 if (ctx->state == MTK_STATE_ABORT) {
612 mtk_v4l2_err("[%d] Call on QBUF after unrecoverable error",
613 ctx->id);
614 return -EIO;
615 }
616
617 return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
618 }
619
620 static int vidioc_vdec_dqbuf(struct file *file, void *priv,
621 struct v4l2_buffer *buf)
622 {
623 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
624
625 if (ctx->state == MTK_STATE_ABORT) {
626 mtk_v4l2_err("[%d] Call on DQBUF after unrecoverable error",
627 ctx->id);
628 return -EIO;
629 }
630
631 return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
632 }
633
634 static int vidioc_vdec_querycap(struct file *file, void *priv,
635 struct v4l2_capability *cap)
636 {
637 strscpy(cap->driver, MTK_VCODEC_DEC_NAME, sizeof(cap->driver));
638 strscpy(cap->bus_info, MTK_PLATFORM_STR, sizeof(cap->bus_info));
639 strscpy(cap->card, MTK_PLATFORM_STR, sizeof(cap->card));
640
641 return 0;
642 }
643
644 static int vidioc_vdec_subscribe_evt(struct v4l2_fh *fh,
645 const struct v4l2_event_subscription *sub)
646 {
647 switch (sub->type) {
648 case V4L2_EVENT_EOS:
649 return v4l2_event_subscribe(fh, sub, 2, NULL);
650 case V4L2_EVENT_SOURCE_CHANGE:
651 return v4l2_src_change_event_subscribe(fh, sub);
652 default:
653 return v4l2_ctrl_subscribe_event(fh, sub);
654 }
655 }
656
657 static int vidioc_try_fmt(struct v4l2_format *f,
658 const struct mtk_video_fmt *fmt)
659 {
660 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
661 int i;
662
663 pix_fmt_mp->field = V4L2_FIELD_NONE;
664
665 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
666 pix_fmt_mp->num_planes = 1;
667 pix_fmt_mp->plane_fmt[0].bytesperline = 0;
668 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
669 int tmp_w, tmp_h;
670
671 pix_fmt_mp->height = clamp(pix_fmt_mp->height,
672 MTK_VDEC_MIN_H,
673 MTK_VDEC_MAX_H);
674 pix_fmt_mp->width = clamp(pix_fmt_mp->width,
675 MTK_VDEC_MIN_W,
676 MTK_VDEC_MAX_W);
677
678 /*
679 * Find next closer width align 64, heign align 64, size align
680 * 64 rectangle
681 * Note: This only get default value, the real HW needed value
682 * only available when ctx in MTK_STATE_HEADER state
683 */
684 tmp_w = pix_fmt_mp->width;
685 tmp_h = pix_fmt_mp->height;
686 v4l_bound_align_image(&pix_fmt_mp->width,
687 MTK_VDEC_MIN_W,
688 MTK_VDEC_MAX_W, 6,
689 &pix_fmt_mp->height,
690 MTK_VDEC_MIN_H,
691 MTK_VDEC_MAX_H, 6, 9);
692
693 if (pix_fmt_mp->width < tmp_w &&
694 (pix_fmt_mp->width + 64) <= MTK_VDEC_MAX_W)
695 pix_fmt_mp->width += 64;
696 if (pix_fmt_mp->height < tmp_h &&
697 (pix_fmt_mp->height + 64) <= MTK_VDEC_MAX_H)
698 pix_fmt_mp->height += 64;
699
700 mtk_v4l2_debug(0,
701 "before resize width=%d, height=%d, after resize width=%d, height=%d, sizeimage=%d",
702 tmp_w, tmp_h, pix_fmt_mp->width,
703 pix_fmt_mp->height,
704 pix_fmt_mp->width * pix_fmt_mp->height);
705
706 pix_fmt_mp->num_planes = fmt->num_planes;
707 pix_fmt_mp->plane_fmt[0].sizeimage =
708 pix_fmt_mp->width * pix_fmt_mp->height;
709 pix_fmt_mp->plane_fmt[0].bytesperline = pix_fmt_mp->width;
710
711 if (pix_fmt_mp->num_planes == 2) {
712 pix_fmt_mp->plane_fmt[1].sizeimage =
713 (pix_fmt_mp->width * pix_fmt_mp->height) / 2;
714 pix_fmt_mp->plane_fmt[1].bytesperline =
715 pix_fmt_mp->width;
716 }
717 }
718
719 for (i = 0; i < pix_fmt_mp->num_planes; i++)
720 memset(&(pix_fmt_mp->plane_fmt[i].reserved[0]), 0x0,
721 sizeof(pix_fmt_mp->plane_fmt[0].reserved));
722
723 pix_fmt_mp->flags = 0;
724 memset(&pix_fmt_mp->reserved, 0x0, sizeof(pix_fmt_mp->reserved));
725 return 0;
726 }
727
728 static int vidioc_try_fmt_vid_cap_mplane(struct file *file, void *priv,
729 struct v4l2_format *f)
730 {
731 const struct mtk_video_fmt *fmt;
732
733 fmt = mtk_vdec_find_format(f);
734 if (!fmt) {
735 f->fmt.pix.pixelformat = mtk_video_formats[CAP_FMT_IDX].fourcc;
736 fmt = mtk_vdec_find_format(f);
737 }
738
739 return vidioc_try_fmt(f, fmt);
740 }
741
742 static int vidioc_try_fmt_vid_out_mplane(struct file *file, void *priv,
743 struct v4l2_format *f)
744 {
745 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
746 const struct mtk_video_fmt *fmt;
747
748 fmt = mtk_vdec_find_format(f);
749 if (!fmt) {
750 f->fmt.pix.pixelformat = mtk_video_formats[OUT_FMT_IDX].fourcc;
751 fmt = mtk_vdec_find_format(f);
752 }
753
754 if (pix_fmt_mp->plane_fmt[0].sizeimage == 0) {
755 mtk_v4l2_err("sizeimage of output format must be given");
756 return -EINVAL;
757 }
758
759 return vidioc_try_fmt(f, fmt);
760 }
761
762 static int vidioc_vdec_g_selection(struct file *file, void *priv,
763 struct v4l2_selection *s)
764 {
765 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
766 struct mtk_q_data *q_data;
767
768 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
769 return -EINVAL;
770
771 q_data = &ctx->q_data[MTK_Q_DATA_DST];
772
773 switch (s->target) {
774 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
775 s->r.left = 0;
776 s->r.top = 0;
777 s->r.width = ctx->picinfo.pic_w;
778 s->r.height = ctx->picinfo.pic_h;
779 break;
780 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
781 s->r.left = 0;
782 s->r.top = 0;
783 s->r.width = ctx->picinfo.buf_w;
784 s->r.height = ctx->picinfo.buf_h;
785 break;
786 case V4L2_SEL_TGT_COMPOSE:
787 if (vdec_if_get_param(ctx, GET_PARAM_CROP_INFO, &(s->r))) {
788 /* set to default value if header info not ready yet*/
789 s->r.left = 0;
790 s->r.top = 0;
791 s->r.width = q_data->visible_width;
792 s->r.height = q_data->visible_height;
793 }
794 break;
795 default:
796 return -EINVAL;
797 }
798
799 if (ctx->state < MTK_STATE_HEADER) {
800 /* set to default value if header info not ready yet*/
801 s->r.left = 0;
802 s->r.top = 0;
803 s->r.width = q_data->visible_width;
804 s->r.height = q_data->visible_height;
805 return 0;
806 }
807
808 return 0;
809 }
810
811 static int vidioc_vdec_s_selection(struct file *file, void *priv,
812 struct v4l2_selection *s)
813 {
814 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
815
816 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
817 return -EINVAL;
818
819 switch (s->target) {
820 case V4L2_SEL_TGT_COMPOSE:
821 s->r.left = 0;
822 s->r.top = 0;
823 s->r.width = ctx->picinfo.pic_w;
824 s->r.height = ctx->picinfo.pic_h;
825 break;
826 default:
827 return -EINVAL;
828 }
829
830 return 0;
831 }
832
833 static int vidioc_vdec_s_fmt(struct file *file, void *priv,
834 struct v4l2_format *f)
835 {
836 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
837 struct v4l2_pix_format_mplane *pix_mp;
838 struct mtk_q_data *q_data;
839 int ret = 0;
840 const struct mtk_video_fmt *fmt;
841
842 mtk_v4l2_debug(3, "[%d]", ctx->id);
843
844 q_data = mtk_vdec_get_q_data(ctx, f->type);
845 if (!q_data)
846 return -EINVAL;
847
848 pix_mp = &f->fmt.pix_mp;
849 /*
850 * Setting OUTPUT format after OUTPUT buffers are allocated is invalid
851 * if using the stateful API.
852 */
853 if ((f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) &&
854 vb2_is_busy(&ctx->m2m_ctx->out_q_ctx.q)) {
855 mtk_v4l2_err("out_q_ctx buffers already requested");
856 ret = -EBUSY;
857 }
858
859 /*
860 * Setting CAPTURE format after CAPTURE buffers are allocated is
861 * invalid.
862 */
863 if ((f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) &&
864 vb2_is_busy(&ctx->m2m_ctx->cap_q_ctx.q)) {
865 mtk_v4l2_err("cap_q_ctx buffers already requested");
866 ret = -EBUSY;
867 }
868
869 fmt = mtk_vdec_find_format(f);
870 if (fmt == NULL) {
871 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
872 f->fmt.pix.pixelformat =
873 mtk_video_formats[OUT_FMT_IDX].fourcc;
874 fmt = mtk_vdec_find_format(f);
875 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
876 f->fmt.pix.pixelformat =
877 mtk_video_formats[CAP_FMT_IDX].fourcc;
878 fmt = mtk_vdec_find_format(f);
879 }
880 }
881 if (fmt == NULL)
882 return -EINVAL;
883
884 q_data->fmt = fmt;
885 vidioc_try_fmt(f, q_data->fmt);
886 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
887 q_data->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage;
888 q_data->coded_width = pix_mp->width;
889 q_data->coded_height = pix_mp->height;
890
891 ctx->colorspace = pix_mp->colorspace;
892 ctx->ycbcr_enc = pix_mp->ycbcr_enc;
893 ctx->quantization = pix_mp->quantization;
894 ctx->xfer_func = pix_mp->xfer_func;
895
896 if (ctx->state == MTK_STATE_FREE) {
897 ret = vdec_if_init(ctx, q_data->fmt->fourcc);
898 if (ret) {
899 mtk_v4l2_err("[%d]: vdec_if_init() fail ret=%d",
900 ctx->id, ret);
901 return -EINVAL;
902 }
903 ctx->state = MTK_STATE_INIT;
904 }
905 }
906
907 return 0;
908 }
909
910 static int vidioc_enum_framesizes(struct file *file, void *priv,
911 struct v4l2_frmsizeenum *fsize)
912 {
913 int i = 0;
914 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
915
916 if (fsize->index != 0)
917 return -EINVAL;
918
919 for (i = 0; i < NUM_SUPPORTED_FRAMESIZE; ++i) {
920 if (fsize->pixel_format != mtk_vdec_framesizes[i].fourcc)
921 continue;
922
923 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
924 fsize->stepwise = mtk_vdec_framesizes[i].stepwise;
925 if (!(ctx->dev->dec_capability &
926 VCODEC_CAPABILITY_4K_DISABLED)) {
927 mtk_v4l2_debug(3, "4K is enabled");
928 fsize->stepwise.max_width =
929 VCODEC_DEC_4K_CODED_WIDTH;
930 fsize->stepwise.max_height =
931 VCODEC_DEC_4K_CODED_HEIGHT;
932 }
933 mtk_v4l2_debug(1, "%x, %d %d %d %d %d %d",
934 ctx->dev->dec_capability,
935 fsize->stepwise.min_width,
936 fsize->stepwise.max_width,
937 fsize->stepwise.step_width,
938 fsize->stepwise.min_height,
939 fsize->stepwise.max_height,
940 fsize->stepwise.step_height);
941 return 0;
942 }
943
944 return -EINVAL;
945 }
946
947 static int vidioc_enum_fmt(struct v4l2_fmtdesc *f, bool output_queue)
948 {
949 const struct mtk_video_fmt *fmt;
950 int i, j = 0;
951
952 for (i = 0; i < NUM_FORMATS; i++) {
953 if (output_queue && (mtk_video_formats[i].type != MTK_FMT_DEC))
954 continue;
955 if (!output_queue &&
956 (mtk_video_formats[i].type != MTK_FMT_FRAME))
957 continue;
958
959 if (j == f->index)
960 break;
961 ++j;
962 }
963
964 if (i == NUM_FORMATS)
965 return -EINVAL;
966
967 fmt = &mtk_video_formats[i];
968 f->pixelformat = fmt->fourcc;
969 f->flags = fmt->flags;
970
971 return 0;
972 }
973
974 static int vidioc_vdec_enum_fmt_vid_cap(struct file *file, void *priv,
975 struct v4l2_fmtdesc *f)
976 {
977 return vidioc_enum_fmt(f, false);
978 }
979
980 static int vidioc_vdec_enum_fmt_vid_out(struct file *file, void *priv,
981 struct v4l2_fmtdesc *f)
982 {
983 return vidioc_enum_fmt(f, true);
984 }
985
986 static int vidioc_vdec_g_fmt(struct file *file, void *priv,
987 struct v4l2_format *f)
988 {
989 struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
990 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
991 struct vb2_queue *vq;
992 struct mtk_q_data *q_data;
993
994 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
995 if (!vq) {
996 mtk_v4l2_err("no vb2 queue for type=%d", f->type);
997 return -EINVAL;
998 }
999
1000 q_data = mtk_vdec_get_q_data(ctx, f->type);
1001
1002 pix_mp->field = V4L2_FIELD_NONE;
1003 pix_mp->colorspace = ctx->colorspace;
1004 pix_mp->ycbcr_enc = ctx->ycbcr_enc;
1005 pix_mp->quantization = ctx->quantization;
1006 pix_mp->xfer_func = ctx->xfer_func;
1007
1008 if ((f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) &&
1009 (ctx->state >= MTK_STATE_HEADER)) {
1010 /* Until STREAMOFF is called on the CAPTURE queue
1011 * (acknowledging the event), the driver operates as if
1012 * the resolution hasn't changed yet.
1013 * So we just return picinfo yet, and update picinfo in
1014 * stop_streaming hook function
1015 */
1016 q_data->sizeimage[0] = ctx->picinfo.fb_sz[0];
1017 q_data->sizeimage[1] = ctx->picinfo.fb_sz[1];
1018 q_data->bytesperline[0] = ctx->last_decoded_picinfo.buf_w;
1019 q_data->bytesperline[1] = ctx->last_decoded_picinfo.buf_w;
1020 q_data->coded_width = ctx->picinfo.buf_w;
1021 q_data->coded_height = ctx->picinfo.buf_h;
1022 ctx->last_decoded_picinfo.cap_fourcc = q_data->fmt->fourcc;
1023
1024 /*
1025 * Width and height are set to the dimensions
1026 * of the movie, the buffer is bigger and
1027 * further processing stages should crop to this
1028 * rectangle.
1029 */
1030 pix_mp->width = q_data->coded_width;
1031 pix_mp->height = q_data->coded_height;
1032
1033 /*
1034 * Set pixelformat to the format in which mt vcodec
1035 * outputs the decoded frame
1036 */
1037 pix_mp->num_planes = q_data->fmt->num_planes;
1038 pix_mp->pixelformat = q_data->fmt->fourcc;
1039 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0];
1040 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0];
1041 pix_mp->plane_fmt[1].bytesperline = q_data->bytesperline[1];
1042 pix_mp->plane_fmt[1].sizeimage = q_data->sizeimage[1];
1043
1044 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1045 /*
1046 * This is run on OUTPUT
1047 * The buffer contains compressed image
1048 * so width and height have no meaning.
1049 * Assign value here to pass v4l2-compliance test
1050 */
1051 pix_mp->width = q_data->visible_width;
1052 pix_mp->height = q_data->visible_height;
1053 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0];
1054 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0];
1055 pix_mp->pixelformat = q_data->fmt->fourcc;
1056 pix_mp->num_planes = q_data->fmt->num_planes;
1057 } else {
1058 pix_mp->width = q_data->coded_width;
1059 pix_mp->height = q_data->coded_height;
1060 pix_mp->num_planes = q_data->fmt->num_planes;
1061 pix_mp->pixelformat = q_data->fmt->fourcc;
1062 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0];
1063 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0];
1064 pix_mp->plane_fmt[1].bytesperline = q_data->bytesperline[1];
1065 pix_mp->plane_fmt[1].sizeimage = q_data->sizeimage[1];
1066
1067 mtk_v4l2_debug(1, "[%d] type=%d state=%d Format information could not be read, not ready yet!",
1068 ctx->id, f->type, ctx->state);
1069 }
1070
1071 return 0;
1072 }
1073
1074 static int vb2ops_vdec_queue_setup(struct vb2_queue *vq,
1075 unsigned int *nbuffers,
1076 unsigned int *nplanes,
1077 unsigned int sizes[],
1078 struct device *alloc_devs[])
1079 {
1080 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(vq);
1081 struct mtk_q_data *q_data;
1082 unsigned int i;
1083
1084 q_data = mtk_vdec_get_q_data(ctx, vq->type);
1085
1086 if (q_data == NULL) {
1087 mtk_v4l2_err("vq->type=%d err\n", vq->type);
1088 return -EINVAL;
1089 }
1090
1091 if (*nplanes) {
1092 for (i = 0; i < *nplanes; i++) {
1093 if (sizes[i] < q_data->sizeimage[i])
1094 return -EINVAL;
1095 }
1096 } else {
1097 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1098 *nplanes = 2;
1099 else
1100 *nplanes = 1;
1101
1102 for (i = 0; i < *nplanes; i++)
1103 sizes[i] = q_data->sizeimage[i];
1104 }
1105
1106 mtk_v4l2_debug(1,
1107 "[%d]\t type = %d, get %d plane(s), %d buffer(s) of size 0x%x 0x%x ",
1108 ctx->id, vq->type, *nplanes, *nbuffers,
1109 sizes[0], sizes[1]);
1110
1111 return 0;
1112 }
1113
1114 static int vb2ops_vdec_buf_prepare(struct vb2_buffer *vb)
1115 {
1116 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1117 struct mtk_q_data *q_data;
1118 int i;
1119
1120 mtk_v4l2_debug(3, "[%d] (%d) id=%d",
1121 ctx->id, vb->vb2_queue->type, vb->index);
1122
1123 q_data = mtk_vdec_get_q_data(ctx, vb->vb2_queue->type);
1124
1125 for (i = 0; i < q_data->fmt->num_planes; i++) {
1126 if (vb2_plane_size(vb, i) < q_data->sizeimage[i]) {
1127 mtk_v4l2_err("data will not fit into plane %d (%lu < %d)",
1128 i, vb2_plane_size(vb, i),
1129 q_data->sizeimage[i]);
1130 }
1131 }
1132
1133 return 0;
1134 }
1135
1136 static void vb2ops_vdec_buf_queue(struct vb2_buffer *vb)
1137 {
1138 struct vb2_v4l2_buffer *src_buf;
1139 struct mtk_vcodec_mem src_mem;
1140 bool res_chg = false;
1141 int ret = 0;
1142 unsigned int dpbsize = 1, i = 0;
1143 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1144 struct vb2_v4l2_buffer *vb2_v4l2 = NULL;
1145 struct mtk_video_dec_buf *buf = NULL;
1146 struct mtk_q_data *dst_q_data;
1147
1148 mtk_v4l2_debug(3, "[%d] (%d) id=%d, vb=%p",
1149 ctx->id, vb->vb2_queue->type,
1150 vb->index, vb);
1151 /*
1152 * check if this buffer is ready to be used after decode
1153 */
1154 if (vb->vb2_queue->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1155 vb2_v4l2 = to_vb2_v4l2_buffer(vb);
1156 buf = container_of(vb2_v4l2, struct mtk_video_dec_buf,
1157 m2m_buf.vb);
1158 mutex_lock(&ctx->lock);
1159 if (buf->used == false) {
1160 v4l2_m2m_buf_queue(ctx->m2m_ctx, vb2_v4l2);
1161 buf->queued_in_vb2 = true;
1162 buf->queued_in_v4l2 = true;
1163 } else {
1164 buf->queued_in_vb2 = false;
1165 buf->queued_in_v4l2 = true;
1166 }
1167 mutex_unlock(&ctx->lock);
1168 return;
1169 }
1170
1171 v4l2_m2m_buf_queue(ctx->m2m_ctx, to_vb2_v4l2_buffer(vb));
1172
1173 if (ctx->state != MTK_STATE_INIT) {
1174 mtk_v4l2_debug(3, "[%d] already init driver %d",
1175 ctx->id, ctx->state);
1176 return;
1177 }
1178
1179 src_buf = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
1180 if (!src_buf) {
1181 mtk_v4l2_err("No src buffer");
1182 return;
1183 }
1184 buf = container_of(src_buf, struct mtk_video_dec_buf, m2m_buf.vb);
1185 if (buf->lastframe) {
1186 /* This shouldn't happen. Just in case. */
1187 mtk_v4l2_err("Invalid flush buffer.");
1188 v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
1189 return;
1190 }
1191
1192 src_mem.va = vb2_plane_vaddr(&src_buf->vb2_buf, 0);
1193 src_mem.dma_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
1194 src_mem.size = (size_t)src_buf->vb2_buf.planes[0].bytesused;
1195 mtk_v4l2_debug(2,
1196 "[%d] buf id=%d va=%p dma=%pad size=%zx",
1197 ctx->id, src_buf->vb2_buf.index,
1198 src_mem.va, &src_mem.dma_addr,
1199 src_mem.size);
1200
1201 ret = vdec_if_decode(ctx, &src_mem, NULL, &res_chg);
1202 if (ret || !res_chg) {
1203 /*
1204 * fb == NULL means to parse SPS/PPS header or
1205 * resolution info in src_mem. Decode can fail
1206 * if there is no SPS header or picture info
1207 * in bs
1208 */
1209
1210 src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
1211 if (ret == -EIO) {
1212 mtk_v4l2_err("[%d] Unrecoverable error in vdec_if_decode.",
1213 ctx->id);
1214 ctx->state = MTK_STATE_ABORT;
1215 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
1216 } else {
1217 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
1218 }
1219 mtk_v4l2_debug(ret ? 0 : 1,
1220 "[%d] vdec_if_decode() src_buf=%d, size=%zu, fail=%d, res_chg=%d",
1221 ctx->id, src_buf->vb2_buf.index,
1222 src_mem.size, ret, res_chg);
1223 return;
1224 }
1225
1226 if (vdec_if_get_param(ctx, GET_PARAM_PIC_INFO, &ctx->picinfo)) {
1227 mtk_v4l2_err("[%d]Error!! Cannot get param : GET_PARAM_PICTURE_INFO ERR",
1228 ctx->id);
1229 return;
1230 }
1231
1232 ctx->last_decoded_picinfo = ctx->picinfo;
1233 dst_q_data = &ctx->q_data[MTK_Q_DATA_DST];
1234 for (i = 0; i < dst_q_data->fmt->num_planes; i++) {
1235 dst_q_data->sizeimage[i] = ctx->picinfo.fb_sz[i];
1236 dst_q_data->bytesperline[i] = ctx->picinfo.buf_w;
1237 }
1238
1239 mtk_v4l2_debug(2, "[%d] vdec_if_init() OK wxh=%dx%d pic wxh=%dx%d sz[0]=0x%x sz[1]=0x%x",
1240 ctx->id,
1241 ctx->picinfo.buf_w, ctx->picinfo.buf_h,
1242 ctx->picinfo.pic_w, ctx->picinfo.pic_h,
1243 dst_q_data->sizeimage[0],
1244 dst_q_data->sizeimage[1]);
1245
1246 ret = vdec_if_get_param(ctx, GET_PARAM_DPB_SIZE, &dpbsize);
1247 if (dpbsize == 0)
1248 mtk_v4l2_err("[%d] GET_PARAM_DPB_SIZE fail=%d", ctx->id, ret);
1249
1250 ctx->dpb_size = dpbsize;
1251 ctx->state = MTK_STATE_HEADER;
1252 mtk_v4l2_debug(1, "[%d] dpbsize=%d", ctx->id, ctx->dpb_size);
1253
1254 mtk_vdec_queue_res_chg_event(ctx);
1255 }
1256
1257 static void vb2ops_vdec_buf_finish(struct vb2_buffer *vb)
1258 {
1259 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1260 struct vb2_v4l2_buffer *vb2_v4l2;
1261 struct mtk_video_dec_buf *buf;
1262 bool buf_error;
1263
1264 vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf);
1265 buf = container_of(vb2_v4l2, struct mtk_video_dec_buf, m2m_buf.vb);
1266 mutex_lock(&ctx->lock);
1267 if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1268 buf->queued_in_v4l2 = false;
1269 buf->queued_in_vb2 = false;
1270 }
1271 buf_error = buf->error;
1272 mutex_unlock(&ctx->lock);
1273
1274 if (buf_error) {
1275 mtk_v4l2_err("Unrecoverable error on buffer.");
1276 ctx->state = MTK_STATE_ABORT;
1277 }
1278 }
1279
1280 static int vb2ops_vdec_buf_init(struct vb2_buffer *vb)
1281 {
1282 struct vb2_v4l2_buffer *vb2_v4l2 = container_of(vb,
1283 struct vb2_v4l2_buffer, vb2_buf);
1284 struct mtk_video_dec_buf *buf = container_of(vb2_v4l2,
1285 struct mtk_video_dec_buf, m2m_buf.vb);
1286
1287 if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1288 buf->used = false;
1289 buf->queued_in_v4l2 = false;
1290 } else {
1291 buf->lastframe = false;
1292 }
1293
1294 return 0;
1295 }
1296
1297 static int vb2ops_vdec_start_streaming(struct vb2_queue *q, unsigned int count)
1298 {
1299 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(q);
1300
1301 if (ctx->state == MTK_STATE_FLUSH)
1302 ctx->state = MTK_STATE_HEADER;
1303
1304 return 0;
1305 }
1306
1307 static void vb2ops_vdec_stop_streaming(struct vb2_queue *q)
1308 {
1309 struct vb2_v4l2_buffer *src_buf = NULL, *dst_buf = NULL;
1310 struct mtk_vcodec_ctx *ctx = vb2_get_drv_priv(q);
1311
1312 mtk_v4l2_debug(3, "[%d] (%d) state=(%x) ctx->decoded_frame_cnt=%d",
1313 ctx->id, q->type, ctx->state, ctx->decoded_frame_cnt);
1314
1315 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1316 while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) {
1317 struct mtk_video_dec_buf *buf_info = container_of(
1318 src_buf, struct mtk_video_dec_buf, m2m_buf.vb);
1319 if (!buf_info->lastframe)
1320 v4l2_m2m_buf_done(src_buf,
1321 VB2_BUF_STATE_ERROR);
1322 }
1323 return;
1324 }
1325
1326 if (ctx->state >= MTK_STATE_HEADER) {
1327
1328 /* Until STREAMOFF is called on the CAPTURE queue
1329 * (acknowledging the event), the driver operates
1330 * as if the resolution hasn't changed yet, i.e.
1331 * VIDIOC_G_FMT< etc. return previous resolution.
1332 * So we update picinfo here
1333 */
1334 ctx->picinfo = ctx->last_decoded_picinfo;
1335
1336 mtk_v4l2_debug(2,
1337 "[%d]-> new(%d,%d), old(%d,%d), real(%d,%d)",
1338 ctx->id, ctx->last_decoded_picinfo.pic_w,
1339 ctx->last_decoded_picinfo.pic_h,
1340 ctx->picinfo.pic_w, ctx->picinfo.pic_h,
1341 ctx->last_decoded_picinfo.buf_w,
1342 ctx->last_decoded_picinfo.buf_h);
1343
1344 mtk_vdec_flush_decoder(ctx);
1345 }
1346 ctx->state = MTK_STATE_FLUSH;
1347
1348 while ((dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx))) {
1349 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);
1350 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2)
1351 vb2_set_plane_payload(&dst_buf->vb2_buf, 1, 0);
1352 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);
1353 }
1354
1355 }
1356
1357 static void m2mops_vdec_device_run(void *priv)
1358 {
1359 struct mtk_vcodec_ctx *ctx = priv;
1360 struct mtk_vcodec_dev *dev = ctx->dev;
1361
1362 queue_work(dev->decode_workqueue, &ctx->decode_work);
1363 }
1364
1365 static int m2mops_vdec_job_ready(void *m2m_priv)
1366 {
1367 struct mtk_vcodec_ctx *ctx = m2m_priv;
1368
1369 mtk_v4l2_debug(3, "[%d]", ctx->id);
1370
1371 if (ctx->state == MTK_STATE_ABORT)
1372 return 0;
1373
1374 if ((ctx->last_decoded_picinfo.pic_w != ctx->picinfo.pic_w) ||
1375 (ctx->last_decoded_picinfo.pic_h != ctx->picinfo.pic_h))
1376 return 0;
1377
1378 if (ctx->state != MTK_STATE_HEADER)
1379 return 0;
1380
1381 return 1;
1382 }
1383
1384 static void m2mops_vdec_job_abort(void *priv)
1385 {
1386 struct mtk_vcodec_ctx *ctx = priv;
1387
1388 ctx->state = MTK_STATE_ABORT;
1389 }
1390
1391 static int mtk_vdec_g_v_ctrl(struct v4l2_ctrl *ctrl)
1392 {
1393 struct mtk_vcodec_ctx *ctx = ctrl_to_ctx(ctrl);
1394 int ret = 0;
1395
1396 switch (ctrl->id) {
1397 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1398 if (ctx->state >= MTK_STATE_HEADER) {
1399 ctrl->val = ctx->dpb_size;
1400 } else {
1401 mtk_v4l2_debug(0, "Seqinfo not ready");
1402 ctrl->val = 0;
1403 }
1404 break;
1405 default:
1406 ret = -EINVAL;
1407 }
1408 return ret;
1409 }
1410
1411 static const struct v4l2_ctrl_ops mtk_vcodec_dec_ctrl_ops = {
1412 .g_volatile_ctrl = mtk_vdec_g_v_ctrl,
1413 };
1414
1415 int mtk_vcodec_dec_ctrls_setup(struct mtk_vcodec_ctx *ctx)
1416 {
1417 struct v4l2_ctrl *ctrl;
1418
1419 v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 1);
1420
1421 ctrl = v4l2_ctrl_new_std(&ctx->ctrl_hdl,
1422 &mtk_vcodec_dec_ctrl_ops,
1423 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE,
1424 0, 32, 1, 1);
1425 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1426 v4l2_ctrl_new_std_menu(&ctx->ctrl_hdl,
1427 &mtk_vcodec_dec_ctrl_ops,
1428 V4L2_CID_MPEG_VIDEO_VP9_PROFILE,
1429 V4L2_MPEG_VIDEO_VP9_PROFILE_0,
1430 0, V4L2_MPEG_VIDEO_VP9_PROFILE_0);
1431
1432 if (ctx->ctrl_hdl.error) {
1433 mtk_v4l2_err("Adding control failed %d",
1434 ctx->ctrl_hdl.error);
1435 return ctx->ctrl_hdl.error;
1436 }
1437
1438 v4l2_ctrl_handler_setup(&ctx->ctrl_hdl);
1439 return 0;
1440 }
1441
1442 const struct v4l2_m2m_ops mtk_vdec_m2m_ops = {
1443 .device_run = m2mops_vdec_device_run,
1444 .job_ready = m2mops_vdec_job_ready,
1445 .job_abort = m2mops_vdec_job_abort,
1446 };
1447
1448 static const struct vb2_ops mtk_vdec_vb2_ops = {
1449 .queue_setup = vb2ops_vdec_queue_setup,
1450 .buf_prepare = vb2ops_vdec_buf_prepare,
1451 .buf_queue = vb2ops_vdec_buf_queue,
1452 .wait_prepare = vb2_ops_wait_prepare,
1453 .wait_finish = vb2_ops_wait_finish,
1454 .buf_init = vb2ops_vdec_buf_init,
1455 .buf_finish = vb2ops_vdec_buf_finish,
1456 .start_streaming = vb2ops_vdec_start_streaming,
1457 .stop_streaming = vb2ops_vdec_stop_streaming,
1458 };
1459
1460 const struct v4l2_ioctl_ops mtk_vdec_ioctl_ops = {
1461 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
1462 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
1463 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
1464 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
1465 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
1466
1467 .vidioc_qbuf = vidioc_vdec_qbuf,
1468 .vidioc_dqbuf = vidioc_vdec_dqbuf,
1469
1470 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane,
1471 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
1472
1473 .vidioc_s_fmt_vid_cap_mplane = vidioc_vdec_s_fmt,
1474 .vidioc_s_fmt_vid_out_mplane = vidioc_vdec_s_fmt,
1475 .vidioc_g_fmt_vid_cap_mplane = vidioc_vdec_g_fmt,
1476 .vidioc_g_fmt_vid_out_mplane = vidioc_vdec_g_fmt,
1477
1478 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
1479
1480 .vidioc_enum_fmt_vid_cap = vidioc_vdec_enum_fmt_vid_cap,
1481 .vidioc_enum_fmt_vid_out = vidioc_vdec_enum_fmt_vid_out,
1482 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1483
1484 .vidioc_querycap = vidioc_vdec_querycap,
1485 .vidioc_subscribe_event = vidioc_vdec_subscribe_evt,
1486 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1487 .vidioc_g_selection = vidioc_vdec_g_selection,
1488 .vidioc_s_selection = vidioc_vdec_s_selection,
1489
1490 .vidioc_decoder_cmd = vidioc_decoder_cmd,
1491 .vidioc_try_decoder_cmd = vidioc_try_decoder_cmd,
1492 };
1493
1494 int mtk_vcodec_dec_queue_init(void *priv, struct vb2_queue *src_vq,
1495 struct vb2_queue *dst_vq)
1496 {
1497 struct mtk_vcodec_ctx *ctx = priv;
1498 int ret = 0;
1499
1500 mtk_v4l2_debug(3, "[%d]", ctx->id);
1501
1502 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1503 src_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1504 src_vq->drv_priv = ctx;
1505 src_vq->buf_struct_size = sizeof(struct mtk_video_dec_buf);
1506 src_vq->ops = &mtk_vdec_vb2_ops;
1507 src_vq->mem_ops = &vb2_dma_contig_memops;
1508 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1509 src_vq->lock = &ctx->dev->dev_mutex;
1510 src_vq->dev = &ctx->dev->plat_dev->dev;
1511
1512 ret = vb2_queue_init(src_vq);
1513 if (ret) {
1514 mtk_v4l2_err("Failed to initialize videobuf2 queue(output)");
1515 return ret;
1516 }
1517 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1518 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1519 dst_vq->drv_priv = ctx;
1520 dst_vq->buf_struct_size = sizeof(struct mtk_video_dec_buf);
1521 dst_vq->ops = &mtk_vdec_vb2_ops;
1522 dst_vq->mem_ops = &vb2_dma_contig_memops;
1523 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1524 dst_vq->lock = &ctx->dev->dev_mutex;
1525 dst_vq->dev = &ctx->dev->plat_dev->dev;
1526
1527 ret = vb2_queue_init(dst_vq);
1528 if (ret) {
1529 vb2_queue_release(src_vq);
1530 mtk_v4l2_err("Failed to initialize videobuf2 queue(capture)");
1531 }
1532
1533 return ret;
1534 }
Linux with added FPC-III support