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