1969 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) STMicroelectronics SA 20154 * Authors: Hugues Fruchet <hugues.fruchet@st.com>5 * Jean-Christophe Trotin <jean-christophe.trotin@st.com>6 * for STMicroelectronics.7 */8 9#include <linux/clk.h>10#include <linux/module.h>11#include <linux/platform_device.h>12#include <linux/pm_runtime.h>13#include <linux/slab.h>14 15#include <media/v4l2-ioctl.h>16#include <media/v4l2-event.h>17#include <media/videobuf2-dma-contig.h>18 19#include "delta.h"20#include "delta-debug.h"21#include "delta-ipc.h"22 23#define DELTA_NAME "st-delta"24 25#define DELTA_PREFIX "[---:----]"26 27#define to_ctx(__fh) container_of(__fh, struct delta_ctx, fh)28#define to_au(__vbuf) container_of(__vbuf, struct delta_au, vbuf)29#define to_frame(__vbuf) container_of(__vbuf, struct delta_frame, vbuf)30 31#define call_dec_op(dec, op, args...)\32 ((dec && (dec)->op) ? (dec)->op(args) : 0)33 34/* registry of available decoders */35static const struct delta_dec *delta_decoders[] = {36#ifdef CONFIG_VIDEO_STI_DELTA_MJPEG37 &mjpegdec,38#endif39};40 41static inline int frame_size(u32 w, u32 h, u32 fmt)42{43 switch (fmt) {44 case V4L2_PIX_FMT_NV12:45 return (w * h * 3) / 2;46 default:47 return 0;48 }49}50 51static inline int frame_stride(u32 w, u32 fmt)52{53 switch (fmt) {54 case V4L2_PIX_FMT_NV12:55 return w;56 default:57 return 0;58 }59}60 61static void dump_au(struct delta_ctx *ctx, struct delta_au *au)62{63 struct delta_dev *delta = ctx->dev;64 u32 size = 10; /* dump first & last 10 bytes */65 u8 *data = (u8 *)(au->vaddr);66 67 if (au->size <= (size * 2))68 dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph\n",69 ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,70 au->size, data);71 else72 dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph..%*ph\n",73 ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,74 size, data, size, data + au->size - size);75}76 77static void dump_frame(struct delta_ctx *ctx, struct delta_frame *frame)78{79 struct delta_dev *delta = ctx->dev;80 u32 size = 10; /* dump first 10 bytes */81 u8 *data = (u8 *)(frame->vaddr);82 83 dev_dbg(delta->dev, "%s dump frame[%d] dts=%lld type=%s field=%s data=%*ph\n",84 ctx->name, frame->index, frame->dts,85 frame_type_str(frame->flags),86 frame_field_str(frame->field),87 size, data);88}89 90static void delta_au_done(struct delta_ctx *ctx, struct delta_au *au, int err)91{92 struct vb2_v4l2_buffer *vbuf;93 94 vbuf = &au->vbuf;95 vbuf->sequence = ctx->au_num++;96 v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);97}98 99static void delta_frame_done(struct delta_ctx *ctx, struct delta_frame *frame,100 int err)101{102 struct vb2_v4l2_buffer *vbuf;103 104 dump_frame(ctx, frame);105 106 /* decoded frame is now output to user */107 frame->state |= DELTA_FRAME_OUT;108 109 vbuf = &frame->vbuf;110 vbuf->sequence = ctx->frame_num++;111 v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);112 113 if (frame->info.size) /* ignore EOS */114 ctx->output_frames++;115}116 117static void requeue_free_frames(struct delta_ctx *ctx)118{119 struct vb2_v4l2_buffer *vbuf;120 struct delta_frame *frame;121 unsigned int i;122 123 /* requeue all free frames */124 for (i = 0; i < ctx->nb_of_frames; i++) {125 frame = ctx->frames[i];126 if (frame->state == DELTA_FRAME_FREE) {127 vbuf = &frame->vbuf;128 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);129 frame->state = DELTA_FRAME_M2M;130 }131 }132}133 134static int delta_recycle(struct delta_ctx *ctx, struct delta_frame *frame)135{136 const struct delta_dec *dec = ctx->dec;137 138 /* recycle frame on decoder side */139 call_dec_op(dec, recycle, ctx, frame);140 141 /* this frame is no more output */142 frame->state &= ~DELTA_FRAME_OUT;143 144 /* requeue free frame */145 if (frame->state == DELTA_FRAME_FREE) {146 struct vb2_v4l2_buffer *vbuf = &frame->vbuf;147 148 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);149 frame->state = DELTA_FRAME_M2M;150 }151 152 /* reset other frame fields */153 frame->flags = 0;154 frame->dts = 0;155 156 return 0;157}158 159static void delta_push_dts(struct delta_ctx *ctx, u64 val)160{161 struct delta_dts *dts;162 163 dts = kzalloc(sizeof(*dts), GFP_KERNEL);164 if (!dts)165 return;166 167 INIT_LIST_HEAD(&dts->list);168 169 /*170 * protected by global lock acquired171 * by V4L2 when calling delta_vb2_au_queue172 */173 dts->val = val;174 list_add_tail(&dts->list, &ctx->dts);175}176 177static void delta_pop_dts(struct delta_ctx *ctx, u64 *val)178{179 struct delta_dev *delta = ctx->dev;180 struct delta_dts *dts;181 182 /*183 * protected by global lock acquired184 * by V4L2 when calling delta_vb2_au_queue185 */186 if (list_empty(&ctx->dts)) {187 dev_warn(delta->dev, "%s no dts to pop ... output dts = 0\n",188 ctx->name);189 *val = 0;190 return;191 }192 193 dts = list_first_entry(&ctx->dts, struct delta_dts, list);194 list_del(&dts->list);195 196 *val = dts->val;197 198 kfree(dts);199}200 201static void delta_flush_dts(struct delta_ctx *ctx)202{203 struct delta_dts *dts;204 struct delta_dts *next;205 206 /*207 * protected by global lock acquired208 * by V4L2 when calling delta_vb2_au_queue209 */210 211 /* free all pending dts */212 list_for_each_entry_safe(dts, next, &ctx->dts, list)213 kfree(dts);214 215 /* reset list */216 INIT_LIST_HEAD(&ctx->dts);217}218 219static inline int frame_alignment(u32 fmt)220{221 switch (fmt) {222 case V4L2_PIX_FMT_NV12:223 case V4L2_PIX_FMT_NV21:224 /* multiple of 2 */225 return 2;226 default:227 return 1;228 }229}230 231static inline int estimated_au_size(u32 w, u32 h)232{233 /*234 * for a MJPEG stream encoded from YUV422 pixel format,235 * assuming a compression ratio of 2, the maximum size236 * of an access unit is (width x height x 2) / 2,237 * so (width x height)238 */239 return (w * h);240}241 242static void set_default_params(struct delta_ctx *ctx)243{244 struct delta_frameinfo *frameinfo = &ctx->frameinfo;245 struct delta_streaminfo *streaminfo = &ctx->streaminfo;246 247 memset(frameinfo, 0, sizeof(*frameinfo));248 frameinfo->pixelformat = V4L2_PIX_FMT_NV12;249 frameinfo->width = DELTA_DEFAULT_WIDTH;250 frameinfo->height = DELTA_DEFAULT_HEIGHT;251 frameinfo->aligned_width = ALIGN(frameinfo->width,252 DELTA_WIDTH_ALIGNMENT);253 frameinfo->aligned_height = ALIGN(frameinfo->height,254 DELTA_HEIGHT_ALIGNMENT);255 frameinfo->size = frame_size(frameinfo->aligned_width,256 frameinfo->aligned_height,257 frameinfo->pixelformat);258 frameinfo->field = V4L2_FIELD_NONE;259 frameinfo->colorspace = V4L2_COLORSPACE_REC709;260 frameinfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;261 frameinfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;262 frameinfo->quantization = V4L2_QUANTIZATION_DEFAULT;263 264 memset(streaminfo, 0, sizeof(*streaminfo));265 streaminfo->streamformat = DELTA_DEFAULT_STREAMFORMAT;266 streaminfo->width = DELTA_DEFAULT_WIDTH;267 streaminfo->height = DELTA_DEFAULT_HEIGHT;268 streaminfo->field = V4L2_FIELD_NONE;269 streaminfo->colorspace = V4L2_COLORSPACE_REC709;270 streaminfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;271 streaminfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;272 streaminfo->quantization = V4L2_QUANTIZATION_DEFAULT;273 274 ctx->max_au_size = estimated_au_size(streaminfo->width,275 streaminfo->height);276}277 278static const struct delta_dec *delta_find_decoder(struct delta_ctx *ctx,279 u32 streamformat,280 u32 pixelformat)281{282 struct delta_dev *delta = ctx->dev;283 const struct delta_dec *dec;284 unsigned int i;285 286 for (i = 0; i < delta->nb_of_decoders; i++) {287 dec = delta->decoders[i];288 if ((dec->pixelformat == pixelformat) &&289 (dec->streamformat == streamformat))290 return dec;291 }292 293 return NULL;294}295 296static void register_format(u32 format, u32 formats[], u32 *nb_of_formats)297{298 u32 i;299 300 for (i = 0; i < *nb_of_formats; i++) {301 if (format == formats[i])302 return;303 }304 305 formats[(*nb_of_formats)++] = format;306}307 308static void register_formats(struct delta_dev *delta)309{310 unsigned int i;311 312 for (i = 0; i < delta->nb_of_decoders; i++) {313 register_format(delta->decoders[i]->pixelformat,314 delta->pixelformats,315 &delta->nb_of_pixelformats);316 317 register_format(delta->decoders[i]->streamformat,318 delta->streamformats,319 &delta->nb_of_streamformats);320 }321}322 323static void register_decoders(struct delta_dev *delta)324{325 unsigned int i;326 327 for (i = 0; i < ARRAY_SIZE(delta_decoders); i++) {328 if (delta->nb_of_decoders >= DELTA_MAX_DECODERS) {329 dev_dbg(delta->dev,330 "%s failed to register %s decoder (%d maximum reached)\n",331 DELTA_PREFIX, delta_decoders[i]->name,332 DELTA_MAX_DECODERS);333 return;334 }335 336 delta->decoders[delta->nb_of_decoders++] = delta_decoders[i];337 dev_info(delta->dev, "%s %s decoder registered\n",338 DELTA_PREFIX, delta_decoders[i]->name);339 }340}341 342static int delta_open_decoder(struct delta_ctx *ctx, u32 streamformat,343 u32 pixelformat, const struct delta_dec **pdec)344{345 struct delta_dev *delta = ctx->dev;346 const struct delta_dec *dec;347 int ret;348 349 dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);350 if (!dec) {351 dev_err(delta->dev, "%s no decoder found matching %4.4s => %4.4s\n",352 ctx->name, (char *)&streamformat, (char *)&pixelformat);353 return -EINVAL;354 }355 356 dev_dbg(delta->dev, "%s one decoder matching %4.4s => %4.4s\n",357 ctx->name, (char *)&streamformat, (char *)&pixelformat);358 359 /* update instance name */360 snprintf(ctx->name, sizeof(ctx->name), "[%3d:%4.4s]",361 delta->instance_id, (char *)&streamformat);362 363 /* open decoder instance */364 ret = call_dec_op(dec, open, ctx);365 if (ret) {366 dev_err(delta->dev, "%s failed to open decoder instance (%d)\n",367 ctx->name, ret);368 return ret;369 }370 371 dev_dbg(delta->dev, "%s %s decoder opened\n", ctx->name, dec->name);372 373 *pdec = dec;374 375 return ret;376}377 378/*379 * V4L2 ioctl operations380 */381 382static int delta_querycap(struct file *file, void *priv,383 struct v4l2_capability *cap)384{385 struct delta_ctx *ctx = to_ctx(file->private_data);386 struct delta_dev *delta = ctx->dev;387 388 strscpy(cap->driver, DELTA_NAME, sizeof(cap->driver));389 strscpy(cap->card, delta->vdev->name, sizeof(cap->card));390 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",391 delta->pdev->name);392 393 return 0;394}395 396static int delta_enum_fmt_stream(struct file *file, void *priv,397 struct v4l2_fmtdesc *f)398{399 struct delta_ctx *ctx = to_ctx(file->private_data);400 struct delta_dev *delta = ctx->dev;401 402 if (unlikely(f->index >= delta->nb_of_streamformats))403 return -EINVAL;404 405 f->pixelformat = delta->streamformats[f->index];406 407 return 0;408}409 410static int delta_enum_fmt_frame(struct file *file, void *priv,411 struct v4l2_fmtdesc *f)412{413 struct delta_ctx *ctx = to_ctx(file->private_data);414 struct delta_dev *delta = ctx->dev;415 416 if (unlikely(f->index >= delta->nb_of_pixelformats))417 return -EINVAL;418 419 f->pixelformat = delta->pixelformats[f->index];420 421 return 0;422}423 424static int delta_g_fmt_stream(struct file *file, void *fh,425 struct v4l2_format *f)426{427 struct delta_ctx *ctx = to_ctx(file->private_data);428 struct delta_dev *delta = ctx->dev;429 struct v4l2_pix_format *pix = &f->fmt.pix;430 struct delta_streaminfo *streaminfo = &ctx->streaminfo;431 unsigned char str[100] = "";432 433 if (!(ctx->flags & DELTA_FLAG_STREAMINFO))434 dev_dbg(delta->dev,435 "%s V4L2 GET_FMT (OUTPUT): no stream information available, default to %s\n",436 ctx->name,437 delta_streaminfo_str(streaminfo, str, sizeof(str)));438 439 pix->pixelformat = streaminfo->streamformat;440 pix->width = streaminfo->width;441 pix->height = streaminfo->height;442 pix->field = streaminfo->field;443 pix->bytesperline = 0;444 pix->sizeimage = ctx->max_au_size;445 pix->colorspace = streaminfo->colorspace;446 pix->xfer_func = streaminfo->xfer_func;447 pix->ycbcr_enc = streaminfo->ycbcr_enc;448 pix->quantization = streaminfo->quantization;449 450 return 0;451}452 453static int delta_g_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)454{455 struct delta_ctx *ctx = to_ctx(file->private_data);456 struct delta_dev *delta = ctx->dev;457 struct v4l2_pix_format *pix = &f->fmt.pix;458 struct delta_frameinfo *frameinfo = &ctx->frameinfo;459 struct delta_streaminfo *streaminfo = &ctx->streaminfo;460 unsigned char str[100] = "";461 462 if (!(ctx->flags & DELTA_FLAG_FRAMEINFO))463 dev_dbg(delta->dev,464 "%s V4L2 GET_FMT (CAPTURE): no frame information available, default to %s\n",465 ctx->name,466 delta_frameinfo_str(frameinfo, str, sizeof(str)));467 468 pix->pixelformat = frameinfo->pixelformat;469 pix->width = frameinfo->aligned_width;470 pix->height = frameinfo->aligned_height;471 pix->field = frameinfo->field;472 pix->bytesperline = frame_stride(frameinfo->aligned_width,473 frameinfo->pixelformat);474 pix->sizeimage = frameinfo->size;475 476 if (ctx->flags & DELTA_FLAG_STREAMINFO) {477 /* align colorspace & friends on stream ones if any set */478 frameinfo->colorspace = streaminfo->colorspace;479 frameinfo->xfer_func = streaminfo->xfer_func;480 frameinfo->ycbcr_enc = streaminfo->ycbcr_enc;481 frameinfo->quantization = streaminfo->quantization;482 }483 pix->colorspace = frameinfo->colorspace;484 pix->xfer_func = frameinfo->xfer_func;485 pix->ycbcr_enc = frameinfo->ycbcr_enc;486 pix->quantization = frameinfo->quantization;487 488 return 0;489}490 491static int delta_try_fmt_stream(struct file *file, void *priv,492 struct v4l2_format *f)493{494 struct delta_ctx *ctx = to_ctx(file->private_data);495 struct delta_dev *delta = ctx->dev;496 struct v4l2_pix_format *pix = &f->fmt.pix;497 u32 streamformat = pix->pixelformat;498 const struct delta_dec *dec;499 u32 width, height;500 u32 au_size;501 502 dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);503 if (!dec) {504 dev_dbg(delta->dev,505 "%s V4L2 TRY_FMT (OUTPUT): unsupported format %4.4s\n",506 ctx->name, (char *)&pix->pixelformat);507 return -EINVAL;508 }509 510 /* adjust width & height */511 width = pix->width;512 height = pix->height;513 v4l_bound_align_image514 (&pix->width,515 DELTA_MIN_WIDTH,516 dec->max_width ? dec->max_width : DELTA_MAX_WIDTH,517 0,518 &pix->height,519 DELTA_MIN_HEIGHT,520 dec->max_height ? dec->max_height : DELTA_MAX_HEIGHT,521 0, 0);522 523 if ((pix->width != width) || (pix->height != height))524 dev_dbg(delta->dev,525 "%s V4L2 TRY_FMT (OUTPUT): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",526 ctx->name, width, height,527 pix->width, pix->height);528 529 au_size = estimated_au_size(pix->width, pix->height);530 if (pix->sizeimage < au_size) {531 dev_dbg(delta->dev,532 "%s V4L2 TRY_FMT (OUTPUT): size updated %d -> %d to fit estimated size\n",533 ctx->name, pix->sizeimage, au_size);534 pix->sizeimage = au_size;535 }536 537 pix->bytesperline = 0;538 539 if (pix->field == V4L2_FIELD_ANY)540 pix->field = V4L2_FIELD_NONE;541 542 return 0;543}544 545static int delta_try_fmt_frame(struct file *file, void *priv,546 struct v4l2_format *f)547{548 struct delta_ctx *ctx = to_ctx(file->private_data);549 struct delta_dev *delta = ctx->dev;550 struct v4l2_pix_format *pix = &f->fmt.pix;551 u32 pixelformat = pix->pixelformat;552 const struct delta_dec *dec;553 u32 width, height;554 555 dec = delta_find_decoder(ctx, ctx->streaminfo.streamformat,556 pixelformat);557 if (!dec) {558 dev_dbg(delta->dev,559 "%s V4L2 TRY_FMT (CAPTURE): unsupported format %4.4s\n",560 ctx->name, (char *)&pixelformat);561 return -EINVAL;562 }563 564 /* adjust width & height */565 width = pix->width;566 height = pix->height;567 v4l_bound_align_image(&pix->width,568 DELTA_MIN_WIDTH, DELTA_MAX_WIDTH,569 frame_alignment(pixelformat) - 1,570 &pix->height,571 DELTA_MIN_HEIGHT, DELTA_MAX_HEIGHT,572 frame_alignment(pixelformat) - 1, 0);573 574 if ((pix->width != width) || (pix->height != height))575 dev_dbg(delta->dev,576 "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",577 ctx->name, width, height, pix->width, pix->height);578 579 /* default decoder alignment constraint */580 width = ALIGN(pix->width, DELTA_WIDTH_ALIGNMENT);581 height = ALIGN(pix->height, DELTA_HEIGHT_ALIGNMENT);582 if ((pix->width != width) || (pix->height != height))583 dev_dbg(delta->dev,584 "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit decoder alignment\n",585 ctx->name, width, height, pix->width, pix->height);586 587 if (!pix->colorspace) {588 pix->colorspace = V4L2_COLORSPACE_REC709;589 pix->xfer_func = V4L2_XFER_FUNC_DEFAULT;590 pix->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;591 pix->quantization = V4L2_QUANTIZATION_DEFAULT;592 }593 594 pix->width = width;595 pix->height = height;596 pix->bytesperline = frame_stride(pix->width, pixelformat);597 pix->sizeimage = frame_size(pix->width, pix->height, pixelformat);598 599 if (pix->field == V4L2_FIELD_ANY)600 pix->field = V4L2_FIELD_NONE;601 602 return 0;603}604 605static int delta_s_fmt_stream(struct file *file, void *fh,606 struct v4l2_format *f)607{608 struct delta_ctx *ctx = to_ctx(file->private_data);609 struct delta_dev *delta = ctx->dev;610 struct vb2_queue *vq;611 struct v4l2_pix_format *pix = &f->fmt.pix;612 int ret;613 614 ret = delta_try_fmt_stream(file, fh, f);615 if (ret) {616 dev_dbg(delta->dev,617 "%s V4L2 S_FMT (OUTPUT): unsupported format %4.4s\n",618 ctx->name, (char *)&pix->pixelformat);619 return ret;620 }621 622 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);623 if (vb2_is_streaming(vq)) {624 dev_dbg(delta->dev, "%s V4L2 S_FMT (OUTPUT): queue busy\n",625 ctx->name);626 return -EBUSY;627 }628 629 ctx->max_au_size = pix->sizeimage;630 ctx->streaminfo.width = pix->width;631 ctx->streaminfo.height = pix->height;632 ctx->streaminfo.streamformat = pix->pixelformat;633 ctx->streaminfo.colorspace = pix->colorspace;634 ctx->streaminfo.xfer_func = pix->xfer_func;635 ctx->streaminfo.ycbcr_enc = pix->ycbcr_enc;636 ctx->streaminfo.quantization = pix->quantization;637 ctx->flags |= DELTA_FLAG_STREAMINFO;638 639 return 0;640}641 642static int delta_s_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)643{644 struct delta_ctx *ctx = to_ctx(file->private_data);645 struct delta_dev *delta = ctx->dev;646 const struct delta_dec *dec = ctx->dec;647 struct v4l2_pix_format *pix = &f->fmt.pix;648 struct delta_frameinfo frameinfo;649 unsigned char str[100] = "";650 struct vb2_queue *vq;651 int ret;652 653 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);654 if (vb2_is_streaming(vq)) {655 dev_dbg(delta->dev, "%s V4L2 S_FMT (CAPTURE): queue busy\n",656 ctx->name);657 return -EBUSY;658 }659 660 if (ctx->state < DELTA_STATE_READY) {661 /*662 * decoder not yet opened and valid stream header not found,663 * could not negotiate format with decoder, check at least664 * pixel format & negotiate resolution boundaries665 * and alignment...666 */667 ret = delta_try_fmt_frame(file, fh, f);668 if (ret) {669 dev_dbg(delta->dev,670 "%s V4L2 S_FMT (CAPTURE): unsupported format %4.4s\n",671 ctx->name, (char *)&pix->pixelformat);672 return ret;673 }674 675 return 0;676 }677 678 /* set frame information to decoder */679 memset(&frameinfo, 0, sizeof(frameinfo));680 frameinfo.pixelformat = pix->pixelformat;681 frameinfo.width = pix->width;682 frameinfo.height = pix->height;683 frameinfo.aligned_width = pix->width;684 frameinfo.aligned_height = pix->height;685 frameinfo.size = pix->sizeimage;686 frameinfo.field = pix->field;687 frameinfo.colorspace = pix->colorspace;688 frameinfo.xfer_func = pix->xfer_func;689 frameinfo.ycbcr_enc = pix->ycbcr_enc;690 frameinfo.quantization = pix->quantization;691 ret = call_dec_op(dec, set_frameinfo, ctx, &frameinfo);692 if (ret)693 return ret;694 695 /* then get what decoder can really do */696 ret = call_dec_op(dec, get_frameinfo, ctx, &frameinfo);697 if (ret)698 return ret;699 700 ctx->flags |= DELTA_FLAG_FRAMEINFO;701 ctx->frameinfo = frameinfo;702 dev_dbg(delta->dev,703 "%s V4L2 SET_FMT (CAPTURE): frameinfo updated to %s\n",704 ctx->name,705 delta_frameinfo_str(&frameinfo, str, sizeof(str)));706 707 pix->pixelformat = frameinfo.pixelformat;708 pix->width = frameinfo.aligned_width;709 pix->height = frameinfo.aligned_height;710 pix->bytesperline = frame_stride(pix->width, pix->pixelformat);711 pix->sizeimage = frameinfo.size;712 pix->field = frameinfo.field;713 pix->colorspace = frameinfo.colorspace;714 pix->xfer_func = frameinfo.xfer_func;715 pix->ycbcr_enc = frameinfo.ycbcr_enc;716 pix->quantization = frameinfo.quantization;717 718 return 0;719}720 721static int delta_g_selection(struct file *file, void *fh,722 struct v4l2_selection *s)723{724 struct delta_ctx *ctx = to_ctx(fh);725 struct delta_frameinfo *frameinfo = &ctx->frameinfo;726 struct v4l2_rect crop;727 728 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)729 return -EINVAL;730 731 if ((ctx->flags & DELTA_FLAG_FRAMEINFO) &&732 (frameinfo->flags & DELTA_FRAMEINFO_FLAG_CROP)) {733 crop = frameinfo->crop;734 } else {735 /* default to video dimensions */736 crop.left = 0;737 crop.top = 0;738 crop.width = frameinfo->width;739 crop.height = frameinfo->height;740 }741 742 switch (s->target) {743 case V4L2_SEL_TGT_COMPOSE:744 case V4L2_SEL_TGT_COMPOSE_DEFAULT:745 /* visible area inside video */746 s->r = crop;747 break;748 case V4L2_SEL_TGT_COMPOSE_PADDED:749 case V4L2_SEL_TGT_COMPOSE_BOUNDS:750 /* up to aligned dimensions */751 s->r.left = 0;752 s->r.top = 0;753 s->r.width = frameinfo->aligned_width;754 s->r.height = frameinfo->aligned_height;755 break;756 default:757 return -EINVAL;758 }759 760 return 0;761}762 763static void delta_complete_eos(struct delta_ctx *ctx,764 struct delta_frame *frame)765{766 struct delta_dev *delta = ctx->dev;767 const struct v4l2_event ev = {.type = V4L2_EVENT_EOS};768 769 /*770 * Send EOS to user:771 * - by returning an empty frame flagged to V4L2_BUF_FLAG_LAST772 * - and then send EOS event773 */774 775 /* empty frame */776 frame->info.size = 0;777 778 /* set the last buffer flag */779 frame->flags |= V4L2_BUF_FLAG_LAST;780 781 /* release frame to user */782 delta_frame_done(ctx, frame, 0);783 784 /* send EOS event */785 v4l2_event_queue_fh(&ctx->fh, &ev);786 787 dev_dbg(delta->dev, "%s EOS completed\n", ctx->name);788}789 790static int delta_try_decoder_cmd(struct file *file, void *fh,791 struct v4l2_decoder_cmd *cmd)792{793 if (cmd->cmd != V4L2_DEC_CMD_STOP)794 return -EINVAL;795 796 if (cmd->flags & V4L2_DEC_CMD_STOP_TO_BLACK)797 return -EINVAL;798 799 if (!(cmd->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) &&800 (cmd->stop.pts != 0))801 return -EINVAL;802 803 return 0;804}805 806static int delta_decoder_stop_cmd(struct delta_ctx *ctx, void *fh)807{808 const struct delta_dec *dec = ctx->dec;809 struct delta_dev *delta = ctx->dev;810 struct delta_frame *frame = NULL;811 int ret = 0;812 813 dev_dbg(delta->dev, "%s EOS received\n", ctx->name);814 815 if (ctx->state != DELTA_STATE_READY)816 return 0;817 818 /* drain the decoder */819 call_dec_op(dec, drain, ctx);820 821 /* release to user drained frames */822 while (1) {823 frame = NULL;824 ret = call_dec_op(dec, get_frame, ctx, &frame);825 if (ret == -ENODATA) {826 /* no more decoded frames */827 break;828 }829 if (frame) {830 dev_dbg(delta->dev, "%s drain frame[%d]\n",831 ctx->name, frame->index);832 833 /* pop timestamp and mark frame with it */834 delta_pop_dts(ctx, &frame->dts);835 836 /* release decoded frame to user */837 delta_frame_done(ctx, frame, 0);838 }839 }840 841 /* try to complete EOS */842 ret = delta_get_free_frame(ctx, &frame);843 if (ret)844 goto delay_eos;845 846 /* new frame available, EOS can now be completed */847 delta_complete_eos(ctx, frame);848 849 ctx->state = DELTA_STATE_EOS;850 851 return 0;852 853delay_eos:854 /*855 * EOS completion from driver is delayed because856 * we don't have a free empty frame available.857 * EOS completion is so delayed till next frame_queue() call858 * to be sure to have a free empty frame available.859 */860 ctx->state = DELTA_STATE_WF_EOS;861 dev_dbg(delta->dev, "%s EOS delayed\n", ctx->name);862 863 return 0;864}865 866static int delta_decoder_cmd(struct file *file, void *fh,867 struct v4l2_decoder_cmd *cmd)868{869 struct delta_ctx *ctx = to_ctx(fh);870 int ret = 0;871 872 ret = delta_try_decoder_cmd(file, fh, cmd);873 if (ret)874 return ret;875 876 return delta_decoder_stop_cmd(ctx, fh);877}878 879static int delta_subscribe_event(struct v4l2_fh *fh,880 const struct v4l2_event_subscription *sub)881{882 switch (sub->type) {883 case V4L2_EVENT_EOS:884 return v4l2_event_subscribe(fh, sub, 2, NULL);885 default:886 return -EINVAL;887 }888 889 return 0;890}891 892/* v4l2 ioctl ops */893static const struct v4l2_ioctl_ops delta_ioctl_ops = {894 .vidioc_querycap = delta_querycap,895 .vidioc_enum_fmt_vid_cap = delta_enum_fmt_frame,896 .vidioc_g_fmt_vid_cap = delta_g_fmt_frame,897 .vidioc_try_fmt_vid_cap = delta_try_fmt_frame,898 .vidioc_s_fmt_vid_cap = delta_s_fmt_frame,899 .vidioc_enum_fmt_vid_out = delta_enum_fmt_stream,900 .vidioc_g_fmt_vid_out = delta_g_fmt_stream,901 .vidioc_try_fmt_vid_out = delta_try_fmt_stream,902 .vidioc_s_fmt_vid_out = delta_s_fmt_stream,903 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,904 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,905 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,906 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,907 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,908 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,909 .vidioc_streamon = v4l2_m2m_ioctl_streamon,910 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,911 .vidioc_g_selection = delta_g_selection,912 .vidioc_try_decoder_cmd = delta_try_decoder_cmd,913 .vidioc_decoder_cmd = delta_decoder_cmd,914 .vidioc_subscribe_event = delta_subscribe_event,915 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,916};917 918/*919 * mem-to-mem operations920 */921 922static void delta_run_work(struct work_struct *work)923{924 struct delta_ctx *ctx = container_of(work, struct delta_ctx, run_work);925 struct delta_dev *delta = ctx->dev;926 const struct delta_dec *dec = ctx->dec;927 struct delta_au *au;928 struct delta_frame *frame = NULL;929 int ret = 0;930 bool discard = false;931 struct vb2_v4l2_buffer *vbuf;932 933 if (!dec) {934 dev_err(delta->dev, "%s no decoder opened yet\n", ctx->name);935 return;936 }937 938 /* protect instance against reentrancy */939 mutex_lock(&ctx->lock);940 941 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);942 if (!vbuf) {943 dev_err(delta->dev, "%s no buffer to decode\n", ctx->name);944 mutex_unlock(&ctx->lock);945 return;946 }947 au = to_au(vbuf);948 au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);949 au->dts = vbuf->vb2_buf.timestamp;950 951 /* dump access unit */952 dump_au(ctx, au);953 954 /* enable the hardware */955 if (!dec->pm) {956 ret = delta_get_sync(ctx);957 if (ret)958 goto err;959 }960 961 /* decode this access unit */962 ret = call_dec_op(dec, decode, ctx, au);963 964 /*965 * if the (-ENODATA) value is returned, it refers to the interlaced966 * stream case for which 2 access units are needed to get 1 frame.967 * So, this returned value doesn't mean that the decoding fails, but968 * indicates that the timestamp information of the access unit shall969 * not be taken into account, and that the V4L2 buffer associated with970 * the access unit shall be flagged with V4L2_BUF_FLAG_ERROR to inform971 * the user of this situation972 */973 if (ret == -ENODATA) {974 discard = true;975 } else if (ret) {976 dev_err(delta->dev, "%s decoding failed (%d)\n",977 ctx->name, ret);978 979 /* disable the hardware */980 if (!dec->pm)981 delta_put_autosuspend(ctx);982 983 goto err;984 }985 986 /* disable the hardware */987 if (!dec->pm)988 delta_put_autosuspend(ctx);989 990 /* push au timestamp in FIFO */991 if (!discard)992 delta_push_dts(ctx, au->dts);993 994 /* get available decoded frames */995 while (1) {996 ret = call_dec_op(dec, get_frame, ctx, &frame);997 if (ret == -ENODATA) {998 /* no more decoded frames */999 goto out;1000 }1001 if (ret) {1002 dev_err(delta->dev, "%s cannot get decoded frame (%d)\n",1003 ctx->name, ret);1004 goto out;1005 }1006 if (!frame) {1007 dev_err(delta->dev,1008 "%s NULL decoded frame\n",1009 ctx->name);1010 goto out;1011 }1012 1013 /* pop timestamp and mark frame with it */1014 delta_pop_dts(ctx, &frame->dts);1015 1016 /* release decoded frame to user */1017 delta_frame_done(ctx, frame, 0);1018 }1019 1020out:1021 requeue_free_frames(ctx);1022 delta_au_done(ctx, au, (discard ? -ENODATA : 0));1023 mutex_unlock(&ctx->lock);1024 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);1025 return;1026 1027err:1028 requeue_free_frames(ctx);1029 delta_au_done(ctx, au, ret);1030 mutex_unlock(&ctx->lock);1031 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);1032}1033 1034static void delta_device_run(void *priv)1035{1036 struct delta_ctx *ctx = priv;1037 struct delta_dev *delta = ctx->dev;1038 1039 queue_work(delta->work_queue, &ctx->run_work);1040}1041 1042static void delta_job_abort(void *priv)1043{1044 struct delta_ctx *ctx = priv;1045 struct delta_dev *delta = ctx->dev;1046 1047 dev_dbg(delta->dev, "%s aborting job\n", ctx->name);1048 1049 ctx->aborting = true;1050}1051 1052static int delta_job_ready(void *priv)1053{1054 struct delta_ctx *ctx = priv;1055 struct delta_dev *delta = ctx->dev;1056 int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx);1057 1058 if (!src_bufs) {1059 dev_dbg(delta->dev, "%s not ready: not enough video buffers.\n",1060 ctx->name);1061 return 0;1062 }1063 1064 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {1065 dev_dbg(delta->dev, "%s not ready: not enough video capture buffers.\n",1066 ctx->name);1067 return 0;1068 }1069 1070 if (ctx->aborting) {1071 dev_dbg(delta->dev, "%s job not ready: aborting\n", ctx->name);1072 return 0;1073 }1074 1075 dev_dbg(delta->dev, "%s job ready\n", ctx->name);1076 1077 return 1;1078}1079 1080/* mem-to-mem ops */1081static const struct v4l2_m2m_ops delta_m2m_ops = {1082 .device_run = delta_device_run,1083 .job_ready = delta_job_ready,1084 .job_abort = delta_job_abort,1085};1086 1087/*1088 * VB2 queue operations1089 */1090 1091static int delta_vb2_au_queue_setup(struct vb2_queue *vq,1092 unsigned int *num_buffers,1093 unsigned int *num_planes,1094 unsigned int sizes[],1095 struct device *alloc_devs[])1096{1097 struct delta_ctx *ctx = vb2_get_drv_priv(vq);1098 unsigned int size = ctx->max_au_size;1099 1100 if (*num_planes)1101 return sizes[0] < size ? -EINVAL : 0;1102 1103 *num_planes = 1;1104 if (*num_buffers < 1)1105 *num_buffers = 1;1106 if (*num_buffers > DELTA_MAX_AUS)1107 *num_buffers = DELTA_MAX_AUS;1108 1109 sizes[0] = size;1110 1111 return 0;1112}1113 1114static int delta_vb2_au_prepare(struct vb2_buffer *vb)1115{1116 struct vb2_queue *q = vb->vb2_queue;1117 struct delta_ctx *ctx = vb2_get_drv_priv(q);1118 struct delta_dev *delta = ctx->dev;1119 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1120 struct delta_au *au = to_au(vbuf);1121 1122 if (!au->prepared) {1123 /* get memory addresses */1124 au->vaddr = vb2_plane_vaddr(&au->vbuf.vb2_buf, 0);1125 au->paddr = vb2_dma_contig_plane_dma_addr1126 (&au->vbuf.vb2_buf, 0);1127 au->prepared = true;1128 dev_dbg(delta->dev, "%s au[%d] prepared; virt=0x%p, phy=0x%pad\n",1129 ctx->name, vb->index, au->vaddr, &au->paddr);1130 }1131 1132 if (vbuf->field == V4L2_FIELD_ANY)1133 vbuf->field = V4L2_FIELD_NONE;1134 1135 return 0;1136}1137 1138static int delta_setup_frame(struct delta_ctx *ctx,1139 struct delta_frame *frame)1140{1141 struct delta_dev *delta = ctx->dev;1142 const struct delta_dec *dec = ctx->dec;1143 1144 if (frame->index >= DELTA_MAX_FRAMES) {1145 dev_err(delta->dev,1146 "%s frame index=%d exceeds output frame count (%d)\n",1147 ctx->name, frame->index, DELTA_MAX_FRAMES);1148 return -EINVAL;1149 }1150 1151 if (ctx->nb_of_frames >= DELTA_MAX_FRAMES) {1152 dev_err(delta->dev,1153 "%s number of frames exceeds output frame count (%d > %d)\n",1154 ctx->name, ctx->nb_of_frames, DELTA_MAX_FRAMES);1155 return -EINVAL;1156 }1157 1158 if (frame->index != ctx->nb_of_frames) {1159 dev_warn(delta->dev,1160 "%s frame index discontinuity detected, expected %d, got %d\n",1161 ctx->name, ctx->nb_of_frames, frame->index);1162 }1163 1164 frame->state = DELTA_FRAME_FREE;1165 ctx->frames[ctx->nb_of_frames] = frame;1166 ctx->nb_of_frames++;1167 1168 /* setup frame on decoder side */1169 return call_dec_op(dec, setup_frame, ctx, frame);1170}1171 1172/*1173 * default implementation of get_frameinfo decoder ops1174 * matching frame information from stream information1175 * & with default pixel format & default alignment.1176 */1177int delta_get_frameinfo_default(struct delta_ctx *ctx,1178 struct delta_frameinfo *frameinfo)1179{1180 struct delta_streaminfo *streaminfo = &ctx->streaminfo;1181 1182 memset(frameinfo, 0, sizeof(*frameinfo));1183 frameinfo->pixelformat = V4L2_PIX_FMT_NV12;1184 frameinfo->width = streaminfo->width;1185 frameinfo->height = streaminfo->height;1186 frameinfo->aligned_width = ALIGN(streaminfo->width,1187 DELTA_WIDTH_ALIGNMENT);1188 frameinfo->aligned_height = ALIGN(streaminfo->height,1189 DELTA_HEIGHT_ALIGNMENT);1190 frameinfo->size = frame_size(frameinfo->aligned_width,1191 frameinfo->aligned_height,1192 frameinfo->pixelformat);1193 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_CROP) {1194 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_CROP;1195 frameinfo->crop = streaminfo->crop;1196 }1197 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_PIXELASPECT) {1198 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_PIXELASPECT;1199 frameinfo->pixelaspect = streaminfo->pixelaspect;1200 }1201 frameinfo->field = streaminfo->field;1202 1203 return 0;1204}1205 1206/*1207 * default implementation of recycle decoder ops1208 * consisting to relax the "decoded" frame state1209 */1210int delta_recycle_default(struct delta_ctx *pctx,1211 struct delta_frame *frame)1212{1213 frame->state &= ~DELTA_FRAME_DEC;1214 1215 return 0;1216}1217 1218static void dump_frames_status(struct delta_ctx *ctx)1219{1220 struct delta_dev *delta = ctx->dev;1221 unsigned int i;1222 struct delta_frame *frame;1223 unsigned char str[100] = "";1224 1225 dev_info(delta->dev,1226 "%s dumping frames status...\n", ctx->name);1227 1228 for (i = 0; i < ctx->nb_of_frames; i++) {1229 frame = ctx->frames[i];1230 dev_info(delta->dev,1231 "%s frame[%d] %s\n",1232 ctx->name, frame->index,1233 frame_state_str(frame->state,1234 str, sizeof(str)));1235 }1236}1237 1238int delta_get_free_frame(struct delta_ctx *ctx,1239 struct delta_frame **pframe)1240{1241 struct delta_dev *delta = ctx->dev;1242 struct vb2_v4l2_buffer *vbuf;1243 struct delta_frame *frame;1244 1245 *pframe = NULL;1246 1247 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);1248 if (!vbuf) {1249 dev_err(delta->dev, "%s no frame available",1250 ctx->name);1251 return -EIO;1252 }1253 1254 frame = to_frame(vbuf);1255 frame->state &= ~DELTA_FRAME_M2M;1256 if (frame->state != DELTA_FRAME_FREE) {1257 dev_err(delta->dev,1258 "%s frame[%d] is not free\n",1259 ctx->name, frame->index);1260 dump_frames_status(ctx);1261 return -ENODATA;1262 }1263 1264 dev_dbg(delta->dev,1265 "%s get free frame[%d]\n", ctx->name, frame->index);1266 1267 *pframe = frame;1268 return 0;1269}1270 1271int delta_get_sync(struct delta_ctx *ctx)1272{1273 struct delta_dev *delta = ctx->dev;1274 int ret = 0;1275 1276 /* enable the hardware */1277 ret = pm_runtime_resume_and_get(delta->dev);1278 if (ret < 0) {1279 dev_err(delta->dev, "%s pm_runtime_resume_and_get failed (%d)\n",1280 __func__, ret);1281 return ret;1282 }1283 1284 return 0;1285}1286 1287void delta_put_autosuspend(struct delta_ctx *ctx)1288{1289 struct delta_dev *delta = ctx->dev;1290 1291 pm_runtime_put_autosuspend(delta->dev);1292}1293 1294static void delta_vb2_au_queue(struct vb2_buffer *vb)1295{1296 struct vb2_queue *q = vb->vb2_queue;1297 struct delta_ctx *ctx = vb2_get_drv_priv(q);1298 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1299 1300 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);1301}1302 1303static int delta_vb2_au_start_streaming(struct vb2_queue *q,1304 unsigned int count)1305{1306 struct delta_ctx *ctx = vb2_get_drv_priv(q);1307 struct delta_dev *delta = ctx->dev;1308 const struct delta_dec *dec = ctx->dec;1309 struct delta_au *au;1310 int ret = 0;1311 struct vb2_v4l2_buffer *vbuf = NULL;1312 struct delta_streaminfo *streaminfo = &ctx->streaminfo;1313 struct delta_frameinfo *frameinfo = &ctx->frameinfo;1314 unsigned char str1[100] = "";1315 unsigned char str2[100] = "";1316 1317 if ((ctx->state != DELTA_STATE_WF_FORMAT) &&1318 (ctx->state != DELTA_STATE_WF_STREAMINFO))1319 return 0;1320 1321 if (ctx->state == DELTA_STATE_WF_FORMAT) {1322 /* open decoder if not yet done */1323 ret = delta_open_decoder(ctx,1324 ctx->streaminfo.streamformat,1325 ctx->frameinfo.pixelformat, &dec);1326 if (ret)1327 goto err;1328 ctx->dec = dec;1329 ctx->state = DELTA_STATE_WF_STREAMINFO;1330 }1331 1332 /*1333 * first buffer should contain stream header,1334 * decode it to get the infos related to stream1335 * such as width, height, dpb, ...1336 */1337 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);1338 if (!vbuf) {1339 dev_err(delta->dev, "%s failed to start streaming, no stream header buffer enqueued\n",1340 ctx->name);1341 ret = -EINVAL;1342 goto err;1343 }1344 au = to_au(vbuf);1345 au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);1346 au->dts = vbuf->vb2_buf.timestamp;1347 1348 delta_push_dts(ctx, au->dts);1349 1350 /* dump access unit */1351 dump_au(ctx, au);1352 1353 /* decode this access unit */1354 ret = call_dec_op(dec, decode, ctx, au);1355 if (ret) {1356 dev_err(delta->dev, "%s failed to start streaming, header decoding failed (%d)\n",1357 ctx->name, ret);1358 goto err;1359 }1360 1361 ret = call_dec_op(dec, get_streaminfo, ctx, streaminfo);1362 if (ret) {1363 dev_dbg_ratelimited(delta->dev,1364 "%s failed to start streaming, valid stream header not yet decoded\n",1365 ctx->name);1366 goto err;1367 }1368 ctx->flags |= DELTA_FLAG_STREAMINFO;1369 1370 ret = call_dec_op(dec, get_frameinfo, ctx, frameinfo);1371 if (ret)1372 goto err;1373 ctx->flags |= DELTA_FLAG_FRAMEINFO;1374 1375 ctx->state = DELTA_STATE_READY;1376 1377 dev_dbg(delta->dev, "%s %s => %s\n", ctx->name,1378 delta_streaminfo_str(streaminfo, str1, sizeof(str1)),1379 delta_frameinfo_str(frameinfo, str2, sizeof(str2)));1380 1381 delta_au_done(ctx, au, ret);1382 return 0;1383 1384err:1385 /*1386 * return all buffers to vb2 in QUEUED state.1387 * This will give ownership back to userspace1388 */1389 if (vbuf)1390 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);1391 1392 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))1393 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);1394 return ret;1395}1396 1397static void delta_vb2_au_stop_streaming(struct vb2_queue *q)1398{1399 struct delta_ctx *ctx = vb2_get_drv_priv(q);1400 struct vb2_v4l2_buffer *vbuf;1401 1402 delta_flush_dts(ctx);1403 1404 /* return all buffers to vb2 in ERROR state */1405 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))1406 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);1407 1408 ctx->au_num = 0;1409 1410 ctx->aborting = false;1411}1412 1413static int delta_vb2_frame_queue_setup(struct vb2_queue *vq,1414 unsigned int *num_buffers,1415 unsigned int *num_planes,1416 unsigned int sizes[],1417 struct device *alloc_devs[])1418{1419 struct delta_ctx *ctx = vb2_get_drv_priv(vq);1420 struct delta_dev *delta = ctx->dev;1421 struct delta_streaminfo *streaminfo = &ctx->streaminfo;1422 struct delta_frameinfo *frameinfo = &ctx->frameinfo;1423 unsigned int size = frameinfo->size;1424 1425 /*1426 * the number of output buffers needed for decoding =1427 * user need (*num_buffers given, usually for display pipeline) +1428 * stream need (streaminfo->dpb) +1429 * decoding peak smoothing (depends on DELTA IP perf)1430 */1431 if (*num_buffers < DELTA_MIN_FRAME_USER) {1432 dev_dbg(delta->dev,1433 "%s num_buffers too low (%d), increasing to %d\n",1434 ctx->name, *num_buffers, DELTA_MIN_FRAME_USER);1435 *num_buffers = DELTA_MIN_FRAME_USER;1436 }1437 1438 *num_buffers += streaminfo->dpb + DELTA_PEAK_FRAME_SMOOTHING;1439 1440 if (*num_buffers > DELTA_MAX_FRAMES) {1441 dev_dbg(delta->dev,1442 "%s output frame count too high (%d), cut to %d\n",1443 ctx->name, *num_buffers, DELTA_MAX_FRAMES);1444 *num_buffers = DELTA_MAX_FRAMES;1445 }1446 1447 if (*num_planes)1448 return sizes[0] < size ? -EINVAL : 0;1449 1450 /* single plane for Y and CbCr */1451 *num_planes = 1;1452 1453 sizes[0] = size;1454 1455 ctx->nb_of_frames = 0;1456 1457 return 0;1458}1459 1460static int delta_vb2_frame_prepare(struct vb2_buffer *vb)1461{1462 struct vb2_queue *q = vb->vb2_queue;1463 struct delta_ctx *ctx = vb2_get_drv_priv(q);1464 struct delta_dev *delta = ctx->dev;1465 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1466 struct delta_frame *frame = to_frame(vbuf);1467 int ret = 0;1468 1469 if (!frame->prepared) {1470 frame->index = vbuf->vb2_buf.index;1471 frame->vaddr = vb2_plane_vaddr(&vbuf->vb2_buf, 0);1472 frame->paddr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);1473 frame->info = ctx->frameinfo;1474 1475 ret = delta_setup_frame(ctx, frame);1476 if (ret) {1477 dev_err(delta->dev,1478 "%s setup_frame() failed (%d)\n",1479 ctx->name, ret);1480 return ret;1481 }1482 frame->prepared = true;1483 dev_dbg(delta->dev,1484 "%s frame[%d] prepared; virt=0x%p, phy=0x%pad\n",1485 ctx->name, vb->index, frame->vaddr,1486 &frame->paddr);1487 }1488 1489 frame->flags = vbuf->flags;1490 1491 return 0;1492}1493 1494static void delta_vb2_frame_finish(struct vb2_buffer *vb)1495{1496 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1497 struct delta_frame *frame = to_frame(vbuf);1498 1499 /* update V4L2 fields for user */1500 vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->info.size);1501 vb->timestamp = frame->dts;1502 vbuf->field = frame->field;1503 vbuf->flags = frame->flags;1504}1505 1506static void delta_vb2_frame_queue(struct vb2_buffer *vb)1507{1508 struct vb2_queue *q = vb->vb2_queue;1509 struct delta_ctx *ctx = vb2_get_drv_priv(q);1510 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);1511 struct delta_frame *frame = to_frame(vbuf);1512 1513 if (ctx->state == DELTA_STATE_WF_EOS) {1514 /* new frame available, EOS can now be completed */1515 delta_complete_eos(ctx, frame);1516 1517 ctx->state = DELTA_STATE_EOS;1518 1519 /* return, no need to recycle this buffer to decoder */1520 return;1521 }1522 1523 /* recycle this frame */1524 delta_recycle(ctx, frame);1525}1526 1527static void delta_vb2_frame_stop_streaming(struct vb2_queue *q)1528{1529 struct delta_ctx *ctx = vb2_get_drv_priv(q);1530 struct vb2_v4l2_buffer *vbuf;1531 struct delta_frame *frame;1532 const struct delta_dec *dec = ctx->dec;1533 unsigned int i;1534 1535 delta_flush_dts(ctx);1536 1537 call_dec_op(dec, flush, ctx);1538 1539 /*1540 * return all buffers to vb2 in ERROR state1541 * & reset each frame state to OUT1542 */1543 for (i = 0; i < ctx->nb_of_frames; i++) {1544 frame = ctx->frames[i];1545 if (!(frame->state & DELTA_FRAME_OUT)) {1546 vbuf = &frame->vbuf;1547 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);1548 }1549 frame->state = DELTA_FRAME_OUT;1550 }1551 1552 ctx->frame_num = 0;1553 1554 ctx->aborting = false;1555}1556 1557/* VB2 queue ops */1558static const struct vb2_ops delta_vb2_au_ops = {1559 .queue_setup = delta_vb2_au_queue_setup,1560 .buf_prepare = delta_vb2_au_prepare,1561 .buf_queue = delta_vb2_au_queue,1562 .wait_prepare = vb2_ops_wait_prepare,1563 .wait_finish = vb2_ops_wait_finish,1564 .start_streaming = delta_vb2_au_start_streaming,1565 .stop_streaming = delta_vb2_au_stop_streaming,1566};1567 1568static const struct vb2_ops delta_vb2_frame_ops = {1569 .queue_setup = delta_vb2_frame_queue_setup,1570 .buf_prepare = delta_vb2_frame_prepare,1571 .buf_finish = delta_vb2_frame_finish,1572 .buf_queue = delta_vb2_frame_queue,1573 .wait_prepare = vb2_ops_wait_prepare,1574 .wait_finish = vb2_ops_wait_finish,1575 .stop_streaming = delta_vb2_frame_stop_streaming,1576};1577 1578/*1579 * V4L2 file operations1580 */1581 1582static int queue_init(void *priv,1583 struct vb2_queue *src_vq, struct vb2_queue *dst_vq)1584{1585 struct vb2_queue *q;1586 struct delta_ctx *ctx = priv;1587 struct delta_dev *delta = ctx->dev;1588 int ret;1589 1590 /* setup vb2 queue for stream input */1591 q = src_vq;1592 q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;1593 q->io_modes = VB2_MMAP | VB2_DMABUF;1594 q->drv_priv = ctx;1595 /* overload vb2 buf with private au struct */1596 q->buf_struct_size = sizeof(struct delta_au);1597 q->ops = &delta_vb2_au_ops;1598 q->mem_ops = &vb2_dma_contig_memops;1599 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;1600 q->lock = &delta->lock;1601 q->dev = delta->dev;1602 1603 ret = vb2_queue_init(q);1604 if (ret)1605 return ret;1606 1607 /* setup vb2 queue for frame output */1608 q = dst_vq;1609 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;1610 q->io_modes = VB2_MMAP | VB2_DMABUF;1611 q->drv_priv = ctx;1612 /* overload vb2 buf with private frame struct */1613 q->buf_struct_size = sizeof(struct delta_frame)1614 + DELTA_MAX_FRAME_PRIV_SIZE;1615 q->ops = &delta_vb2_frame_ops;1616 q->mem_ops = &vb2_dma_contig_memops;1617 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;1618 q->lock = &delta->lock;1619 q->dev = delta->dev;1620 1621 return vb2_queue_init(q);1622}1623 1624static int delta_open(struct file *file)1625{1626 struct delta_dev *delta = video_drvdata(file);1627 struct delta_ctx *ctx = NULL;1628 int ret = 0;1629 1630 mutex_lock(&delta->lock);1631 1632 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);1633 if (!ctx) {1634 ret = -ENOMEM;1635 goto err;1636 }1637 ctx->dev = delta;1638 1639 v4l2_fh_init(&ctx->fh, video_devdata(file));1640 file->private_data = &ctx->fh;1641 v4l2_fh_add(&ctx->fh);1642 1643 INIT_WORK(&ctx->run_work, delta_run_work);1644 mutex_init(&ctx->lock);1645 1646 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(delta->m2m_dev, ctx,1647 queue_init);1648 if (IS_ERR(ctx->fh.m2m_ctx)) {1649 ret = PTR_ERR(ctx->fh.m2m_ctx);1650 dev_err(delta->dev, "%s failed to initialize m2m context (%d)\n",1651 DELTA_PREFIX, ret);1652 goto err_fh_del;1653 }1654 1655 /*1656 * wait stream format to determine which1657 * decoder to open1658 */1659 ctx->state = DELTA_STATE_WF_FORMAT;1660 1661 INIT_LIST_HEAD(&ctx->dts);1662 1663 /* set the instance name */1664 delta->instance_id++;1665 snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]",1666 delta->instance_id);1667 1668 /* default parameters for frame and stream */1669 set_default_params(ctx);1670 1671 /* enable ST231 clocks */1672 if (clk_prepare_enable(delta->clk_st231))1673 dev_warn(delta->dev, "failed to enable st231 clk\n");1674 1675 /* enable FLASH_PROMIP clock */1676 if (clk_prepare_enable(delta->clk_flash_promip))1677 dev_warn(delta->dev, "failed to enable delta promip clk\n");1678 1679 mutex_unlock(&delta->lock);1680 1681 dev_dbg(delta->dev, "%s decoder instance created\n", ctx->name);1682 1683 return 0;1684 1685err_fh_del:1686 v4l2_fh_del(&ctx->fh);1687 v4l2_fh_exit(&ctx->fh);1688 kfree(ctx);1689err:1690 mutex_unlock(&delta->lock);1691 1692 return ret;1693}1694 1695static int delta_release(struct file *file)1696{1697 struct delta_ctx *ctx = to_ctx(file->private_data);1698 struct delta_dev *delta = ctx->dev;1699 const struct delta_dec *dec = ctx->dec;1700 1701 mutex_lock(&delta->lock);1702 1703 /* close decoder */1704 call_dec_op(dec, close, ctx);1705 1706 /*1707 * trace a summary of instance1708 * before closing (debug purpose)1709 */1710 delta_trace_summary(ctx);1711 1712 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);1713 1714 v4l2_fh_del(&ctx->fh);1715 v4l2_fh_exit(&ctx->fh);1716 1717 /* disable ST231 clocks */1718 clk_disable_unprepare(delta->clk_st231);1719 1720 /* disable FLASH_PROMIP clock */1721 clk_disable_unprepare(delta->clk_flash_promip);1722 1723 dev_dbg(delta->dev, "%s decoder instance released\n", ctx->name);1724 1725 kfree(ctx);1726 1727 mutex_unlock(&delta->lock);1728 return 0;1729}1730 1731/* V4L2 file ops */1732static const struct v4l2_file_operations delta_fops = {1733 .owner = THIS_MODULE,1734 .open = delta_open,1735 .release = delta_release,1736 .unlocked_ioctl = video_ioctl2,1737 .mmap = v4l2_m2m_fop_mmap,1738 .poll = v4l2_m2m_fop_poll,1739};1740 1741/*1742 * Platform device operations1743 */1744 1745static int delta_register_device(struct delta_dev *delta)1746{1747 int ret;1748 struct video_device *vdev;1749 1750 if (!delta)1751 return -ENODEV;1752 1753 delta->m2m_dev = v4l2_m2m_init(&delta_m2m_ops);1754 if (IS_ERR(delta->m2m_dev)) {1755 dev_err(delta->dev, "%s failed to initialize v4l2-m2m device\n",1756 DELTA_PREFIX);1757 ret = PTR_ERR(delta->m2m_dev);1758 goto err;1759 }1760 1761 vdev = video_device_alloc();1762 if (!vdev) {1763 dev_err(delta->dev, "%s failed to allocate video device\n",1764 DELTA_PREFIX);1765 ret = -ENOMEM;1766 goto err_m2m_release;1767 }1768 1769 vdev->fops = &delta_fops;1770 vdev->ioctl_ops = &delta_ioctl_ops;1771 vdev->release = video_device_release;1772 vdev->lock = &delta->lock;1773 vdev->vfl_dir = VFL_DIR_M2M;1774 vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;1775 vdev->v4l2_dev = &delta->v4l2_dev;1776 snprintf(vdev->name, sizeof(vdev->name), "%s-%s",1777 DELTA_NAME, DELTA_FW_VERSION);1778 1779 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);1780 if (ret) {1781 dev_err(delta->dev, "%s failed to register video device\n",1782 DELTA_PREFIX);1783 goto err_vdev_release;1784 }1785 1786 delta->vdev = vdev;1787 video_set_drvdata(vdev, delta);1788 return 0;1789 1790err_vdev_release:1791 video_device_release(vdev);1792err_m2m_release:1793 v4l2_m2m_release(delta->m2m_dev);1794err:1795 return ret;1796}1797 1798static void delta_unregister_device(struct delta_dev *delta)1799{1800 if (!delta)1801 return;1802 1803 if (delta->m2m_dev)1804 v4l2_m2m_release(delta->m2m_dev);1805 1806 video_unregister_device(delta->vdev);1807}1808 1809static int delta_probe(struct platform_device *pdev)1810{1811 struct delta_dev *delta;1812 struct device *dev = &pdev->dev;1813 int ret;1814 1815 delta = devm_kzalloc(dev, sizeof(*delta), GFP_KERNEL);1816 if (!delta) {1817 ret = -ENOMEM;1818 goto err;1819 }1820 1821 delta->dev = dev;1822 delta->pdev = pdev;1823 platform_set_drvdata(pdev, delta);1824 1825 mutex_init(&delta->lock);1826 1827 /* get clock resources */1828 delta->clk_delta = devm_clk_get(dev, "delta");1829 if (IS_ERR(delta->clk_delta)) {1830 dev_dbg(dev, "%s can't get delta clock\n", DELTA_PREFIX);1831 delta->clk_delta = NULL;1832 }1833 1834 delta->clk_st231 = devm_clk_get(dev, "delta-st231");1835 if (IS_ERR(delta->clk_st231)) {1836 dev_dbg(dev, "%s can't get delta-st231 clock\n", DELTA_PREFIX);1837 delta->clk_st231 = NULL;1838 }1839 1840 delta->clk_flash_promip = devm_clk_get(dev, "delta-flash-promip");1841 if (IS_ERR(delta->clk_flash_promip)) {1842 dev_dbg(dev, "%s can't get delta-flash-promip clock\n",1843 DELTA_PREFIX);1844 delta->clk_flash_promip = NULL;1845 }1846 1847 /* init pm_runtime used for power management */1848 pm_runtime_set_autosuspend_delay(dev, DELTA_HW_AUTOSUSPEND_DELAY_MS);1849 pm_runtime_use_autosuspend(dev);1850 pm_runtime_set_suspended(dev);1851 pm_runtime_enable(dev);1852 1853 /* init firmware ipc channel */1854 ret = delta_ipc_init(delta);1855 if (ret) {1856 dev_err(delta->dev, "%s failed to initialize firmware ipc channel\n",1857 DELTA_PREFIX);1858 goto err_pm_disable;1859 }1860 1861 /* register all available decoders */1862 register_decoders(delta);1863 1864 /* register all supported formats */1865 register_formats(delta);1866 1867 /* register on V4L2 */1868 ret = v4l2_device_register(dev, &delta->v4l2_dev);1869 if (ret) {1870 dev_err(delta->dev, "%s failed to register V4L2 device\n",1871 DELTA_PREFIX);1872 goto err_pm_disable;1873 }1874 1875 delta->work_queue = create_workqueue(DELTA_NAME);1876 if (!delta->work_queue) {1877 dev_err(delta->dev, "%s failed to allocate work queue\n",1878 DELTA_PREFIX);1879 ret = -ENOMEM;1880 goto err_v4l2;1881 }1882 1883 /* register device */1884 ret = delta_register_device(delta);1885 if (ret)1886 goto err_work_queue;1887 1888 dev_info(dev, "%s %s registered as /dev/video%d\n",1889 DELTA_PREFIX, delta->vdev->name, delta->vdev->num);1890 1891 return 0;1892 1893err_work_queue:1894 destroy_workqueue(delta->work_queue);1895err_v4l2:1896 v4l2_device_unregister(&delta->v4l2_dev);1897err_pm_disable:1898 pm_runtime_disable(dev);1899err:1900 return ret;1901}1902 1903static void delta_remove(struct platform_device *pdev)1904{1905 struct delta_dev *delta = platform_get_drvdata(pdev);1906 1907 delta_ipc_exit(delta);1908 1909 delta_unregister_device(delta);1910 1911 destroy_workqueue(delta->work_queue);1912 1913 pm_runtime_put_autosuspend(delta->dev);1914 pm_runtime_disable(delta->dev);1915 1916 v4l2_device_unregister(&delta->v4l2_dev);1917}1918 1919static int delta_runtime_suspend(struct device *dev)1920{1921 struct delta_dev *delta = dev_get_drvdata(dev);1922 1923 clk_disable_unprepare(delta->clk_delta);1924 1925 return 0;1926}1927 1928static int delta_runtime_resume(struct device *dev)1929{1930 struct delta_dev *delta = dev_get_drvdata(dev);1931 1932 if (clk_prepare_enable(delta->clk_delta))1933 dev_warn(dev, "failed to prepare/enable delta clk\n");1934 1935 return 0;1936}1937 1938/* PM ops */1939static const struct dev_pm_ops delta_pm_ops = {1940 .runtime_suspend = delta_runtime_suspend,1941 .runtime_resume = delta_runtime_resume,1942};1943 1944static const struct of_device_id delta_match_types[] = {1945 {1946 .compatible = "st,st-delta",1947 },1948 {1949 /* end node */1950 }1951};1952 1953MODULE_DEVICE_TABLE(of, delta_match_types);1954 1955static struct platform_driver delta_driver = {1956 .probe = delta_probe,1957 .remove_new = delta_remove,1958 .driver = {1959 .name = DELTA_NAME,1960 .of_match_table = delta_match_types,1961 .pm = &delta_pm_ops},1962};1963 1964module_platform_driver(delta_driver);1965 1966MODULE_LICENSE("GPL");1967MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");1968MODULE_DESCRIPTION("STMicroelectronics DELTA video decoder V4L2 driver");1969