1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2020-2021 NXP
4 */
5
6 #include <linux/init.h>
7 #include <linux/interconnect.h>
8 #include <linux/ioctl.h>
9 #include <linux/list.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/vmalloc.h>
13 #include <linux/videodev2.h>
14 #include <media/v4l2-device.h>
15 #include <media/v4l2-event.h>
16 #include <media/v4l2-mem2mem.h>
17 #include <media/v4l2-ioctl.h>
18 #include <media/videobuf2-v4l2.h>
19 #include <media/videobuf2-dma-contig.h>
20 #include <media/videobuf2-vmalloc.h>
21 #include "vpu.h"
22 #include "vpu_defs.h"
23 #include "vpu_core.h"
24 #include "vpu_helpers.h"
25 #include "vpu_v4l2.h"
26 #include "vpu_cmds.h"
27 #include "vpu_rpc.h"
28
29 #define VDEC_MIN_BUFFER_CAP 8
30 #define VDEC_MIN_BUFFER_OUT 8
31
32 struct vdec_fs_info {
33 char name[8];
34 u32 type;
35 u32 max_count;
36 u32 req_count;
37 u32 count;
38 u32 index;
39 u32 size;
40 struct vpu_buffer buffer[32];
41 u32 tag;
42 };
43
44 struct vdec_t {
45 u32 seq_hdr_found;
46 struct vpu_buffer udata;
47 struct vpu_decode_params params;
48 struct vpu_dec_codec_info codec_info;
49 enum vpu_codec_state state;
50
51 struct vpu_vb2_buffer *slots[VB2_MAX_FRAME];
52 u32 req_frame_count;
53 struct vdec_fs_info mbi;
54 struct vdec_fs_info dcp;
55 u32 seq_tag;
56
57 bool reset_codec;
58 bool fixed_fmt;
59 u32 decoded_frame_count;
60 u32 display_frame_count;
61 u32 sequence;
62 u32 eos_received;
63 bool is_source_changed;
64 u32 source_change;
65 u32 drain;
66 bool aborting;
67 };
68
69 static const struct vpu_format vdec_formats[] = {
70 {
71 .pixfmt = V4L2_PIX_FMT_NV12M_8L128,
72 .mem_planes = 2,
73 .comp_planes = 2,
74 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
75 .sibling = V4L2_PIX_FMT_NV12_8L128,
76 },
77 {
78 .pixfmt = V4L2_PIX_FMT_NV12_8L128,
79 .mem_planes = 1,
80 .comp_planes = 2,
81 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
82 .sibling = V4L2_PIX_FMT_NV12M_8L128,
83 },
84 {
85 .pixfmt = V4L2_PIX_FMT_NV12M_10BE_8L128,
86 .mem_planes = 2,
87 .comp_planes = 2,
88 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
89 .sibling = V4L2_PIX_FMT_NV12_10BE_8L128,
90 },
91 {
92 .pixfmt = V4L2_PIX_FMT_NV12_10BE_8L128,
93 .mem_planes = 1,
94 .comp_planes = 2,
95 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
96 .sibling = V4L2_PIX_FMT_NV12M_10BE_8L128
97 },
98 {
99 .pixfmt = V4L2_PIX_FMT_H264,
100 .mem_planes = 1,
101 .comp_planes = 1,
102 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
103 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
104 },
105 {
106 .pixfmt = V4L2_PIX_FMT_H264_MVC,
107 .mem_planes = 1,
108 .comp_planes = 1,
109 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
110 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
111 },
112 {
113 .pixfmt = V4L2_PIX_FMT_HEVC,
114 .mem_planes = 1,
115 .comp_planes = 1,
116 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
117 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
118 },
119 {
120 .pixfmt = V4L2_PIX_FMT_VC1_ANNEX_G,
121 .mem_planes = 1,
122 .comp_planes = 1,
123 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
124 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
125 },
126 {
127 .pixfmt = V4L2_PIX_FMT_VC1_ANNEX_L,
128 .mem_planes = 1,
129 .comp_planes = 1,
130 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
131 .flags = V4L2_FMT_FLAG_COMPRESSED
132 },
133 {
134 .pixfmt = V4L2_PIX_FMT_MPEG2,
135 .mem_planes = 1,
136 .comp_planes = 1,
137 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
138 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
139 },
140 {
141 .pixfmt = V4L2_PIX_FMT_MPEG4,
142 .mem_planes = 1,
143 .comp_planes = 1,
144 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
145 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
146 },
147 {
148 .pixfmt = V4L2_PIX_FMT_XVID,
149 .mem_planes = 1,
150 .comp_planes = 1,
151 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
152 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
153 },
154 {
155 .pixfmt = V4L2_PIX_FMT_VP8,
156 .mem_planes = 1,
157 .comp_planes = 1,
158 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
159 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
160 },
161 {
162 .pixfmt = V4L2_PIX_FMT_H263,
163 .mem_planes = 1,
164 .comp_planes = 1,
165 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
166 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
167 },
168 {
169 .pixfmt = V4L2_PIX_FMT_SPK,
170 .mem_planes = 1,
171 .comp_planes = 1,
172 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
173 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
174 },
175 {
176 .pixfmt = V4L2_PIX_FMT_RV30,
177 .mem_planes = 1,
178 .comp_planes = 1,
179 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
180 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
181 },
182 {
183 .pixfmt = V4L2_PIX_FMT_RV40,
184 .mem_planes = 1,
185 .comp_planes = 1,
186 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
187 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
188 },
189 {0, 0, 0, 0},
190 };
191
vdec_op_s_ctrl(struct v4l2_ctrl * ctrl)192 static int vdec_op_s_ctrl(struct v4l2_ctrl *ctrl)
193 {
194 struct vpu_inst *inst = ctrl_to_inst(ctrl);
195 struct vdec_t *vdec = inst->priv;
196 int ret = 0;
197
198 vpu_inst_lock(inst);
199 switch (ctrl->id) {
200 case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE:
201 vdec->params.display_delay_enable = ctrl->val;
202 break;
203 case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY:
204 vdec->params.display_delay = ctrl->val;
205 break;
206 default:
207 ret = -EINVAL;
208 break;
209 }
210 vpu_inst_unlock(inst);
211
212 return ret;
213 }
214
215 static const struct v4l2_ctrl_ops vdec_ctrl_ops = {
216 .s_ctrl = vdec_op_s_ctrl,
217 .g_volatile_ctrl = vpu_helper_g_volatile_ctrl,
218 };
219
vdec_ctrl_init(struct vpu_inst * inst)220 static int vdec_ctrl_init(struct vpu_inst *inst)
221 {
222 struct v4l2_ctrl *ctrl;
223 int ret;
224
225 ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 20);
226 if (ret)
227 return ret;
228
229 v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
230 V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY,
231 0, 0, 1, 0);
232
233 v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
234 V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE,
235 0, 1, 1, 0);
236
237 ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
238 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 32, 1, 2);
239 if (ctrl)
240 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
241
242 ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
243 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 1, 32, 1, 2);
244 if (ctrl)
245 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
246
247 if (inst->ctrl_handler.error) {
248 ret = inst->ctrl_handler.error;
249 v4l2_ctrl_handler_free(&inst->ctrl_handler);
250 return ret;
251 }
252
253 ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
254 if (ret) {
255 dev_err(inst->dev, "[%d] setup ctrls fail, ret = %d\n", inst->id, ret);
256 v4l2_ctrl_handler_free(&inst->ctrl_handler);
257 return ret;
258 }
259
260 return 0;
261 }
262
vdec_handle_resolution_change(struct vpu_inst * inst)263 static void vdec_handle_resolution_change(struct vpu_inst *inst)
264 {
265 struct vdec_t *vdec = inst->priv;
266 struct vb2_queue *q;
267
268 if (!inst->fh.m2m_ctx)
269 return;
270
271 if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
272 return;
273 if (!vdec->source_change)
274 return;
275
276 q = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
277 if (!list_empty(&q->done_list))
278 return;
279
280 vdec->source_change--;
281 vpu_notify_source_change(inst);
282 vpu_set_last_buffer_dequeued(inst, false);
283 }
284
vdec_update_state(struct vpu_inst * inst,enum vpu_codec_state state,u32 force)285 static int vdec_update_state(struct vpu_inst *inst, enum vpu_codec_state state, u32 force)
286 {
287 struct vdec_t *vdec = inst->priv;
288 enum vpu_codec_state pre_state = inst->state;
289
290 if (state == VPU_CODEC_STATE_SEEK) {
291 if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
292 vdec->state = inst->state;
293 else
294 vdec->state = VPU_CODEC_STATE_ACTIVE;
295 }
296 if (inst->state != VPU_CODEC_STATE_SEEK || force)
297 inst->state = state;
298 else if (state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
299 vdec->state = VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE;
300
301 if (inst->state != pre_state)
302 vpu_trace(inst->dev, "[%d] %s -> %s\n", inst->id,
303 vpu_codec_state_name(pre_state), vpu_codec_state_name(inst->state));
304
305 if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
306 vdec_handle_resolution_change(inst);
307
308 return 0;
309 }
310
vdec_set_last_buffer_dequeued(struct vpu_inst * inst)311 static void vdec_set_last_buffer_dequeued(struct vpu_inst *inst)
312 {
313 struct vdec_t *vdec = inst->priv;
314
315 if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
316 return;
317
318 if (vdec->eos_received) {
319 if (!vpu_set_last_buffer_dequeued(inst, true)) {
320 vdec->eos_received--;
321 vdec_update_state(inst, VPU_CODEC_STATE_DRAIN, 0);
322 }
323 }
324 }
325
vdec_querycap(struct file * file,void * fh,struct v4l2_capability * cap)326 static int vdec_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
327 {
328 strscpy(cap->driver, "amphion-vpu", sizeof(cap->driver));
329 strscpy(cap->card, "amphion vpu decoder", sizeof(cap->card));
330 strscpy(cap->bus_info, "platform: amphion-vpu", sizeof(cap->bus_info));
331
332 return 0;
333 }
334
vdec_enum_fmt(struct file * file,void * fh,struct v4l2_fmtdesc * f)335 static int vdec_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
336 {
337 struct vpu_inst *inst = to_inst(file);
338 struct vdec_t *vdec = inst->priv;
339 const struct vpu_format *fmt;
340 int ret = -EINVAL;
341
342 vpu_inst_lock(inst);
343 if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
344 fmt = vpu_get_format(inst, f->type);
345 if (f->index == 1)
346 fmt = vpu_helper_find_sibling(inst, f->type, fmt->pixfmt);
347 if (f->index > 1)
348 fmt = NULL;
349 } else {
350 fmt = vpu_helper_enum_format(inst, f->type, f->index);
351 }
352 if (!fmt)
353 goto exit;
354
355 memset(f->reserved, 0, sizeof(f->reserved));
356 f->pixelformat = fmt->pixfmt;
357 f->flags = fmt->flags;
358 ret = 0;
359 exit:
360 vpu_inst_unlock(inst);
361 return ret;
362 }
363
vdec_g_fmt(struct file * file,void * fh,struct v4l2_format * f)364 static int vdec_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
365 {
366 struct vpu_inst *inst = to_inst(file);
367 struct vdec_t *vdec = inst->priv;
368 struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
369 struct vpu_format *cur_fmt;
370 int i;
371
372 vpu_inst_lock(inst);
373 cur_fmt = vpu_get_format(inst, f->type);
374
375 pixmp->pixelformat = cur_fmt->pixfmt;
376 pixmp->num_planes = cur_fmt->mem_planes;
377 pixmp->width = cur_fmt->width;
378 pixmp->height = cur_fmt->height;
379 pixmp->field = cur_fmt->field;
380 pixmp->flags = cur_fmt->flags;
381 for (i = 0; i < pixmp->num_planes; i++) {
382 pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
383 pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
384 }
385
386 f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
387 f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
388 f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
389 f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
390 vpu_inst_unlock(inst);
391
392 return 0;
393 }
394
vdec_try_fmt(struct file * file,void * fh,struct v4l2_format * f)395 static int vdec_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
396 {
397 struct vpu_inst *inst = to_inst(file);
398 struct vdec_t *vdec = inst->priv;
399 struct vpu_format fmt;
400
401 vpu_inst_lock(inst);
402 if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
403 struct vpu_format *cap_fmt = vpu_get_format(inst, f->type);
404
405 if (!vpu_helper_match_format(inst, cap_fmt->type, cap_fmt->pixfmt,
406 f->fmt.pix_mp.pixelformat))
407 f->fmt.pix_mp.pixelformat = cap_fmt->pixfmt;
408 }
409
410 vpu_try_fmt_common(inst, f, &fmt);
411
412 if (vdec->fixed_fmt) {
413 f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
414 f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
415 f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
416 f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
417 } else {
418 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT;
419 f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;
420 f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
421 f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;
422 }
423 vpu_inst_unlock(inst);
424
425 return 0;
426 }
427
vdec_s_fmt_common(struct vpu_inst * inst,struct v4l2_format * f)428 static int vdec_s_fmt_common(struct vpu_inst *inst, struct v4l2_format *f)
429 {
430 struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
431 struct vpu_format fmt;
432 struct vpu_format *cur_fmt;
433 struct vb2_queue *q;
434 struct vdec_t *vdec = inst->priv;
435 int i;
436
437 if (!inst->fh.m2m_ctx)
438 return -EINVAL;
439
440 q = v4l2_m2m_get_vq(inst->fh.m2m_ctx, f->type);
441 if (!q)
442 return -EINVAL;
443 if (vb2_is_busy(q))
444 return -EBUSY;
445
446 if (vpu_try_fmt_common(inst, f, &fmt))
447 return -EINVAL;
448
449 cur_fmt = vpu_get_format(inst, f->type);
450 if (V4L2_TYPE_IS_OUTPUT(f->type) && inst->state != VPU_CODEC_STATE_DEINIT) {
451 if (cur_fmt->pixfmt != fmt.pixfmt) {
452 vdec->reset_codec = true;
453 vdec->fixed_fmt = false;
454 }
455 }
456 if (V4L2_TYPE_IS_OUTPUT(f->type) || !vdec->fixed_fmt) {
457 memcpy(cur_fmt, &fmt, sizeof(*cur_fmt));
458 } else {
459 if (vpu_helper_match_format(inst, f->type, cur_fmt->pixfmt, pixmp->pixelformat)) {
460 cur_fmt->pixfmt = fmt.pixfmt;
461 cur_fmt->mem_planes = fmt.mem_planes;
462 }
463 pixmp->pixelformat = cur_fmt->pixfmt;
464 pixmp->num_planes = cur_fmt->mem_planes;
465 pixmp->width = cur_fmt->width;
466 pixmp->height = cur_fmt->height;
467 for (i = 0; i < pixmp->num_planes; i++) {
468 pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
469 pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
470 }
471 pixmp->field = cur_fmt->field;
472 }
473
474 if (!vdec->fixed_fmt) {
475 if (V4L2_TYPE_IS_OUTPUT(f->type)) {
476 vdec->params.codec_format = cur_fmt->pixfmt;
477 vdec->codec_info.color_primaries = f->fmt.pix_mp.colorspace;
478 vdec->codec_info.transfer_chars = f->fmt.pix_mp.xfer_func;
479 vdec->codec_info.matrix_coeffs = f->fmt.pix_mp.ycbcr_enc;
480 vdec->codec_info.full_range = f->fmt.pix_mp.quantization;
481 } else {
482 vdec->params.output_format = cur_fmt->pixfmt;
483 inst->crop.left = 0;
484 inst->crop.top = 0;
485 inst->crop.width = cur_fmt->width;
486 inst->crop.height = cur_fmt->height;
487 }
488 }
489
490 vpu_trace(inst->dev, "[%d] %c%c%c%c %dx%d\n", inst->id,
491 f->fmt.pix_mp.pixelformat,
492 f->fmt.pix_mp.pixelformat >> 8,
493 f->fmt.pix_mp.pixelformat >> 16,
494 f->fmt.pix_mp.pixelformat >> 24,
495 f->fmt.pix_mp.width,
496 f->fmt.pix_mp.height);
497
498 return 0;
499 }
500
vdec_s_fmt(struct file * file,void * fh,struct v4l2_format * f)501 static int vdec_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
502 {
503 struct vpu_inst *inst = to_inst(file);
504 struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
505 struct vdec_t *vdec = inst->priv;
506 int ret = 0;
507
508 vpu_inst_lock(inst);
509 ret = vdec_s_fmt_common(inst, f);
510 if (ret)
511 goto exit;
512
513 if (V4L2_TYPE_IS_OUTPUT(f->type) && !vdec->fixed_fmt) {
514 struct v4l2_format fc;
515
516 memset(&fc, 0, sizeof(fc));
517 fc.type = inst->cap_format.type;
518 fc.fmt.pix_mp.pixelformat = inst->cap_format.pixfmt;
519 fc.fmt.pix_mp.width = pixmp->width;
520 fc.fmt.pix_mp.height = pixmp->height;
521 vdec_s_fmt_common(inst, &fc);
522 }
523
524 f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
525 f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
526 f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
527 f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
528
529 exit:
530 vpu_inst_unlock(inst);
531 return ret;
532 }
533
vdec_g_selection(struct file * file,void * fh,struct v4l2_selection * s)534 static int vdec_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
535 {
536 struct vpu_inst *inst = to_inst(file);
537
538 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
539 return -EINVAL;
540
541 switch (s->target) {
542 case V4L2_SEL_TGT_COMPOSE:
543 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
544 case V4L2_SEL_TGT_COMPOSE_PADDED:
545 s->r = inst->crop;
546 break;
547 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
548 s->r.left = 0;
549 s->r.top = 0;
550 s->r.width = inst->cap_format.width;
551 s->r.height = inst->cap_format.height;
552 break;
553 default:
554 return -EINVAL;
555 }
556
557 return 0;
558 }
559
vdec_drain(struct vpu_inst * inst)560 static int vdec_drain(struct vpu_inst *inst)
561 {
562 struct vdec_t *vdec = inst->priv;
563
564 if (!inst->fh.m2m_ctx)
565 return 0;
566
567 if (!vdec->drain)
568 return 0;
569
570 if (!vpu_is_source_empty(inst))
571 return 0;
572
573 if (!vdec->params.frame_count) {
574 vpu_set_last_buffer_dequeued(inst, true);
575 return 0;
576 }
577
578 vpu_iface_add_scode(inst, SCODE_PADDING_EOS);
579 vdec->params.end_flag = 1;
580 vpu_iface_set_decode_params(inst, &vdec->params, 1);
581 vdec->drain = 0;
582 vpu_trace(inst->dev, "[%d] frame_count = %d\n", inst->id, vdec->params.frame_count);
583
584 return 0;
585 }
586
vdec_cmd_start(struct vpu_inst * inst)587 static int vdec_cmd_start(struct vpu_inst *inst)
588 {
589 struct vdec_t *vdec = inst->priv;
590
591 switch (inst->state) {
592 case VPU_CODEC_STATE_STARTED:
593 case VPU_CODEC_STATE_DRAIN:
594 case VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE:
595 vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
596 break;
597 default:
598 break;
599 }
600 vpu_process_capture_buffer(inst);
601 if (vdec->eos_received)
602 vdec_set_last_buffer_dequeued(inst);
603 return 0;
604 }
605
vdec_cmd_stop(struct vpu_inst * inst)606 static int vdec_cmd_stop(struct vpu_inst *inst)
607 {
608 struct vdec_t *vdec = inst->priv;
609
610 vpu_trace(inst->dev, "[%d]\n", inst->id);
611
612 if (inst->state == VPU_CODEC_STATE_DEINIT) {
613 vpu_set_last_buffer_dequeued(inst, true);
614 } else {
615 vdec->drain = 1;
616 vdec_drain(inst);
617 }
618
619 return 0;
620 }
621
vdec_decoder_cmd(struct file * file,void * fh,struct v4l2_decoder_cmd * cmd)622 static int vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd)
623 {
624 struct vpu_inst *inst = to_inst(file);
625 int ret;
626
627 ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd);
628 if (ret)
629 return ret;
630
631 vpu_inst_lock(inst);
632 switch (cmd->cmd) {
633 case V4L2_DEC_CMD_START:
634 vdec_cmd_start(inst);
635 break;
636 case V4L2_DEC_CMD_STOP:
637 vdec_cmd_stop(inst);
638 break;
639 default:
640 break;
641 }
642 vpu_inst_unlock(inst);
643
644 return 0;
645 }
646
vdec_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)647 static int vdec_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
648 {
649 switch (sub->type) {
650 case V4L2_EVENT_EOS:
651 return v4l2_event_subscribe(fh, sub, 0, NULL);
652 case V4L2_EVENT_SOURCE_CHANGE:
653 return v4l2_src_change_event_subscribe(fh, sub);
654 case V4L2_EVENT_CTRL:
655 return v4l2_ctrl_subscribe_event(fh, sub);
656 default:
657 return -EINVAL;
658 }
659
660 return 0;
661 }
662
663 static const struct v4l2_ioctl_ops vdec_ioctl_ops = {
664 .vidioc_querycap = vdec_querycap,
665 .vidioc_enum_fmt_vid_cap = vdec_enum_fmt,
666 .vidioc_enum_fmt_vid_out = vdec_enum_fmt,
667 .vidioc_g_fmt_vid_cap_mplane = vdec_g_fmt,
668 .vidioc_g_fmt_vid_out_mplane = vdec_g_fmt,
669 .vidioc_try_fmt_vid_cap_mplane = vdec_try_fmt,
670 .vidioc_try_fmt_vid_out_mplane = vdec_try_fmt,
671 .vidioc_s_fmt_vid_cap_mplane = vdec_s_fmt,
672 .vidioc_s_fmt_vid_out_mplane = vdec_s_fmt,
673 .vidioc_g_selection = vdec_g_selection,
674 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd,
675 .vidioc_decoder_cmd = vdec_decoder_cmd,
676 .vidioc_subscribe_event = vdec_subscribe_event,
677 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
678 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
679 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
680 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
681 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
682 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
683 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
684 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
685 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
686 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
687 };
688
vdec_check_ready(struct vpu_inst * inst,unsigned int type)689 static bool vdec_check_ready(struct vpu_inst *inst, unsigned int type)
690 {
691 struct vdec_t *vdec = inst->priv;
692
693 if (V4L2_TYPE_IS_OUTPUT(type))
694 return true;
695
696 if (vdec->req_frame_count)
697 return true;
698
699 return false;
700 }
701
vdec_get_src_buffer(struct vpu_inst * inst,u32 count)702 static struct vb2_v4l2_buffer *vdec_get_src_buffer(struct vpu_inst *inst, u32 count)
703 {
704 if (count > 1)
705 vpu_skip_frame(inst, count - 1);
706
707 return vpu_next_src_buf(inst);
708 }
709
vdec_frame_decoded(struct vpu_inst * inst,void * arg)710 static int vdec_frame_decoded(struct vpu_inst *inst, void *arg)
711 {
712 struct vdec_t *vdec = inst->priv;
713 struct vpu_dec_pic_info *info = arg;
714 struct vpu_vb2_buffer *vpu_buf;
715 struct vb2_v4l2_buffer *vbuf;
716 struct vb2_v4l2_buffer *src_buf;
717 int ret = 0;
718
719 if (!info || info->id >= ARRAY_SIZE(vdec->slots))
720 return -EINVAL;
721
722 vpu_inst_lock(inst);
723 vpu_buf = vdec->slots[info->id];
724 if (!vpu_buf) {
725 dev_err(inst->dev, "[%d] decoded invalid frame[%d]\n", inst->id, info->id);
726 ret = -EINVAL;
727 goto exit;
728 }
729 vbuf = &vpu_buf->m2m_buf.vb;
730 src_buf = vdec_get_src_buffer(inst, info->consumed_count);
731 if (src_buf) {
732 v4l2_m2m_buf_copy_metadata(src_buf, vbuf, true);
733 if (info->consumed_count) {
734 v4l2_m2m_src_buf_remove(inst->fh.m2m_ctx);
735 vpu_set_buffer_state(src_buf, VPU_BUF_STATE_IDLE);
736 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
737 } else {
738 vpu_set_buffer_state(src_buf, VPU_BUF_STATE_DECODED);
739 }
740 }
741 if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED)
742 dev_info(inst->dev, "[%d] buf[%d] has been decoded\n", inst->id, info->id);
743 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_DECODED);
744 vdec->decoded_frame_count++;
745 if (vdec->params.display_delay_enable) {
746 struct vpu_format *cur_fmt;
747
748 cur_fmt = vpu_get_format(inst, inst->cap_format.type);
749 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_READY);
750 for (int i = 0; i < vbuf->vb2_buf.num_planes; i++)
751 vb2_set_plane_payload(&vbuf->vb2_buf,
752 i, vpu_get_fmt_plane_size(cur_fmt, i));
753 vbuf->field = cur_fmt->field;
754 vbuf->sequence = vdec->sequence++;
755 dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
756
757 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
758 vdec->display_frame_count++;
759 }
760 exit:
761 vpu_inst_unlock(inst);
762
763 return ret;
764 }
765
vdec_find_buffer(struct vpu_inst * inst,u32 luma)766 static struct vpu_vb2_buffer *vdec_find_buffer(struct vpu_inst *inst, u32 luma)
767 {
768 struct vdec_t *vdec = inst->priv;
769 int i;
770
771 for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
772 if (!vdec->slots[i])
773 continue;
774 if (luma == vdec->slots[i]->luma)
775 return vdec->slots[i];
776 }
777
778 return NULL;
779 }
780
vdec_buf_done(struct vpu_inst * inst,struct vpu_frame_info * frame)781 static void vdec_buf_done(struct vpu_inst *inst, struct vpu_frame_info *frame)
782 {
783 struct vdec_t *vdec = inst->priv;
784 struct vpu_format *cur_fmt;
785 struct vpu_vb2_buffer *vpu_buf;
786 struct vb2_v4l2_buffer *vbuf;
787 int i;
788
789 if (!frame)
790 return;
791
792 vpu_inst_lock(inst);
793 if (!vdec->params.display_delay_enable)
794 vdec->sequence++;
795 vpu_buf = vdec_find_buffer(inst, frame->luma);
796 vpu_inst_unlock(inst);
797 if (!vpu_buf) {
798 dev_err(inst->dev, "[%d] can't find buffer, id = %d, addr = 0x%x\n",
799 inst->id, frame->id, frame->luma);
800 return;
801 }
802 if (frame->skipped) {
803 dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
804 return;
805 }
806
807 cur_fmt = vpu_get_format(inst, inst->cap_format.type);
808 vbuf = &vpu_buf->m2m_buf.vb;
809 if (vbuf->vb2_buf.index != frame->id)
810 dev_err(inst->dev, "[%d] buffer id(%d, %d) dismatch\n",
811 inst->id, vbuf->vb2_buf.index, frame->id);
812
813 if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_READY && vdec->params.display_delay_enable)
814 return;
815
816 if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_DECODED)
817 dev_err(inst->dev, "[%d] buffer(%d) ready without decoded\n", inst->id, frame->id);
818
819 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_READY);
820 for (i = 0; i < vbuf->vb2_buf.num_planes; i++)
821 vb2_set_plane_payload(&vbuf->vb2_buf, i, vpu_get_fmt_plane_size(cur_fmt, i));
822 vbuf->field = cur_fmt->field;
823 vbuf->sequence = vdec->sequence;
824 dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
825
826 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
827 vpu_inst_lock(inst);
828 vdec->display_frame_count++;
829 vpu_inst_unlock(inst);
830 dev_dbg(inst->dev, "[%d] decoded : %d, display : %d, sequence : %d\n",
831 inst->id, vdec->decoded_frame_count, vdec->display_frame_count, vdec->sequence);
832 }
833
vdec_stop_done(struct vpu_inst * inst)834 static void vdec_stop_done(struct vpu_inst *inst)
835 {
836 struct vdec_t *vdec = inst->priv;
837
838 vpu_inst_lock(inst);
839 vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 0);
840 vdec->seq_hdr_found = 0;
841 vdec->req_frame_count = 0;
842 vdec->reset_codec = false;
843 vdec->fixed_fmt = false;
844 vdec->params.end_flag = 0;
845 vdec->drain = 0;
846 vdec->params.frame_count = 0;
847 vdec->decoded_frame_count = 0;
848 vdec->display_frame_count = 0;
849 vdec->sequence = 0;
850 vdec->eos_received = 0;
851 vdec->is_source_changed = false;
852 vdec->source_change = 0;
853 inst->total_input_count = 0;
854 vpu_inst_unlock(inst);
855 }
856
vdec_check_source_change(struct vpu_inst * inst)857 static bool vdec_check_source_change(struct vpu_inst *inst)
858 {
859 struct vdec_t *vdec = inst->priv;
860 const struct vpu_format *sibling;
861
862 if (!inst->fh.m2m_ctx)
863 return false;
864
865 if (vdec->reset_codec)
866 return false;
867
868 sibling = vpu_helper_find_sibling(inst, inst->cap_format.type, inst->cap_format.pixfmt);
869 if (sibling && vdec->codec_info.pixfmt == sibling->pixfmt)
870 vdec->codec_info.pixfmt = inst->cap_format.pixfmt;
871
872 if (!vb2_is_streaming(v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx)))
873 return true;
874 if (inst->cap_format.pixfmt != vdec->codec_info.pixfmt)
875 return true;
876 if (inst->cap_format.width != vdec->codec_info.decoded_width)
877 return true;
878 if (inst->cap_format.height != vdec->codec_info.decoded_height)
879 return true;
880 if (vpu_get_num_buffers(inst, inst->cap_format.type) < inst->min_buffer_cap)
881 return true;
882 if (inst->crop.left != vdec->codec_info.offset_x)
883 return true;
884 if (inst->crop.top != vdec->codec_info.offset_y)
885 return true;
886 if (inst->crop.width != vdec->codec_info.width)
887 return true;
888 if (inst->crop.height != vdec->codec_info.height)
889 return true;
890
891 return false;
892 }
893
vdec_init_fmt(struct vpu_inst * inst)894 static void vdec_init_fmt(struct vpu_inst *inst)
895 {
896 struct vdec_t *vdec = inst->priv;
897 struct v4l2_format f;
898
899 memset(&f, 0, sizeof(f));
900 f.type = inst->cap_format.type;
901 f.fmt.pix_mp.pixelformat = vdec->codec_info.pixfmt;
902 f.fmt.pix_mp.width = vdec->codec_info.decoded_width;
903 f.fmt.pix_mp.height = vdec->codec_info.decoded_height;
904 if (vdec->codec_info.progressive)
905 f.fmt.pix_mp.field = V4L2_FIELD_NONE;
906 else
907 f.fmt.pix_mp.field = V4L2_FIELD_SEQ_TB;
908 vpu_try_fmt_common(inst, &f, &inst->cap_format);
909
910 inst->out_format.width = vdec->codec_info.width;
911 inst->out_format.height = vdec->codec_info.height;
912 }
913
vdec_init_crop(struct vpu_inst * inst)914 static void vdec_init_crop(struct vpu_inst *inst)
915 {
916 struct vdec_t *vdec = inst->priv;
917
918 inst->crop.left = vdec->codec_info.offset_x;
919 inst->crop.top = vdec->codec_info.offset_y;
920 inst->crop.width = vdec->codec_info.width;
921 inst->crop.height = vdec->codec_info.height;
922 }
923
vdec_init_mbi(struct vpu_inst * inst)924 static void vdec_init_mbi(struct vpu_inst *inst)
925 {
926 struct vdec_t *vdec = inst->priv;
927
928 vdec->mbi.size = vdec->codec_info.mbi_size;
929 vdec->mbi.max_count = ARRAY_SIZE(vdec->mbi.buffer);
930 scnprintf(vdec->mbi.name, sizeof(vdec->mbi.name), "mbi");
931 vdec->mbi.type = MEM_RES_MBI;
932 vdec->mbi.tag = vdec->seq_tag;
933 }
934
vdec_init_dcp(struct vpu_inst * inst)935 static void vdec_init_dcp(struct vpu_inst *inst)
936 {
937 struct vdec_t *vdec = inst->priv;
938
939 vdec->dcp.size = vdec->codec_info.dcp_size;
940 vdec->dcp.max_count = ARRAY_SIZE(vdec->dcp.buffer);
941 scnprintf(vdec->dcp.name, sizeof(vdec->dcp.name), "dcp");
942 vdec->dcp.type = MEM_RES_DCP;
943 vdec->dcp.tag = vdec->seq_tag;
944 }
945
vdec_request_one_fs(struct vdec_fs_info * fs)946 static void vdec_request_one_fs(struct vdec_fs_info *fs)
947 {
948 fs->req_count++;
949 if (fs->req_count > fs->max_count)
950 fs->req_count = fs->max_count;
951 }
952
vdec_alloc_fs_buffer(struct vpu_inst * inst,struct vdec_fs_info * fs)953 static int vdec_alloc_fs_buffer(struct vpu_inst *inst, struct vdec_fs_info *fs)
954 {
955 struct vpu_buffer *buffer;
956
957 if (!fs->size)
958 return -EINVAL;
959
960 if (fs->count >= fs->req_count)
961 return -EINVAL;
962
963 buffer = &fs->buffer[fs->count];
964 if (buffer->virt && buffer->length >= fs->size)
965 return 0;
966
967 vpu_free_dma(buffer);
968 buffer->length = fs->size;
969 return vpu_alloc_dma(inst->core, buffer);
970 }
971
vdec_alloc_fs(struct vpu_inst * inst,struct vdec_fs_info * fs)972 static void vdec_alloc_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
973 {
974 int ret;
975
976 while (fs->count < fs->req_count) {
977 ret = vdec_alloc_fs_buffer(inst, fs);
978 if (ret)
979 break;
980 fs->count++;
981 }
982 }
983
vdec_clear_fs(struct vdec_fs_info * fs)984 static void vdec_clear_fs(struct vdec_fs_info *fs)
985 {
986 u32 i;
987
988 if (!fs)
989 return;
990
991 for (i = 0; i < ARRAY_SIZE(fs->buffer); i++)
992 vpu_free_dma(&fs->buffer[i]);
993 memset(fs, 0, sizeof(*fs));
994 }
995
vdec_response_fs(struct vpu_inst * inst,struct vdec_fs_info * fs)996 static int vdec_response_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
997 {
998 struct vpu_fs_info info;
999 int ret;
1000
1001 if (fs->index >= fs->count)
1002 return 0;
1003
1004 memset(&info, 0, sizeof(info));
1005 info.id = fs->index;
1006 info.type = fs->type;
1007 info.tag = fs->tag;
1008 info.luma_addr = fs->buffer[fs->index].phys;
1009 info.luma_size = fs->buffer[fs->index].length;
1010 ret = vpu_session_alloc_fs(inst, &info);
1011 if (ret)
1012 return ret;
1013
1014 fs->index++;
1015 return 0;
1016 }
1017
vdec_response_frame_abnormal(struct vpu_inst * inst)1018 static int vdec_response_frame_abnormal(struct vpu_inst *inst)
1019 {
1020 struct vdec_t *vdec = inst->priv;
1021 struct vpu_fs_info info;
1022 int ret;
1023
1024 if (!vdec->req_frame_count)
1025 return 0;
1026
1027 memset(&info, 0, sizeof(info));
1028 info.type = MEM_RES_FRAME;
1029 info.tag = vdec->seq_tag + 0xf0;
1030 ret = vpu_session_alloc_fs(inst, &info);
1031 if (ret)
1032 return ret;
1033 vdec->req_frame_count--;
1034
1035 return 0;
1036 }
1037
vdec_response_frame(struct vpu_inst * inst,struct vb2_v4l2_buffer * vbuf)1038 static int vdec_response_frame(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1039 {
1040 struct vdec_t *vdec = inst->priv;
1041 struct vpu_vb2_buffer *vpu_buf;
1042 struct vpu_fs_info info;
1043 int ret;
1044
1045 if (inst->state != VPU_CODEC_STATE_ACTIVE)
1046 return -EINVAL;
1047
1048 if (vdec->aborting)
1049 return -EINVAL;
1050
1051 if (!vdec->req_frame_count)
1052 return -EINVAL;
1053
1054 if (!vbuf)
1055 return -EINVAL;
1056
1057 if (vdec->slots[vbuf->vb2_buf.index]) {
1058 dev_err(inst->dev, "[%d] repeat alloc fs %d\n",
1059 inst->id, vbuf->vb2_buf.index);
1060 return -EINVAL;
1061 }
1062
1063 dev_dbg(inst->dev, "[%d] state = %s, alloc fs %d, tag = 0x%x\n",
1064 inst->id, vpu_codec_state_name(inst->state), vbuf->vb2_buf.index, vdec->seq_tag);
1065 vpu_buf = to_vpu_vb2_buffer(vbuf);
1066
1067 memset(&info, 0, sizeof(info));
1068 info.id = vbuf->vb2_buf.index;
1069 info.type = MEM_RES_FRAME;
1070 info.tag = vdec->seq_tag;
1071 info.luma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 0);
1072 info.luma_size = inst->cap_format.sizeimage[0];
1073 if (vbuf->vb2_buf.num_planes > 1)
1074 info.chroma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 1);
1075 else
1076 info.chroma_addr = info.luma_addr + info.luma_size;
1077 info.chromau_size = inst->cap_format.sizeimage[1];
1078 info.bytesperline = inst->cap_format.bytesperline[0];
1079 ret = vpu_session_alloc_fs(inst, &info);
1080 if (ret)
1081 return ret;
1082
1083 vpu_buf->tag = info.tag;
1084 vpu_buf->luma = info.luma_addr;
1085 vpu_buf->chroma_u = info.chroma_addr;
1086 vpu_buf->chroma_v = 0;
1087 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1088 vdec->slots[info.id] = vpu_buf;
1089 vdec->req_frame_count--;
1090
1091 return 0;
1092 }
1093
vdec_response_fs_request(struct vpu_inst * inst,bool force)1094 static void vdec_response_fs_request(struct vpu_inst *inst, bool force)
1095 {
1096 struct vdec_t *vdec = inst->priv;
1097 int i;
1098 int ret;
1099
1100 if (force) {
1101 for (i = vdec->req_frame_count; i > 0; i--)
1102 vdec_response_frame_abnormal(inst);
1103 return;
1104 }
1105
1106 for (i = vdec->req_frame_count; i > 0; i--) {
1107 ret = vpu_process_capture_buffer(inst);
1108 if (ret)
1109 break;
1110 if (vdec->eos_received)
1111 break;
1112 }
1113
1114 for (i = vdec->mbi.index; i < vdec->mbi.count; i++) {
1115 if (vdec_response_fs(inst, &vdec->mbi))
1116 break;
1117 if (vdec->eos_received)
1118 break;
1119 }
1120 for (i = vdec->dcp.index; i < vdec->dcp.count; i++) {
1121 if (vdec_response_fs(inst, &vdec->dcp))
1122 break;
1123 if (vdec->eos_received)
1124 break;
1125 }
1126 }
1127
vdec_response_fs_release(struct vpu_inst * inst,u32 id,u32 tag)1128 static void vdec_response_fs_release(struct vpu_inst *inst, u32 id, u32 tag)
1129 {
1130 struct vpu_fs_info info;
1131
1132 memset(&info, 0, sizeof(info));
1133 info.id = id;
1134 info.tag = tag;
1135 vpu_session_release_fs(inst, &info);
1136 }
1137
vdec_recycle_buffer(struct vpu_inst * inst,struct vb2_v4l2_buffer * vbuf)1138 static void vdec_recycle_buffer(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1139 {
1140 if (!inst->fh.m2m_ctx)
1141 return;
1142 if (vbuf->vb2_buf.state != VB2_BUF_STATE_ACTIVE)
1143 return;
1144 if (vpu_find_buf_by_idx(inst, vbuf->vb2_buf.type, vbuf->vb2_buf.index))
1145 return;
1146 v4l2_m2m_buf_queue(inst->fh.m2m_ctx, vbuf);
1147 }
1148
vdec_clear_slots(struct vpu_inst * inst)1149 static void vdec_clear_slots(struct vpu_inst *inst)
1150 {
1151 struct vdec_t *vdec = inst->priv;
1152 struct vpu_vb2_buffer *vpu_buf;
1153 struct vb2_v4l2_buffer *vbuf;
1154 int i;
1155
1156 for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
1157 if (!vdec->slots[i])
1158 continue;
1159
1160 vpu_buf = vdec->slots[i];
1161 vbuf = &vpu_buf->m2m_buf.vb;
1162
1163 vpu_trace(inst->dev, "clear slot %d\n", i);
1164 vdec_response_fs_release(inst, i, vpu_buf->tag);
1165 vdec_recycle_buffer(inst, vbuf);
1166 vdec->slots[i]->state = VPU_BUF_STATE_IDLE;
1167 vdec->slots[i] = NULL;
1168 }
1169 }
1170
vdec_event_seq_hdr(struct vpu_inst * inst,struct vpu_dec_codec_info * hdr)1171 static void vdec_event_seq_hdr(struct vpu_inst *inst, struct vpu_dec_codec_info *hdr)
1172 {
1173 struct vdec_t *vdec = inst->priv;
1174
1175 vpu_inst_lock(inst);
1176 memcpy(&vdec->codec_info, hdr, sizeof(vdec->codec_info));
1177
1178 vpu_trace(inst->dev, "[%d] %d x %d, crop : (%d, %d) %d x %d, %d, %d\n",
1179 inst->id,
1180 vdec->codec_info.decoded_width,
1181 vdec->codec_info.decoded_height,
1182 vdec->codec_info.offset_x,
1183 vdec->codec_info.offset_y,
1184 vdec->codec_info.width,
1185 vdec->codec_info.height,
1186 hdr->num_ref_frms,
1187 hdr->num_dpb_frms);
1188 inst->min_buffer_cap = hdr->num_ref_frms + hdr->num_dpb_frms;
1189 vdec->is_source_changed = vdec_check_source_change(inst);
1190 vdec_init_fmt(inst);
1191 vdec_init_crop(inst);
1192 vdec_init_mbi(inst);
1193 vdec_init_dcp(inst);
1194 if (!vdec->seq_hdr_found) {
1195 vdec->seq_tag = vdec->codec_info.tag;
1196 if (vdec->is_source_changed) {
1197 vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1198 vdec->source_change++;
1199 vdec_handle_resolution_change(inst);
1200 vdec->is_source_changed = false;
1201 }
1202 }
1203 if (vdec->seq_tag != vdec->codec_info.tag) {
1204 vdec_response_fs_request(inst, true);
1205 vpu_trace(inst->dev, "[%d] seq tag change: %d -> %d\n",
1206 inst->id, vdec->seq_tag, vdec->codec_info.tag);
1207 }
1208 vdec->seq_hdr_found++;
1209 vdec->fixed_fmt = true;
1210 vpu_inst_unlock(inst);
1211 }
1212
vdec_event_resolution_change(struct vpu_inst * inst)1213 static void vdec_event_resolution_change(struct vpu_inst *inst)
1214 {
1215 struct vdec_t *vdec = inst->priv;
1216
1217 vpu_trace(inst->dev, "[%d]\n", inst->id);
1218 vpu_inst_lock(inst);
1219 vdec->seq_tag = vdec->codec_info.tag;
1220 vdec_clear_fs(&vdec->mbi);
1221 vdec_clear_fs(&vdec->dcp);
1222 vdec_clear_slots(inst);
1223 vdec_init_mbi(inst);
1224 vdec_init_dcp(inst);
1225 if (vdec->is_source_changed) {
1226 vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1227 vdec->source_change++;
1228 vdec_handle_resolution_change(inst);
1229 vdec->is_source_changed = false;
1230 }
1231 vpu_inst_unlock(inst);
1232 }
1233
vdec_event_req_fs(struct vpu_inst * inst,struct vpu_fs_info * fs)1234 static void vdec_event_req_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1235 {
1236 struct vdec_t *vdec = inst->priv;
1237
1238 if (!fs)
1239 return;
1240
1241 vpu_inst_lock(inst);
1242
1243 switch (fs->type) {
1244 case MEM_RES_FRAME:
1245 vdec->req_frame_count++;
1246 break;
1247 case MEM_RES_MBI:
1248 vdec_request_one_fs(&vdec->mbi);
1249 break;
1250 case MEM_RES_DCP:
1251 vdec_request_one_fs(&vdec->dcp);
1252 break;
1253 default:
1254 break;
1255 }
1256
1257 vdec_alloc_fs(inst, &vdec->mbi);
1258 vdec_alloc_fs(inst, &vdec->dcp);
1259
1260 vdec_response_fs_request(inst, false);
1261
1262 vpu_inst_unlock(inst);
1263 }
1264
vdec_evnet_rel_fs(struct vpu_inst * inst,struct vpu_fs_info * fs)1265 static void vdec_evnet_rel_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1266 {
1267 struct vdec_t *vdec = inst->priv;
1268 struct vpu_vb2_buffer *vpu_buf;
1269 struct vb2_v4l2_buffer *vbuf;
1270
1271 if (!fs || fs->id >= ARRAY_SIZE(vdec->slots))
1272 return;
1273 if (fs->type != MEM_RES_FRAME)
1274 return;
1275
1276 if (fs->id >= vpu_get_num_buffers(inst, inst->cap_format.type)) {
1277 dev_err(inst->dev, "[%d] invalid fs(%d) to release\n", inst->id, fs->id);
1278 return;
1279 }
1280
1281 vpu_inst_lock(inst);
1282 vpu_buf = vdec->slots[fs->id];
1283 vdec->slots[fs->id] = NULL;
1284
1285 if (!vpu_buf) {
1286 dev_dbg(inst->dev, "[%d] fs[%d] has bee released\n", inst->id, fs->id);
1287 goto exit;
1288 }
1289
1290 vbuf = &vpu_buf->m2m_buf.vb;
1291 if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED) {
1292 dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
1293 vdec->sequence++;
1294 }
1295
1296 vdec_response_fs_release(inst, fs->id, vpu_buf->tag);
1297 if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_READY)
1298 vdec_recycle_buffer(inst, vbuf);
1299
1300 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_IDLE);
1301 vpu_process_capture_buffer(inst);
1302
1303 exit:
1304 vpu_inst_unlock(inst);
1305 }
1306
vdec_event_eos(struct vpu_inst * inst)1307 static void vdec_event_eos(struct vpu_inst *inst)
1308 {
1309 struct vdec_t *vdec = inst->priv;
1310
1311 vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1312 inst->id,
1313 vdec->params.frame_count,
1314 vdec->decoded_frame_count,
1315 vdec->display_frame_count,
1316 vdec->sequence);
1317 vpu_inst_lock(inst);
1318 vdec->eos_received++;
1319 vdec->fixed_fmt = false;
1320 inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1321 vdec_set_last_buffer_dequeued(inst);
1322 vpu_inst_unlock(inst);
1323 }
1324
vdec_event_notify(struct vpu_inst * inst,u32 event,void * data)1325 static void vdec_event_notify(struct vpu_inst *inst, u32 event, void *data)
1326 {
1327 switch (event) {
1328 case VPU_MSG_ID_SEQ_HDR_FOUND:
1329 vdec_event_seq_hdr(inst, data);
1330 break;
1331 case VPU_MSG_ID_RES_CHANGE:
1332 vdec_event_resolution_change(inst);
1333 break;
1334 case VPU_MSG_ID_FRAME_REQ:
1335 vdec_event_req_fs(inst, data);
1336 break;
1337 case VPU_MSG_ID_FRAME_RELEASE:
1338 vdec_evnet_rel_fs(inst, data);
1339 break;
1340 case VPU_MSG_ID_PIC_EOS:
1341 vdec_event_eos(inst);
1342 break;
1343 default:
1344 break;
1345 }
1346 }
1347
vdec_process_output(struct vpu_inst * inst,struct vb2_buffer * vb)1348 static int vdec_process_output(struct vpu_inst *inst, struct vb2_buffer *vb)
1349 {
1350 struct vdec_t *vdec = inst->priv;
1351 struct vb2_v4l2_buffer *vbuf;
1352 struct vpu_rpc_buffer_desc desc;
1353 u32 free_space;
1354 int ret;
1355
1356 vbuf = to_vb2_v4l2_buffer(vb);
1357 dev_dbg(inst->dev, "[%d] dec output [%d] %d : %ld\n",
1358 inst->id, vbuf->sequence, vb->index, vb2_get_plane_payload(vb, 0));
1359
1360 if (inst->state == VPU_CODEC_STATE_DEINIT)
1361 return -EINVAL;
1362 if (vdec->reset_codec)
1363 return -EINVAL;
1364
1365 if (inst->state == VPU_CODEC_STATE_STARTED)
1366 vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
1367
1368 ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1369 if (ret)
1370 return ret;
1371
1372 free_space = vpu_helper_get_free_space(inst);
1373 if (free_space < vb2_get_plane_payload(vb, 0) + 0x40000)
1374 return -ENOMEM;
1375
1376 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1377 ret = vpu_iface_input_frame(inst, vb);
1378 if (ret < 0)
1379 return -ENOMEM;
1380
1381 dev_dbg(inst->dev, "[%d][INPUT TS]%32lld\n", inst->id, vb->timestamp);
1382 vdec->params.frame_count++;
1383
1384 if (vdec->drain)
1385 vdec_drain(inst);
1386
1387 return 0;
1388 }
1389
vdec_process_capture(struct vpu_inst * inst,struct vb2_buffer * vb)1390 static int vdec_process_capture(struct vpu_inst *inst, struct vb2_buffer *vb)
1391 {
1392 struct vdec_t *vdec = inst->priv;
1393 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1394 int ret;
1395
1396 if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
1397 return -EINVAL;
1398 if (vdec->reset_codec)
1399 return -EINVAL;
1400
1401 ret = vdec_response_frame(inst, vbuf);
1402 if (ret)
1403 return ret;
1404 v4l2_m2m_dst_buf_remove_by_buf(inst->fh.m2m_ctx, vbuf);
1405 return 0;
1406 }
1407
vdec_on_queue_empty(struct vpu_inst * inst,u32 type)1408 static void vdec_on_queue_empty(struct vpu_inst *inst, u32 type)
1409 {
1410 struct vdec_t *vdec = inst->priv;
1411
1412 if (V4L2_TYPE_IS_OUTPUT(type))
1413 return;
1414
1415 vdec_handle_resolution_change(inst);
1416 if (vdec->eos_received)
1417 vdec_set_last_buffer_dequeued(inst);
1418 }
1419
vdec_abort(struct vpu_inst * inst)1420 static void vdec_abort(struct vpu_inst *inst)
1421 {
1422 struct vdec_t *vdec = inst->priv;
1423 struct vpu_rpc_buffer_desc desc;
1424 int ret;
1425
1426 vpu_trace(inst->dev, "[%d] state = %s\n", inst->id, vpu_codec_state_name(inst->state));
1427
1428 vdec->aborting = true;
1429 vpu_iface_add_scode(inst, SCODE_PADDING_ABORT);
1430 vdec->params.end_flag = 1;
1431 vpu_iface_set_decode_params(inst, &vdec->params, 1);
1432
1433 vpu_session_abort(inst);
1434
1435 ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1436 if (!ret)
1437 vpu_iface_update_stream_buffer(inst, desc.rptr, 1);
1438
1439 vpu_session_rst_buf(inst);
1440 vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1441 inst->id,
1442 vdec->params.frame_count,
1443 vdec->decoded_frame_count,
1444 vdec->display_frame_count,
1445 vdec->sequence);
1446 if (!vdec->seq_hdr_found)
1447 vdec->reset_codec = true;
1448 vdec->params.end_flag = 0;
1449 vdec->drain = 0;
1450 vdec->params.frame_count = 0;
1451 vdec->decoded_frame_count = 0;
1452 vdec->display_frame_count = 0;
1453 vdec->sequence = 0;
1454 vdec->aborting = false;
1455 inst->extra_size = 0;
1456 }
1457
vdec_stop(struct vpu_inst * inst,bool free)1458 static void vdec_stop(struct vpu_inst *inst, bool free)
1459 {
1460 struct vdec_t *vdec = inst->priv;
1461
1462 vdec_clear_slots(inst);
1463 if (inst->state != VPU_CODEC_STATE_DEINIT)
1464 vpu_session_stop(inst);
1465 vdec_clear_fs(&vdec->mbi);
1466 vdec_clear_fs(&vdec->dcp);
1467 if (free) {
1468 vpu_free_dma(&vdec->udata);
1469 vpu_free_dma(&inst->stream_buffer);
1470 }
1471 vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 1);
1472 vdec->reset_codec = false;
1473 }
1474
vdec_release(struct vpu_inst * inst)1475 static void vdec_release(struct vpu_inst *inst)
1476 {
1477 if (inst->id != VPU_INST_NULL_ID)
1478 vpu_trace(inst->dev, "[%d]\n", inst->id);
1479 vdec_stop(inst, true);
1480 }
1481
vdec_cleanup(struct vpu_inst * inst)1482 static void vdec_cleanup(struct vpu_inst *inst)
1483 {
1484 struct vdec_t *vdec;
1485
1486 if (!inst)
1487 return;
1488
1489 vdec = inst->priv;
1490 vfree(vdec);
1491 inst->priv = NULL;
1492 vfree(inst);
1493 }
1494
vdec_init_params(struct vdec_t * vdec)1495 static void vdec_init_params(struct vdec_t *vdec)
1496 {
1497 vdec->params.frame_count = 0;
1498 vdec->params.end_flag = 0;
1499 }
1500
vdec_start(struct vpu_inst * inst)1501 static int vdec_start(struct vpu_inst *inst)
1502 {
1503 struct vdec_t *vdec = inst->priv;
1504 int stream_buffer_size;
1505 int ret;
1506
1507 if (inst->state != VPU_CODEC_STATE_DEINIT)
1508 return 0;
1509
1510 vpu_trace(inst->dev, "[%d]\n", inst->id);
1511 if (!vdec->udata.virt) {
1512 vdec->udata.length = 0x1000;
1513 ret = vpu_alloc_dma(inst->core, &vdec->udata);
1514 if (ret) {
1515 dev_err(inst->dev, "[%d] alloc udata fail\n", inst->id);
1516 goto error;
1517 }
1518 }
1519
1520 if (!inst->stream_buffer.virt) {
1521 stream_buffer_size = vpu_iface_get_stream_buffer_size(inst->core);
1522 if (stream_buffer_size > 0) {
1523 inst->stream_buffer.length = stream_buffer_size;
1524 ret = vpu_alloc_dma(inst->core, &inst->stream_buffer);
1525 if (ret) {
1526 dev_err(inst->dev, "[%d] alloc stream buffer fail\n", inst->id);
1527 goto error;
1528 }
1529 inst->use_stream_buffer = true;
1530 }
1531 }
1532
1533 if (inst->use_stream_buffer)
1534 vpu_iface_config_stream_buffer(inst, &inst->stream_buffer);
1535 vpu_iface_init_instance(inst);
1536 vdec->params.udata.base = vdec->udata.phys;
1537 vdec->params.udata.size = vdec->udata.length;
1538 ret = vpu_iface_set_decode_params(inst, &vdec->params, 0);
1539 if (ret) {
1540 dev_err(inst->dev, "[%d] set decode params fail\n", inst->id);
1541 goto error;
1542 }
1543
1544 vdec_init_params(vdec);
1545 ret = vpu_session_start(inst);
1546 if (ret) {
1547 dev_err(inst->dev, "[%d] start fail\n", inst->id);
1548 goto error;
1549 }
1550
1551 vdec_update_state(inst, VPU_CODEC_STATE_STARTED, 0);
1552
1553 return 0;
1554 error:
1555 vpu_free_dma(&vdec->udata);
1556 vpu_free_dma(&inst->stream_buffer);
1557 return ret;
1558 }
1559
vdec_start_session(struct vpu_inst * inst,u32 type)1560 static int vdec_start_session(struct vpu_inst *inst, u32 type)
1561 {
1562 struct vdec_t *vdec = inst->priv;
1563 int ret = 0;
1564
1565 if (V4L2_TYPE_IS_OUTPUT(type)) {
1566 if (vdec->reset_codec)
1567 vdec_stop(inst, false);
1568 if (inst->state == VPU_CODEC_STATE_DEINIT) {
1569 ret = vdec_start(inst);
1570 if (ret)
1571 return ret;
1572 }
1573 }
1574
1575 if (V4L2_TYPE_IS_OUTPUT(type)) {
1576 vdec_update_state(inst, vdec->state, 1);
1577 vdec->eos_received = 0;
1578 vpu_process_output_buffer(inst);
1579 } else {
1580 vdec_cmd_start(inst);
1581 }
1582 if (inst->state == VPU_CODEC_STATE_ACTIVE)
1583 vdec_response_fs_request(inst, false);
1584
1585 return ret;
1586 }
1587
vdec_stop_session(struct vpu_inst * inst,u32 type)1588 static int vdec_stop_session(struct vpu_inst *inst, u32 type)
1589 {
1590 struct vdec_t *vdec = inst->priv;
1591
1592 if (inst->state == VPU_CODEC_STATE_DEINIT)
1593 return 0;
1594
1595 if (V4L2_TYPE_IS_OUTPUT(type)) {
1596 vdec_update_state(inst, VPU_CODEC_STATE_SEEK, 0);
1597 vdec->drain = 0;
1598 } else {
1599 if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE) {
1600 vdec_abort(inst);
1601 vdec->eos_received = 0;
1602 }
1603 vdec_clear_slots(inst);
1604 }
1605
1606 return 0;
1607 }
1608
vdec_get_debug_info(struct vpu_inst * inst,char * str,u32 size,u32 i)1609 static int vdec_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i)
1610 {
1611 struct vdec_t *vdec = inst->priv;
1612 int num = -1;
1613
1614 switch (i) {
1615 case 0:
1616 num = scnprintf(str, size,
1617 "req_frame_count = %d\ninterlaced = %d\n",
1618 vdec->req_frame_count,
1619 vdec->codec_info.progressive ? 0 : 1);
1620 break;
1621 case 1:
1622 num = scnprintf(str, size,
1623 "mbi: size = 0x%x request = %d, alloc = %d, response = %d\n",
1624 vdec->mbi.size,
1625 vdec->mbi.req_count,
1626 vdec->mbi.count,
1627 vdec->mbi.index);
1628 break;
1629 case 2:
1630 num = scnprintf(str, size,
1631 "dcp: size = 0x%x request = %d, alloc = %d, response = %d\n",
1632 vdec->dcp.size,
1633 vdec->dcp.req_count,
1634 vdec->dcp.count,
1635 vdec->dcp.index);
1636 break;
1637 case 3:
1638 num = scnprintf(str, size, "input_frame_count = %d\n", vdec->params.frame_count);
1639 break;
1640 case 4:
1641 num = scnprintf(str, size, "decoded_frame_count = %d\n", vdec->decoded_frame_count);
1642 break;
1643 case 5:
1644 num = scnprintf(str, size, "display_frame_count = %d\n", vdec->display_frame_count);
1645 break;
1646 case 6:
1647 num = scnprintf(str, size, "sequence = %d\n", vdec->sequence);
1648 break;
1649 case 7:
1650 num = scnprintf(str, size, "drain = %d, eos = %d, source_change = %d\n",
1651 vdec->drain, vdec->eos_received, vdec->source_change);
1652 break;
1653 case 8:
1654 num = scnprintf(str, size, "fps = %d/%d\n",
1655 vdec->codec_info.frame_rate.numerator,
1656 vdec->codec_info.frame_rate.denominator);
1657 break;
1658 case 9:
1659 num = scnprintf(str, size, "colorspace: %d, %d, %d, %d (%d)\n",
1660 vdec->codec_info.color_primaries,
1661 vdec->codec_info.transfer_chars,
1662 vdec->codec_info.matrix_coeffs,
1663 vdec->codec_info.full_range,
1664 vdec->codec_info.vui_present);
1665 break;
1666 default:
1667 break;
1668 }
1669
1670 return num;
1671 }
1672
1673 static struct vpu_inst_ops vdec_inst_ops = {
1674 .ctrl_init = vdec_ctrl_init,
1675 .check_ready = vdec_check_ready,
1676 .buf_done = vdec_buf_done,
1677 .get_one_frame = vdec_frame_decoded,
1678 .stop_done = vdec_stop_done,
1679 .event_notify = vdec_event_notify,
1680 .release = vdec_release,
1681 .cleanup = vdec_cleanup,
1682 .start = vdec_start_session,
1683 .stop = vdec_stop_session,
1684 .process_output = vdec_process_output,
1685 .process_capture = vdec_process_capture,
1686 .on_queue_empty = vdec_on_queue_empty,
1687 .get_debug_info = vdec_get_debug_info,
1688 .wait_prepare = vpu_inst_unlock,
1689 .wait_finish = vpu_inst_lock,
1690 };
1691
vdec_init(struct file * file)1692 static void vdec_init(struct file *file)
1693 {
1694 struct vpu_inst *inst = to_inst(file);
1695 struct v4l2_format f;
1696
1697 memset(&f, 0, sizeof(f));
1698 f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1699 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
1700 f.fmt.pix_mp.width = 1280;
1701 f.fmt.pix_mp.height = 720;
1702 f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1703 vdec_s_fmt(file, &inst->fh, &f);
1704
1705 memset(&f, 0, sizeof(f));
1706 f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1707 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M_8L128;
1708 f.fmt.pix_mp.width = 1280;
1709 f.fmt.pix_mp.height = 720;
1710 f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1711 vdec_s_fmt(file, &inst->fh, &f);
1712 }
1713
vdec_open(struct file * file)1714 static int vdec_open(struct file *file)
1715 {
1716 struct vpu_inst *inst;
1717 struct vdec_t *vdec;
1718 int ret;
1719
1720 inst = vzalloc(sizeof(*inst));
1721 if (!inst)
1722 return -ENOMEM;
1723
1724 vdec = vzalloc(sizeof(*vdec));
1725 if (!vdec) {
1726 vfree(inst);
1727 return -ENOMEM;
1728 }
1729
1730 inst->ops = &vdec_inst_ops;
1731 inst->formats = vdec_formats;
1732 inst->type = VPU_CORE_TYPE_DEC;
1733 inst->priv = vdec;
1734
1735 ret = vpu_v4l2_open(file, inst);
1736 if (ret)
1737 return ret;
1738
1739 vdec->fixed_fmt = false;
1740 vdec->state = VPU_CODEC_STATE_ACTIVE;
1741 inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1742 inst->min_buffer_out = VDEC_MIN_BUFFER_OUT;
1743 vdec_init(file);
1744
1745 return 0;
1746 }
1747
1748 static const struct v4l2_file_operations vdec_fops = {
1749 .owner = THIS_MODULE,
1750 .open = vdec_open,
1751 .release = vpu_v4l2_close,
1752 .unlocked_ioctl = video_ioctl2,
1753 .poll = v4l2_m2m_fop_poll,
1754 .mmap = v4l2_m2m_fop_mmap,
1755 };
1756
vdec_get_ioctl_ops(void)1757 const struct v4l2_ioctl_ops *vdec_get_ioctl_ops(void)
1758 {
1759 return &vdec_ioctl_ops;
1760 }
1761
vdec_get_fops(void)1762 const struct v4l2_file_operations *vdec_get_fops(void)
1763 {
1764 return &vdec_fops;
1765 }
1766