1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Hantro VPU codec driver
4 *
5 * Copyright (C) 2018 Collabora, Ltd.
6 * Copyright (C) 2018 Rockchip Electronics Co., Ltd.
7 * Alpha Lin <Alpha.Lin@rock-chips.com>
8 * Jeffy Chen <jeffy.chen@rock-chips.com>
9 *
10 * Copyright 2018 Google LLC.
11 * Tomasz Figa <tfiga@chromium.org>
12 *
13 * Based on s5p-mfc driver by Samsung Electronics Co., Ltd.
14 * Copyright (C) 2010-2011 Samsung Electronics Co., Ltd.
15 */
16
17 #include <linux/interrupt.h>
18 #include <linux/io.h>
19 #include <linux/module.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/videodev2.h>
22 #include <linux/workqueue.h>
23 #include <media/v4l2-ctrls.h>
24 #include <media/v4l2-event.h>
25 #include <media/v4l2-mem2mem.h>
26
27 #include "hantro.h"
28 #include "hantro_hw.h"
29 #include "hantro_v4l2.h"
30
31 #define HANTRO_DEFAULT_BIT_DEPTH 8
32
33 static int hantro_set_fmt_out(struct hantro_ctx *ctx,
34 struct v4l2_pix_format_mplane *pix_mp,
35 bool need_postproc);
36 static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
37 struct v4l2_pix_format_mplane *pix_mp);
38
39 static const struct hantro_fmt *
hantro_get_formats(const struct hantro_ctx * ctx,unsigned int * num_fmts,bool need_postproc)40 hantro_get_formats(const struct hantro_ctx *ctx, unsigned int *num_fmts, bool need_postproc)
41 {
42 const struct hantro_fmt *formats;
43
44 if (need_postproc) {
45 *num_fmts = 0;
46 return NULL;
47 }
48
49 if (ctx->is_encoder) {
50 formats = ctx->dev->variant->enc_fmts;
51 *num_fmts = ctx->dev->variant->num_enc_fmts;
52 } else {
53 formats = ctx->dev->variant->dec_fmts;
54 *num_fmts = ctx->dev->variant->num_dec_fmts;
55 }
56
57 return formats;
58 }
59
60 static const struct hantro_fmt *
hantro_get_postproc_formats(const struct hantro_ctx * ctx,unsigned int * num_fmts)61 hantro_get_postproc_formats(const struct hantro_ctx *ctx,
62 unsigned int *num_fmts)
63 {
64 struct hantro_dev *vpu = ctx->dev;
65
66 if (ctx->is_encoder || !vpu->variant->postproc_fmts) {
67 *num_fmts = 0;
68 return NULL;
69 }
70
71 *num_fmts = ctx->dev->variant->num_postproc_fmts;
72 return ctx->dev->variant->postproc_fmts;
73 }
74
hantro_get_format_depth(u32 fourcc)75 int hantro_get_format_depth(u32 fourcc)
76 {
77 switch (fourcc) {
78 case V4L2_PIX_FMT_P010:
79 case V4L2_PIX_FMT_P010_4L4:
80 case V4L2_PIX_FMT_NV15_4L4:
81 return 10;
82 default:
83 return 8;
84 }
85 }
86
87 static bool
hantro_check_depth_match(const struct hantro_fmt * fmt,int bit_depth)88 hantro_check_depth_match(const struct hantro_fmt *fmt, int bit_depth)
89 {
90 int fmt_depth;
91
92 if (!fmt->match_depth && !fmt->postprocessed)
93 return true;
94
95 /* 0 means default depth, which is 8 */
96 if (!bit_depth)
97 bit_depth = HANTRO_DEFAULT_BIT_DEPTH;
98
99 fmt_depth = hantro_get_format_depth(fmt->fourcc);
100
101 /*
102 * Allow only downconversion for postproc formats for now.
103 * It may be possible to relax that on some HW.
104 */
105 if (!fmt->match_depth)
106 return fmt_depth <= bit_depth;
107
108 return fmt_depth == bit_depth;
109 }
110
111 static const struct hantro_fmt *
hantro_find_format(const struct hantro_ctx * ctx,u32 fourcc)112 hantro_find_format(const struct hantro_ctx *ctx, u32 fourcc)
113 {
114 const struct hantro_fmt *formats;
115 unsigned int i, num_fmts;
116
117 formats = hantro_get_formats(ctx, &num_fmts, HANTRO_AUTO_POSTPROC);
118 for (i = 0; i < num_fmts; i++)
119 if (formats[i].fourcc == fourcc)
120 return &formats[i];
121
122 formats = hantro_get_postproc_formats(ctx, &num_fmts);
123 for (i = 0; i < num_fmts; i++)
124 if (formats[i].fourcc == fourcc)
125 return &formats[i];
126 return NULL;
127 }
128
129 const struct hantro_fmt *
hantro_get_default_fmt(const struct hantro_ctx * ctx,bool bitstream,int bit_depth,bool need_postproc)130 hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream,
131 int bit_depth, bool need_postproc)
132 {
133 const struct hantro_fmt *formats;
134 unsigned int i, num_fmts;
135
136 formats = hantro_get_formats(ctx, &num_fmts, need_postproc);
137 for (i = 0; i < num_fmts; i++) {
138 if (bitstream == (formats[i].codec_mode !=
139 HANTRO_MODE_NONE) &&
140 hantro_check_depth_match(&formats[i], bit_depth))
141 return &formats[i];
142 }
143
144 formats = hantro_get_postproc_formats(ctx, &num_fmts);
145 for (i = 0; i < num_fmts; i++) {
146 if (bitstream == (formats[i].codec_mode !=
147 HANTRO_MODE_NONE) &&
148 hantro_check_depth_match(&formats[i], bit_depth))
149 return &formats[i];
150 }
151
152 return NULL;
153 }
154
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * cap)155 static int vidioc_querycap(struct file *file, void *priv,
156 struct v4l2_capability *cap)
157 {
158 struct hantro_dev *vpu = video_drvdata(file);
159 struct video_device *vdev = video_devdata(file);
160
161 strscpy(cap->driver, vpu->dev->driver->name, sizeof(cap->driver));
162 strscpy(cap->card, vdev->name, sizeof(cap->card));
163 return 0;
164 }
165
vidioc_enum_framesizes(struct file * file,void * priv,struct v4l2_frmsizeenum * fsize)166 static int vidioc_enum_framesizes(struct file *file, void *priv,
167 struct v4l2_frmsizeenum *fsize)
168 {
169 struct hantro_ctx *ctx = fh_to_ctx(priv);
170 const struct hantro_fmt *fmt;
171
172 fmt = hantro_find_format(ctx, fsize->pixel_format);
173 if (!fmt) {
174 vpu_debug(0, "unsupported bitstream format (%08x)\n",
175 fsize->pixel_format);
176 return -EINVAL;
177 }
178
179 /* For non-coded formats check if postprocessing scaling is possible */
180 if (fmt->codec_mode == HANTRO_MODE_NONE) {
181 if (hantro_needs_postproc(ctx, fmt))
182 return hanto_postproc_enum_framesizes(ctx, fsize);
183 else
184 return -ENOTTY;
185 } else if (fsize->index != 0) {
186 vpu_debug(0, "invalid frame size index (expected 0, got %d)\n",
187 fsize->index);
188 return -EINVAL;
189 }
190
191 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
192 fsize->stepwise = fmt->frmsize;
193
194 return 0;
195 }
196
vidioc_enum_fmt(struct file * file,void * priv,struct v4l2_fmtdesc * f,bool capture)197 static int vidioc_enum_fmt(struct file *file, void *priv,
198 struct v4l2_fmtdesc *f, bool capture)
199
200 {
201 struct hantro_ctx *ctx = fh_to_ctx(priv);
202 const struct hantro_fmt *fmt, *formats;
203 unsigned int num_fmts, i, j = 0;
204 bool skip_mode_none;
205
206 /*
207 * When dealing with an encoder:
208 * - on the capture side we want to filter out all MODE_NONE formats.
209 * - on the output side we want to filter out all formats that are
210 * not MODE_NONE.
211 * When dealing with a decoder:
212 * - on the capture side we want to filter out all formats that are
213 * not MODE_NONE.
214 * - on the output side we want to filter out all MODE_NONE formats.
215 */
216 skip_mode_none = capture == ctx->is_encoder;
217
218 formats = hantro_get_formats(ctx, &num_fmts, HANTRO_AUTO_POSTPROC);
219 for (i = 0; i < num_fmts; i++) {
220 bool mode_none = formats[i].codec_mode == HANTRO_MODE_NONE;
221 fmt = &formats[i];
222
223 if (skip_mode_none == mode_none)
224 continue;
225 if (!hantro_check_depth_match(fmt, ctx->bit_depth))
226 continue;
227 if (j == f->index) {
228 f->pixelformat = fmt->fourcc;
229 return 0;
230 }
231 ++j;
232 }
233
234 /*
235 * Enumerate post-processed formats. As per the specification,
236 * we enumerated these formats after natively decoded formats
237 * as a hint for applications on what's the preferred fomat.
238 */
239 if (!capture)
240 return -EINVAL;
241 formats = hantro_get_postproc_formats(ctx, &num_fmts);
242 for (i = 0; i < num_fmts; i++) {
243 fmt = &formats[i];
244
245 if (!hantro_check_depth_match(fmt, ctx->bit_depth))
246 continue;
247 if (j == f->index) {
248 f->pixelformat = fmt->fourcc;
249 return 0;
250 }
251 ++j;
252 }
253
254 return -EINVAL;
255 }
256
vidioc_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)257 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
258 struct v4l2_fmtdesc *f)
259 {
260 return vidioc_enum_fmt(file, priv, f, true);
261 }
262
vidioc_enum_fmt_vid_out(struct file * file,void * priv,struct v4l2_fmtdesc * f)263 static int vidioc_enum_fmt_vid_out(struct file *file, void *priv,
264 struct v4l2_fmtdesc *f)
265 {
266 return vidioc_enum_fmt(file, priv, f, false);
267 }
268
vidioc_g_fmt_out_mplane(struct file * file,void * priv,struct v4l2_format * f)269 static int vidioc_g_fmt_out_mplane(struct file *file, void *priv,
270 struct v4l2_format *f)
271 {
272 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
273 struct hantro_ctx *ctx = fh_to_ctx(priv);
274
275 vpu_debug(4, "f->type = %d\n", f->type);
276
277 *pix_mp = ctx->src_fmt;
278
279 return 0;
280 }
281
vidioc_g_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)282 static int vidioc_g_fmt_cap_mplane(struct file *file, void *priv,
283 struct v4l2_format *f)
284 {
285 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
286 struct hantro_ctx *ctx = fh_to_ctx(priv);
287
288 vpu_debug(4, "f->type = %d\n", f->type);
289
290 *pix_mp = ctx->dst_fmt;
291
292 return 0;
293 }
294
hantro_try_fmt(const struct hantro_ctx * ctx,struct v4l2_pix_format_mplane * pix_mp,enum v4l2_buf_type type)295 static int hantro_try_fmt(const struct hantro_ctx *ctx,
296 struct v4l2_pix_format_mplane *pix_mp,
297 enum v4l2_buf_type type)
298 {
299 const struct hantro_fmt *fmt;
300 const struct hantro_fmt *vpu_fmt;
301 bool capture = V4L2_TYPE_IS_CAPTURE(type);
302 bool coded;
303
304 coded = capture == ctx->is_encoder;
305
306 vpu_debug(4, "trying format %c%c%c%c\n",
307 (pix_mp->pixelformat & 0x7f),
308 (pix_mp->pixelformat >> 8) & 0x7f,
309 (pix_mp->pixelformat >> 16) & 0x7f,
310 (pix_mp->pixelformat >> 24) & 0x7f);
311
312 fmt = hantro_find_format(ctx, pix_mp->pixelformat);
313 if (!fmt) {
314 fmt = hantro_get_default_fmt(ctx, coded, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
315 pix_mp->pixelformat = fmt->fourcc;
316 }
317
318 if (coded) {
319 pix_mp->num_planes = 1;
320 vpu_fmt = fmt;
321 } else if (ctx->is_encoder) {
322 vpu_fmt = hantro_find_format(ctx, ctx->dst_fmt.pixelformat);
323 } else {
324 /*
325 * Width/height on the CAPTURE end of a decoder are ignored and
326 * replaced by the OUTPUT ones.
327 */
328 pix_mp->width = ctx->src_fmt.width;
329 pix_mp->height = ctx->src_fmt.height;
330 vpu_fmt = fmt;
331 }
332
333 pix_mp->field = V4L2_FIELD_NONE;
334
335 v4l2_apply_frmsize_constraints(&pix_mp->width, &pix_mp->height,
336 &vpu_fmt->frmsize);
337
338 if (!coded) {
339 /* Fill remaining fields */
340 v4l2_fill_pixfmt_mp(pix_mp, fmt->fourcc, pix_mp->width,
341 pix_mp->height);
342 if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_H264_SLICE &&
343 !hantro_needs_postproc(ctx, fmt))
344 pix_mp->plane_fmt[0].sizeimage +=
345 hantro_h264_mv_size(pix_mp->width,
346 pix_mp->height);
347 else if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_VP9_FRAME &&
348 !hantro_needs_postproc(ctx, fmt))
349 pix_mp->plane_fmt[0].sizeimage +=
350 hantro_vp9_mv_size(pix_mp->width,
351 pix_mp->height);
352 else if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_HEVC_SLICE &&
353 !hantro_needs_postproc(ctx, fmt))
354 pix_mp->plane_fmt[0].sizeimage +=
355 hantro_hevc_mv_size(pix_mp->width,
356 pix_mp->height);
357 else if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_AV1_FRAME &&
358 !hantro_needs_postproc(ctx, fmt))
359 pix_mp->plane_fmt[0].sizeimage +=
360 hantro_av1_mv_size(pix_mp->width,
361 pix_mp->height);
362 } else if (!pix_mp->plane_fmt[0].sizeimage) {
363 /*
364 * For coded formats the application can specify
365 * sizeimage. If the application passes a zero sizeimage,
366 * let's default to the maximum frame size.
367 */
368 pix_mp->plane_fmt[0].sizeimage = fmt->header_size +
369 pix_mp->width * pix_mp->height * fmt->max_depth;
370 }
371
372 return 0;
373 }
374
vidioc_try_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)375 static int vidioc_try_fmt_cap_mplane(struct file *file, void *priv,
376 struct v4l2_format *f)
377 {
378 return hantro_try_fmt(fh_to_ctx(priv), &f->fmt.pix_mp, f->type);
379 }
380
vidioc_try_fmt_out_mplane(struct file * file,void * priv,struct v4l2_format * f)381 static int vidioc_try_fmt_out_mplane(struct file *file, void *priv,
382 struct v4l2_format *f)
383 {
384 return hantro_try_fmt(fh_to_ctx(priv), &f->fmt.pix_mp, f->type);
385 }
386
387 static void
hantro_reset_fmt(struct v4l2_pix_format_mplane * fmt,const struct hantro_fmt * vpu_fmt)388 hantro_reset_fmt(struct v4l2_pix_format_mplane *fmt,
389 const struct hantro_fmt *vpu_fmt)
390 {
391 memset(fmt, 0, sizeof(*fmt));
392
393 fmt->pixelformat = vpu_fmt->fourcc;
394 fmt->field = V4L2_FIELD_NONE;
395 fmt->colorspace = V4L2_COLORSPACE_JPEG;
396 fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
397 fmt->quantization = V4L2_QUANTIZATION_DEFAULT;
398 fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT;
399 }
400
401 static void
hantro_reset_encoded_fmt(struct hantro_ctx * ctx)402 hantro_reset_encoded_fmt(struct hantro_ctx *ctx)
403 {
404 const struct hantro_fmt *vpu_fmt;
405 struct v4l2_pix_format_mplane fmt;
406
407 vpu_fmt = hantro_get_default_fmt(ctx, true, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
408 if (!vpu_fmt)
409 return;
410
411 hantro_reset_fmt(&fmt, vpu_fmt);
412 fmt.width = vpu_fmt->frmsize.min_width;
413 fmt.height = vpu_fmt->frmsize.min_height;
414 if (ctx->is_encoder)
415 hantro_set_fmt_cap(ctx, &fmt);
416 else
417 hantro_set_fmt_out(ctx, &fmt, HANTRO_AUTO_POSTPROC);
418 }
419
420 int
hantro_reset_raw_fmt(struct hantro_ctx * ctx,int bit_depth,bool need_postproc)421 hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth, bool need_postproc)
422 {
423 const struct hantro_fmt *raw_vpu_fmt;
424 struct v4l2_pix_format_mplane raw_fmt, *encoded_fmt;
425 int ret;
426
427 raw_vpu_fmt = hantro_get_default_fmt(ctx, false, bit_depth, need_postproc);
428 if (!raw_vpu_fmt)
429 return -EINVAL;
430
431 if (ctx->is_encoder) {
432 encoded_fmt = &ctx->dst_fmt;
433 ctx->vpu_src_fmt = raw_vpu_fmt;
434 } else {
435 encoded_fmt = &ctx->src_fmt;
436 }
437
438 hantro_reset_fmt(&raw_fmt, raw_vpu_fmt);
439 raw_fmt.width = encoded_fmt->width;
440 raw_fmt.height = encoded_fmt->height;
441 if (ctx->is_encoder)
442 ret = hantro_set_fmt_out(ctx, &raw_fmt, need_postproc);
443 else
444 ret = hantro_set_fmt_cap(ctx, &raw_fmt);
445
446 if (!ret) {
447 ctx->bit_depth = bit_depth;
448 ctx->need_postproc = need_postproc;
449 }
450
451 return ret;
452 }
453
hantro_reset_fmts(struct hantro_ctx * ctx)454 void hantro_reset_fmts(struct hantro_ctx *ctx)
455 {
456 hantro_reset_encoded_fmt(ctx);
457 hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
458 }
459
460 static void
hantro_update_requires_request(struct hantro_ctx * ctx,u32 fourcc)461 hantro_update_requires_request(struct hantro_ctx *ctx, u32 fourcc)
462 {
463 switch (fourcc) {
464 case V4L2_PIX_FMT_JPEG:
465 ctx->fh.m2m_ctx->out_q_ctx.q.requires_requests = false;
466 break;
467 case V4L2_PIX_FMT_MPEG2_SLICE:
468 case V4L2_PIX_FMT_VP8_FRAME:
469 case V4L2_PIX_FMT_H264_SLICE:
470 case V4L2_PIX_FMT_HEVC_SLICE:
471 case V4L2_PIX_FMT_VP9_FRAME:
472 ctx->fh.m2m_ctx->out_q_ctx.q.requires_requests = true;
473 break;
474 default:
475 break;
476 }
477 }
478
479 static void
hantro_update_requires_hold_capture_buf(struct hantro_ctx * ctx,u32 fourcc)480 hantro_update_requires_hold_capture_buf(struct hantro_ctx *ctx, u32 fourcc)
481 {
482 struct vb2_queue *vq;
483
484 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
485 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
486
487 switch (fourcc) {
488 case V4L2_PIX_FMT_JPEG:
489 case V4L2_PIX_FMT_MPEG2_SLICE:
490 case V4L2_PIX_FMT_VP8_FRAME:
491 case V4L2_PIX_FMT_HEVC_SLICE:
492 case V4L2_PIX_FMT_VP9_FRAME:
493 vq->subsystem_flags &= ~(VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF);
494 break;
495 case V4L2_PIX_FMT_H264_SLICE:
496 vq->subsystem_flags |= VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF;
497 break;
498 default:
499 break;
500 }
501 }
502
hantro_set_fmt_out(struct hantro_ctx * ctx,struct v4l2_pix_format_mplane * pix_mp,bool need_postproc)503 static int hantro_set_fmt_out(struct hantro_ctx *ctx,
504 struct v4l2_pix_format_mplane *pix_mp,
505 bool need_postproc)
506 {
507 struct vb2_queue *vq;
508 int ret;
509
510 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
511 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
512 ret = hantro_try_fmt(ctx, pix_mp, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
513 if (ret)
514 return ret;
515
516 if (!ctx->is_encoder) {
517 struct vb2_queue *peer_vq;
518
519 /*
520 * In order to support dynamic resolution change,
521 * the decoder admits a resolution change, as long
522 * as the pixelformat remains. Can't be done if streaming.
523 */
524 if (vb2_is_streaming(vq) || (vb2_is_busy(vq) &&
525 pix_mp->pixelformat != ctx->src_fmt.pixelformat))
526 return -EBUSY;
527 /*
528 * Since format change on the OUTPUT queue will reset
529 * the CAPTURE queue, we can't allow doing so
530 * when the CAPTURE queue has buffers allocated.
531 */
532 peer_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
533 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
534 if (vb2_is_busy(peer_vq))
535 return -EBUSY;
536 } else {
537 /*
538 * The encoder doesn't admit a format change if
539 * there are OUTPUT buffers allocated.
540 */
541 if (vb2_is_busy(vq))
542 return -EBUSY;
543 }
544
545 ctx->vpu_src_fmt = hantro_find_format(ctx, pix_mp->pixelformat);
546 ctx->src_fmt = *pix_mp;
547
548 /*
549 * Current raw format might have become invalid with newly
550 * selected codec, so reset it to default just to be safe and
551 * keep internal driver state sane. User is mandated to set
552 * the raw format again after we return, so we don't need
553 * anything smarter.
554 * Note that hantro_reset_raw_fmt() also propagates size
555 * changes to the raw format.
556 */
557 if (!ctx->is_encoder)
558 hantro_reset_raw_fmt(ctx,
559 hantro_get_format_depth(pix_mp->pixelformat),
560 need_postproc);
561
562 /* Colorimetry information are always propagated. */
563 ctx->dst_fmt.colorspace = pix_mp->colorspace;
564 ctx->dst_fmt.ycbcr_enc = pix_mp->ycbcr_enc;
565 ctx->dst_fmt.xfer_func = pix_mp->xfer_func;
566 ctx->dst_fmt.quantization = pix_mp->quantization;
567
568 hantro_update_requires_request(ctx, pix_mp->pixelformat);
569 hantro_update_requires_hold_capture_buf(ctx, pix_mp->pixelformat);
570
571 vpu_debug(0, "OUTPUT codec mode: %d\n", ctx->vpu_src_fmt->codec_mode);
572 vpu_debug(0, "fmt - w: %d, h: %d\n",
573 pix_mp->width, pix_mp->height);
574 return 0;
575 }
576
hantro_set_fmt_cap(struct hantro_ctx * ctx,struct v4l2_pix_format_mplane * pix_mp)577 static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
578 struct v4l2_pix_format_mplane *pix_mp)
579 {
580 struct vb2_queue *vq;
581 int ret;
582
583 /* Change not allowed if queue is busy. */
584 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
585 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
586 if (vb2_is_busy(vq))
587 return -EBUSY;
588
589 if (ctx->is_encoder) {
590 struct vb2_queue *peer_vq;
591
592 /*
593 * Since format change on the CAPTURE queue will reset
594 * the OUTPUT queue, we can't allow doing so
595 * when the OUTPUT queue has buffers allocated.
596 */
597 peer_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
598 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
599 if (vb2_is_busy(peer_vq) &&
600 (pix_mp->pixelformat != ctx->dst_fmt.pixelformat ||
601 pix_mp->height != ctx->dst_fmt.height ||
602 pix_mp->width != ctx->dst_fmt.width))
603 return -EBUSY;
604 }
605
606 ret = hantro_try_fmt(ctx, pix_mp, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
607 if (ret)
608 return ret;
609
610 ctx->vpu_dst_fmt = hantro_find_format(ctx, pix_mp->pixelformat);
611 ctx->dst_fmt = *pix_mp;
612
613 /*
614 * Current raw format might have become invalid with newly
615 * selected codec, so reset it to default just to be safe and
616 * keep internal driver state sane. User is mandated to set
617 * the raw format again after we return, so we don't need
618 * anything smarter.
619 * Note that hantro_reset_raw_fmt() also propagates size
620 * changes to the raw format.
621 */
622 if (ctx->is_encoder)
623 hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
624
625 /* Colorimetry information are always propagated. */
626 ctx->src_fmt.colorspace = pix_mp->colorspace;
627 ctx->src_fmt.ycbcr_enc = pix_mp->ycbcr_enc;
628 ctx->src_fmt.xfer_func = pix_mp->xfer_func;
629 ctx->src_fmt.quantization = pix_mp->quantization;
630
631 vpu_debug(0, "CAPTURE codec mode: %d\n", ctx->vpu_dst_fmt->codec_mode);
632 vpu_debug(0, "fmt - w: %d, h: %d\n",
633 pix_mp->width, pix_mp->height);
634
635 hantro_update_requires_request(ctx, pix_mp->pixelformat);
636
637 return 0;
638 }
639
640 static int
vidioc_s_fmt_out_mplane(struct file * file,void * priv,struct v4l2_format * f)641 vidioc_s_fmt_out_mplane(struct file *file, void *priv, struct v4l2_format *f)
642 {
643 return hantro_set_fmt_out(fh_to_ctx(priv), &f->fmt.pix_mp, HANTRO_AUTO_POSTPROC);
644 }
645
646 static int
vidioc_s_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)647 vidioc_s_fmt_cap_mplane(struct file *file, void *priv, struct v4l2_format *f)
648 {
649 return hantro_set_fmt_cap(fh_to_ctx(priv), &f->fmt.pix_mp);
650 }
651
vidioc_g_selection(struct file * file,void * priv,struct v4l2_selection * sel)652 static int vidioc_g_selection(struct file *file, void *priv,
653 struct v4l2_selection *sel)
654 {
655 struct hantro_ctx *ctx = fh_to_ctx(priv);
656
657 /* Crop only supported on source. */
658 if (!ctx->is_encoder ||
659 sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
660 return -EINVAL;
661
662 switch (sel->target) {
663 case V4L2_SEL_TGT_CROP_DEFAULT:
664 case V4L2_SEL_TGT_CROP_BOUNDS:
665 sel->r.top = 0;
666 sel->r.left = 0;
667 sel->r.width = ctx->src_fmt.width;
668 sel->r.height = ctx->src_fmt.height;
669 break;
670 case V4L2_SEL_TGT_CROP:
671 sel->r.top = 0;
672 sel->r.left = 0;
673 sel->r.width = ctx->dst_fmt.width;
674 sel->r.height = ctx->dst_fmt.height;
675 break;
676 default:
677 return -EINVAL;
678 }
679
680 return 0;
681 }
682
vidioc_s_selection(struct file * file,void * priv,struct v4l2_selection * sel)683 static int vidioc_s_selection(struct file *file, void *priv,
684 struct v4l2_selection *sel)
685 {
686 struct hantro_ctx *ctx = fh_to_ctx(priv);
687 struct v4l2_rect *rect = &sel->r;
688 struct vb2_queue *vq;
689
690 /* Crop only supported on source. */
691 if (!ctx->is_encoder ||
692 sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
693 return -EINVAL;
694
695 /* Change not allowed if the queue is streaming. */
696 vq = v4l2_m2m_get_src_vq(ctx->fh.m2m_ctx);
697 if (vb2_is_streaming(vq))
698 return -EBUSY;
699
700 if (sel->target != V4L2_SEL_TGT_CROP)
701 return -EINVAL;
702
703 /*
704 * We do not support offsets, and we can crop only inside
705 * right-most or bottom-most macroblocks.
706 */
707 if (rect->left != 0 || rect->top != 0 ||
708 round_up(rect->width, MB_DIM) != ctx->src_fmt.width ||
709 round_up(rect->height, MB_DIM) != ctx->src_fmt.height) {
710 /* Default to full frame for incorrect settings. */
711 rect->left = 0;
712 rect->top = 0;
713 rect->width = ctx->src_fmt.width;
714 rect->height = ctx->src_fmt.height;
715 } else {
716 /* We support widths aligned to 4 pixels and arbitrary heights. */
717 rect->width = round_up(rect->width, 4);
718 }
719
720 ctx->dst_fmt.width = rect->width;
721 ctx->dst_fmt.height = rect->height;
722
723 return 0;
724 }
725
726 static const struct v4l2_event hantro_eos_event = {
727 .type = V4L2_EVENT_EOS
728 };
729
vidioc_encoder_cmd(struct file * file,void * priv,struct v4l2_encoder_cmd * ec)730 static int vidioc_encoder_cmd(struct file *file, void *priv,
731 struct v4l2_encoder_cmd *ec)
732 {
733 struct hantro_ctx *ctx = fh_to_ctx(priv);
734 int ret;
735
736 ret = v4l2_m2m_ioctl_try_encoder_cmd(file, priv, ec);
737 if (ret < 0)
738 return ret;
739
740 if (!vb2_is_streaming(v4l2_m2m_get_src_vq(ctx->fh.m2m_ctx)) ||
741 !vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx)))
742 return 0;
743
744 ret = v4l2_m2m_ioctl_encoder_cmd(file, priv, ec);
745 if (ret < 0)
746 return ret;
747
748 if (ec->cmd == V4L2_ENC_CMD_STOP &&
749 v4l2_m2m_has_stopped(ctx->fh.m2m_ctx))
750 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
751
752 if (ec->cmd == V4L2_ENC_CMD_START)
753 vb2_clear_last_buffer_dequeued(&ctx->fh.m2m_ctx->cap_q_ctx.q);
754
755 return 0;
756 }
757
758 const struct v4l2_ioctl_ops hantro_ioctl_ops = {
759 .vidioc_querycap = vidioc_querycap,
760 .vidioc_enum_framesizes = vidioc_enum_framesizes,
761
762 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_cap_mplane,
763 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_out_mplane,
764 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_out_mplane,
765 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_cap_mplane,
766 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_out_mplane,
767 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_cap_mplane,
768 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
769 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
770
771 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
772 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
773 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
774 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
775 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
776 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
777 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
778
779 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
780 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
781
782 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
783 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
784
785 .vidioc_g_selection = vidioc_g_selection,
786 .vidioc_s_selection = vidioc_s_selection,
787
788 .vidioc_decoder_cmd = v4l2_m2m_ioctl_stateless_decoder_cmd,
789 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_stateless_try_decoder_cmd,
790
791 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd,
792 .vidioc_encoder_cmd = vidioc_encoder_cmd,
793 };
794
795 static int
hantro_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])796 hantro_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
797 unsigned int *num_planes, unsigned int sizes[],
798 struct device *alloc_devs[])
799 {
800 struct hantro_ctx *ctx = vb2_get_drv_priv(vq);
801 struct v4l2_pix_format_mplane *pixfmt;
802 int i;
803
804 switch (vq->type) {
805 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
806 pixfmt = &ctx->dst_fmt;
807 break;
808 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
809 pixfmt = &ctx->src_fmt;
810 break;
811 default:
812 vpu_err("invalid queue type: %d\n", vq->type);
813 return -EINVAL;
814 }
815
816 if (*num_planes) {
817 if (*num_planes != pixfmt->num_planes)
818 return -EINVAL;
819 for (i = 0; i < pixfmt->num_planes; ++i)
820 if (sizes[i] < pixfmt->plane_fmt[i].sizeimage)
821 return -EINVAL;
822 return 0;
823 }
824
825 *num_planes = pixfmt->num_planes;
826 for (i = 0; i < pixfmt->num_planes; ++i)
827 sizes[i] = pixfmt->plane_fmt[i].sizeimage;
828 return 0;
829 }
830
831 static int
hantro_buf_plane_check(struct vb2_buffer * vb,struct v4l2_pix_format_mplane * pixfmt)832 hantro_buf_plane_check(struct vb2_buffer *vb,
833 struct v4l2_pix_format_mplane *pixfmt)
834 {
835 unsigned int sz;
836 int i;
837
838 for (i = 0; i < pixfmt->num_planes; ++i) {
839 sz = pixfmt->plane_fmt[i].sizeimage;
840 vpu_debug(4, "plane %d size: %ld, sizeimage: %u\n",
841 i, vb2_plane_size(vb, i), sz);
842 if (vb2_plane_size(vb, i) < sz) {
843 vpu_err("plane %d is too small for output\n", i);
844 return -EINVAL;
845 }
846 }
847 return 0;
848 }
849
hantro_buf_prepare(struct vb2_buffer * vb)850 static int hantro_buf_prepare(struct vb2_buffer *vb)
851 {
852 struct vb2_queue *vq = vb->vb2_queue;
853 struct hantro_ctx *ctx = vb2_get_drv_priv(vq);
854 struct v4l2_pix_format_mplane *pix_fmt;
855 int ret;
856
857 if (V4L2_TYPE_IS_OUTPUT(vq->type))
858 pix_fmt = &ctx->src_fmt;
859 else
860 pix_fmt = &ctx->dst_fmt;
861 ret = hantro_buf_plane_check(vb, pix_fmt);
862 if (ret)
863 return ret;
864 /*
865 * Buffer's bytesused must be written by driver for CAPTURE buffers.
866 * (for OUTPUT buffers, if userspace passes 0 bytesused, v4l2-core sets
867 * it to buffer length).
868 */
869 if (V4L2_TYPE_IS_CAPTURE(vq->type)) {
870 if (ctx->is_encoder)
871 vb2_set_plane_payload(vb, 0, 0);
872 else
873 vb2_set_plane_payload(vb, 0, pix_fmt->plane_fmt[0].sizeimage);
874 }
875
876 return 0;
877 }
878
hantro_buf_queue(struct vb2_buffer * vb)879 static void hantro_buf_queue(struct vb2_buffer *vb)
880 {
881 struct hantro_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
882 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
883
884 if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) &&
885 vb2_is_streaming(vb->vb2_queue) &&
886 v4l2_m2m_dst_buf_is_last(ctx->fh.m2m_ctx)) {
887 unsigned int i;
888
889 for (i = 0; i < vb->num_planes; i++)
890 vb2_set_plane_payload(vb, i, 0);
891
892 vbuf->field = V4L2_FIELD_NONE;
893 vbuf->sequence = ctx->sequence_cap++;
894
895 v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, vbuf);
896 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
897 return;
898 }
899
900 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
901 }
902
hantro_vq_is_coded(struct vb2_queue * q)903 static bool hantro_vq_is_coded(struct vb2_queue *q)
904 {
905 struct hantro_ctx *ctx = vb2_get_drv_priv(q);
906
907 return ctx->is_encoder != V4L2_TYPE_IS_OUTPUT(q->type);
908 }
909
hantro_start_streaming(struct vb2_queue * q,unsigned int count)910 static int hantro_start_streaming(struct vb2_queue *q, unsigned int count)
911 {
912 struct hantro_ctx *ctx = vb2_get_drv_priv(q);
913 int ret = 0;
914
915 v4l2_m2m_update_start_streaming_state(ctx->fh.m2m_ctx, q);
916
917 if (V4L2_TYPE_IS_OUTPUT(q->type))
918 ctx->sequence_out = 0;
919 else
920 ctx->sequence_cap = 0;
921
922 if (hantro_vq_is_coded(q)) {
923 enum hantro_codec_mode codec_mode;
924
925 if (V4L2_TYPE_IS_OUTPUT(q->type))
926 codec_mode = ctx->vpu_src_fmt->codec_mode;
927 else
928 codec_mode = ctx->vpu_dst_fmt->codec_mode;
929
930 vpu_debug(4, "Codec mode = %d\n", codec_mode);
931 ctx->codec_ops = &ctx->dev->variant->codec_ops[codec_mode];
932 if (ctx->codec_ops->init) {
933 ret = ctx->codec_ops->init(ctx);
934 if (ret)
935 return ret;
936 }
937
938 if (hantro_needs_postproc(ctx, ctx->vpu_dst_fmt)) {
939 ret = hantro_postproc_alloc(ctx);
940 if (ret)
941 goto err_codec_exit;
942 }
943 }
944 return ret;
945
946 err_codec_exit:
947 if (ctx->codec_ops->exit)
948 ctx->codec_ops->exit(ctx);
949 return ret;
950 }
951
952 static void
hantro_return_bufs(struct vb2_queue * q,struct vb2_v4l2_buffer * (* buf_remove)(struct v4l2_m2m_ctx *))953 hantro_return_bufs(struct vb2_queue *q,
954 struct vb2_v4l2_buffer *(*buf_remove)(struct v4l2_m2m_ctx *))
955 {
956 struct hantro_ctx *ctx = vb2_get_drv_priv(q);
957
958 for (;;) {
959 struct vb2_v4l2_buffer *vbuf;
960
961 vbuf = buf_remove(ctx->fh.m2m_ctx);
962 if (!vbuf)
963 break;
964 v4l2_ctrl_request_complete(vbuf->vb2_buf.req_obj.req,
965 &ctx->ctrl_handler);
966 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
967 }
968 }
969
hantro_stop_streaming(struct vb2_queue * q)970 static void hantro_stop_streaming(struct vb2_queue *q)
971 {
972 struct hantro_ctx *ctx = vb2_get_drv_priv(q);
973
974 if (hantro_vq_is_coded(q)) {
975 hantro_postproc_free(ctx);
976 if (ctx->codec_ops && ctx->codec_ops->exit)
977 ctx->codec_ops->exit(ctx);
978 }
979
980 /*
981 * The mem2mem framework calls v4l2_m2m_cancel_job before
982 * .stop_streaming, so there isn't any job running and
983 * it is safe to return all the buffers.
984 */
985 if (V4L2_TYPE_IS_OUTPUT(q->type))
986 hantro_return_bufs(q, v4l2_m2m_src_buf_remove);
987 else
988 hantro_return_bufs(q, v4l2_m2m_dst_buf_remove);
989
990 v4l2_m2m_update_stop_streaming_state(ctx->fh.m2m_ctx, q);
991
992 if (V4L2_TYPE_IS_OUTPUT(q->type) &&
993 v4l2_m2m_has_stopped(ctx->fh.m2m_ctx))
994 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
995 }
996
hantro_buf_request_complete(struct vb2_buffer * vb)997 static void hantro_buf_request_complete(struct vb2_buffer *vb)
998 {
999 struct hantro_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1000
1001 v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->ctrl_handler);
1002 }
1003
hantro_buf_out_validate(struct vb2_buffer * vb)1004 static int hantro_buf_out_validate(struct vb2_buffer *vb)
1005 {
1006 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1007
1008 vbuf->field = V4L2_FIELD_NONE;
1009 return 0;
1010 }
1011
1012 const struct vb2_ops hantro_queue_ops = {
1013 .queue_setup = hantro_queue_setup,
1014 .buf_prepare = hantro_buf_prepare,
1015 .buf_queue = hantro_buf_queue,
1016 .buf_out_validate = hantro_buf_out_validate,
1017 .buf_request_complete = hantro_buf_request_complete,
1018 .start_streaming = hantro_start_streaming,
1019 .stop_streaming = hantro_stop_streaming,
1020 .wait_prepare = vb2_ops_wait_prepare,
1021 .wait_finish = vb2_ops_wait_finish,
1022 };
1023