1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (C) STMicroelectronics SA 2015 4 * 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_MJPEG 37 &mjpegdec, 38#endif 39}; 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 else 72 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 acquired 171 * by V4L2 when calling delta_vb2_au_queue 172 */ 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 acquired 184 * by V4L2 when calling delta_vb2_au_queue 185 */ 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 acquired 208 * by V4L2 when calling delta_vb2_au_queue 209 */ 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 size 236 * 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 operations 380 */ 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_image 514 (&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 least 664 * pixel format & negotiate resolution boundaries 665 * 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_LAST 772 * - and then send EOS event 773 */ 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 because 856 * we don't have a free empty frame available. 857 * EOS completion is so delayed till next frame_queue() call 858 * 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 operations 920 */ 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 delta_put_autosuspend(ctx); 959 goto err; 960 } 961 } 962 963 /* decode this access unit */ 964 ret = call_dec_op(dec, decode, ctx, au); 965 966 /* 967 * if the (-ENODATA) value is returned, it refers to the interlaced 968 * stream case for which 2 access units are needed to get 1 frame. 969 * So, this returned value doesn't mean that the decoding fails, but 970 * indicates that the timestamp information of the access unit shall 971 * not be taken into account, and that the V4L2 buffer associated with 972 * the access unit shall be flagged with V4L2_BUF_FLAG_ERROR to inform 973 * the user of this situation 974 */ 975 if (ret == -ENODATA) { 976 discard = true; 977 } else if (ret) { 978 dev_err(delta->dev, "%s decoding failed (%d)\n", 979 ctx->name, ret); 980 981 /* disable the hardware */ 982 if (!dec->pm) 983 delta_put_autosuspend(ctx); 984 985 goto err; 986 } 987 988 /* disable the hardware */ 989 if (!dec->pm) 990 delta_put_autosuspend(ctx); 991 992 /* push au timestamp in FIFO */ 993 if (!discard) 994 delta_push_dts(ctx, au->dts); 995 996 /* get available decoded frames */ 997 while (1) { 998 ret = call_dec_op(dec, get_frame, ctx, &frame); 999 if (ret == -ENODATA) { 1000 /* no more decoded frames */ 1001 goto out; 1002 } 1003 if (ret) { 1004 dev_err(delta->dev, "%s cannot get decoded frame (%d)\n", 1005 ctx->name, ret); 1006 goto out; 1007 } 1008 if (!frame) { 1009 dev_err(delta->dev, 1010 "%s NULL decoded frame\n", 1011 ctx->name); 1012 ret = -EIO; 1013 goto out; 1014 } 1015 1016 /* pop timestamp and mark frame with it */ 1017 delta_pop_dts(ctx, &frame->dts); 1018 1019 /* release decoded frame to user */ 1020 delta_frame_done(ctx, frame, 0); 1021 } 1022 1023out: 1024 requeue_free_frames(ctx); 1025 delta_au_done(ctx, au, (discard ? -ENODATA : 0)); 1026 mutex_unlock(&ctx->lock); 1027 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx); 1028 return; 1029 1030err: 1031 requeue_free_frames(ctx); 1032 delta_au_done(ctx, au, ret); 1033 mutex_unlock(&ctx->lock); 1034 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx); 1035} 1036 1037static void delta_device_run(void *priv) 1038{ 1039 struct delta_ctx *ctx = priv; 1040 struct delta_dev *delta = ctx->dev; 1041 1042 queue_work(delta->work_queue, &ctx->run_work); 1043} 1044 1045static void delta_job_abort(void *priv) 1046{ 1047 struct delta_ctx *ctx = priv; 1048 struct delta_dev *delta = ctx->dev; 1049 1050 dev_dbg(delta->dev, "%s aborting job\n", ctx->name); 1051 1052 ctx->aborting = true; 1053} 1054 1055static int delta_job_ready(void *priv) 1056{ 1057 struct delta_ctx *ctx = priv; 1058 struct delta_dev *delta = ctx->dev; 1059 int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx); 1060 1061 if (!src_bufs) { 1062 dev_dbg(delta->dev, "%s not ready: not enough video buffers.\n", 1063 ctx->name); 1064 return 0; 1065 } 1066 1067 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) { 1068 dev_dbg(delta->dev, "%s not ready: not enough video capture buffers.\n", 1069 ctx->name); 1070 return 0; 1071 } 1072 1073 if (ctx->aborting) { 1074 dev_dbg(delta->dev, "%s job not ready: aborting\n", ctx->name); 1075 return 0; 1076 } 1077 1078 dev_dbg(delta->dev, "%s job ready\n", ctx->name); 1079 1080 return 1; 1081} 1082 1083/* mem-to-mem ops */ 1084static const struct v4l2_m2m_ops delta_m2m_ops = { 1085 .device_run = delta_device_run, 1086 .job_ready = delta_job_ready, 1087 .job_abort = delta_job_abort, 1088}; 1089 1090/* 1091 * VB2 queue operations 1092 */ 1093 1094static int delta_vb2_au_queue_setup(struct vb2_queue *vq, 1095 unsigned int *num_buffers, 1096 unsigned int *num_planes, 1097 unsigned int sizes[], 1098 struct device *alloc_devs[]) 1099{ 1100 struct delta_ctx *ctx = vb2_get_drv_priv(vq); 1101 unsigned int size = ctx->max_au_size; 1102 1103 if (*num_planes) 1104 return sizes[0] < size ? -EINVAL : 0; 1105 1106 *num_planes = 1; 1107 if (*num_buffers < 1) 1108 *num_buffers = 1; 1109 if (*num_buffers > DELTA_MAX_AUS) 1110 *num_buffers = DELTA_MAX_AUS; 1111 1112 sizes[0] = size; 1113 1114 return 0; 1115} 1116 1117static int delta_vb2_au_prepare(struct vb2_buffer *vb) 1118{ 1119 struct vb2_queue *q = vb->vb2_queue; 1120 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1121 struct delta_dev *delta = ctx->dev; 1122 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1123 struct delta_au *au = to_au(vbuf); 1124 1125 if (!au->prepared) { 1126 /* get memory addresses */ 1127 au->vaddr = vb2_plane_vaddr(&au->vbuf.vb2_buf, 0); 1128 au->paddr = vb2_dma_contig_plane_dma_addr 1129 (&au->vbuf.vb2_buf, 0); 1130 au->prepared = true; 1131 dev_dbg(delta->dev, "%s au[%d] prepared; virt=0x%p, phy=0x%pad\n", 1132 ctx->name, vb->index, au->vaddr, &au->paddr); 1133 } 1134 1135 if (vbuf->field == V4L2_FIELD_ANY) 1136 vbuf->field = V4L2_FIELD_NONE; 1137 1138 return 0; 1139} 1140 1141static int delta_setup_frame(struct delta_ctx *ctx, 1142 struct delta_frame *frame) 1143{ 1144 struct delta_dev *delta = ctx->dev; 1145 const struct delta_dec *dec = ctx->dec; 1146 1147 if (frame->index >= DELTA_MAX_FRAMES) { 1148 dev_err(delta->dev, 1149 "%s frame index=%d exceeds output frame count (%d)\n", 1150 ctx->name, frame->index, DELTA_MAX_FRAMES); 1151 return -EINVAL; 1152 } 1153 1154 if (ctx->nb_of_frames >= DELTA_MAX_FRAMES) { 1155 dev_err(delta->dev, 1156 "%s number of frames exceeds output frame count (%d > %d)\n", 1157 ctx->name, ctx->nb_of_frames, DELTA_MAX_FRAMES); 1158 return -EINVAL; 1159 } 1160 1161 if (frame->index != ctx->nb_of_frames) { 1162 dev_warn(delta->dev, 1163 "%s frame index discontinuity detected, expected %d, got %d\n", 1164 ctx->name, ctx->nb_of_frames, frame->index); 1165 } 1166 1167 frame->state = DELTA_FRAME_FREE; 1168 ctx->frames[ctx->nb_of_frames] = frame; 1169 ctx->nb_of_frames++; 1170 1171 /* setup frame on decoder side */ 1172 return call_dec_op(dec, setup_frame, ctx, frame); 1173} 1174 1175/* 1176 * default implementation of get_frameinfo decoder ops 1177 * matching frame information from stream information 1178 * & with default pixel format & default alignment. 1179 */ 1180int delta_get_frameinfo_default(struct delta_ctx *ctx, 1181 struct delta_frameinfo *frameinfo) 1182{ 1183 struct delta_streaminfo *streaminfo = &ctx->streaminfo; 1184 1185 memset(frameinfo, 0, sizeof(*frameinfo)); 1186 frameinfo->pixelformat = V4L2_PIX_FMT_NV12; 1187 frameinfo->width = streaminfo->width; 1188 frameinfo->height = streaminfo->height; 1189 frameinfo->aligned_width = ALIGN(streaminfo->width, 1190 DELTA_WIDTH_ALIGNMENT); 1191 frameinfo->aligned_height = ALIGN(streaminfo->height, 1192 DELTA_HEIGHT_ALIGNMENT); 1193 frameinfo->size = frame_size(frameinfo->aligned_width, 1194 frameinfo->aligned_height, 1195 frameinfo->pixelformat); 1196 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_CROP) { 1197 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_CROP; 1198 frameinfo->crop = streaminfo->crop; 1199 } 1200 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_PIXELASPECT) { 1201 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_PIXELASPECT; 1202 frameinfo->pixelaspect = streaminfo->pixelaspect; 1203 } 1204 frameinfo->field = streaminfo->field; 1205 1206 return 0; 1207} 1208 1209/* 1210 * default implementation of recycle decoder ops 1211 * consisting to relax the "decoded" frame state 1212 */ 1213int delta_recycle_default(struct delta_ctx *pctx, 1214 struct delta_frame *frame) 1215{ 1216 frame->state &= ~DELTA_FRAME_DEC; 1217 1218 return 0; 1219} 1220 1221static void dump_frames_status(struct delta_ctx *ctx) 1222{ 1223 struct delta_dev *delta = ctx->dev; 1224 unsigned int i; 1225 struct delta_frame *frame; 1226 unsigned char str[100] = ""; 1227 1228 dev_info(delta->dev, 1229 "%s dumping frames status...\n", ctx->name); 1230 1231 for (i = 0; i < ctx->nb_of_frames; i++) { 1232 frame = ctx->frames[i]; 1233 dev_info(delta->dev, 1234 "%s frame[%d] %s\n", 1235 ctx->name, frame->index, 1236 frame_state_str(frame->state, 1237 str, sizeof(str))); 1238 } 1239} 1240 1241int delta_get_free_frame(struct delta_ctx *ctx, 1242 struct delta_frame **pframe) 1243{ 1244 struct delta_dev *delta = ctx->dev; 1245 struct vb2_v4l2_buffer *vbuf; 1246 struct delta_frame *frame; 1247 1248 *pframe = NULL; 1249 1250 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 1251 if (!vbuf) { 1252 dev_err(delta->dev, "%s no frame available", 1253 ctx->name); 1254 return -EIO; 1255 } 1256 1257 frame = to_frame(vbuf); 1258 frame->state &= ~DELTA_FRAME_M2M; 1259 if (frame->state != DELTA_FRAME_FREE) { 1260 dev_err(delta->dev, 1261 "%s frame[%d] is not free\n", 1262 ctx->name, frame->index); 1263 dump_frames_status(ctx); 1264 return -ENODATA; 1265 } 1266 1267 dev_dbg(delta->dev, 1268 "%s get free frame[%d]\n", ctx->name, frame->index); 1269 1270 *pframe = frame; 1271 return 0; 1272} 1273 1274int delta_get_sync(struct delta_ctx *ctx) 1275{ 1276 struct delta_dev *delta = ctx->dev; 1277 int ret = 0; 1278 1279 /* enable the hardware */ 1280 ret = pm_runtime_get_sync(delta->dev); 1281 if (ret < 0) { 1282 dev_err(delta->dev, "%s pm_runtime_get_sync failed (%d)\n", 1283 __func__, ret); 1284 return ret; 1285 } 1286 1287 return 0; 1288} 1289 1290void delta_put_autosuspend(struct delta_ctx *ctx) 1291{ 1292 struct delta_dev *delta = ctx->dev; 1293 1294 pm_runtime_put_autosuspend(delta->dev); 1295} 1296 1297static void delta_vb2_au_queue(struct vb2_buffer *vb) 1298{ 1299 struct vb2_queue *q = vb->vb2_queue; 1300 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1301 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1302 1303 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1304} 1305 1306static int delta_vb2_au_start_streaming(struct vb2_queue *q, 1307 unsigned int count) 1308{ 1309 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1310 struct delta_dev *delta = ctx->dev; 1311 const struct delta_dec *dec = ctx->dec; 1312 struct delta_au *au; 1313 int ret = 0; 1314 struct vb2_v4l2_buffer *vbuf = NULL; 1315 struct delta_streaminfo *streaminfo = &ctx->streaminfo; 1316 struct delta_frameinfo *frameinfo = &ctx->frameinfo; 1317 unsigned char str1[100] = ""; 1318 unsigned char str2[100] = ""; 1319 1320 if ((ctx->state != DELTA_STATE_WF_FORMAT) && 1321 (ctx->state != DELTA_STATE_WF_STREAMINFO)) 1322 return 0; 1323 1324 if (ctx->state == DELTA_STATE_WF_FORMAT) { 1325 /* open decoder if not yet done */ 1326 ret = delta_open_decoder(ctx, 1327 ctx->streaminfo.streamformat, 1328 ctx->frameinfo.pixelformat, &dec); 1329 if (ret) 1330 goto err; 1331 ctx->dec = dec; 1332 ctx->state = DELTA_STATE_WF_STREAMINFO; 1333 } 1334 1335 /* 1336 * first buffer should contain stream header, 1337 * decode it to get the infos related to stream 1338 * such as width, height, dpb, ... 1339 */ 1340 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 1341 if (!vbuf) { 1342 dev_err(delta->dev, "%s failed to start streaming, no stream header buffer enqueued\n", 1343 ctx->name); 1344 ret = -EINVAL; 1345 goto err; 1346 } 1347 au = to_au(vbuf); 1348 au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0); 1349 au->dts = vbuf->vb2_buf.timestamp; 1350 1351 delta_push_dts(ctx, au->dts); 1352 1353 /* dump access unit */ 1354 dump_au(ctx, au); 1355 1356 /* decode this access unit */ 1357 ret = call_dec_op(dec, decode, ctx, au); 1358 if (ret) { 1359 dev_err(delta->dev, "%s failed to start streaming, header decoding failed (%d)\n", 1360 ctx->name, ret); 1361 goto err; 1362 } 1363 1364 ret = call_dec_op(dec, get_streaminfo, ctx, streaminfo); 1365 if (ret) { 1366 dev_dbg_ratelimited(delta->dev, 1367 "%s failed to start streaming, valid stream header not yet decoded\n", 1368 ctx->name); 1369 goto err; 1370 } 1371 ctx->flags |= DELTA_FLAG_STREAMINFO; 1372 1373 ret = call_dec_op(dec, get_frameinfo, ctx, frameinfo); 1374 if (ret) 1375 goto err; 1376 ctx->flags |= DELTA_FLAG_FRAMEINFO; 1377 1378 ctx->state = DELTA_STATE_READY; 1379 1380 dev_dbg(delta->dev, "%s %s => %s\n", ctx->name, 1381 delta_streaminfo_str(streaminfo, str1, sizeof(str1)), 1382 delta_frameinfo_str(frameinfo, str2, sizeof(str2))); 1383 1384 delta_au_done(ctx, au, ret); 1385 return 0; 1386 1387err: 1388 /* 1389 * return all buffers to vb2 in QUEUED state. 1390 * This will give ownership back to userspace 1391 */ 1392 if (vbuf) 1393 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED); 1394 1395 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 1396 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED); 1397 return ret; 1398} 1399 1400static void delta_vb2_au_stop_streaming(struct vb2_queue *q) 1401{ 1402 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1403 struct vb2_v4l2_buffer *vbuf; 1404 1405 delta_flush_dts(ctx); 1406 1407 /* return all buffers to vb2 in ERROR state */ 1408 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 1409 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR); 1410 1411 ctx->au_num = 0; 1412 1413 ctx->aborting = false; 1414} 1415 1416static int delta_vb2_frame_queue_setup(struct vb2_queue *vq, 1417 unsigned int *num_buffers, 1418 unsigned int *num_planes, 1419 unsigned int sizes[], 1420 struct device *alloc_devs[]) 1421{ 1422 struct delta_ctx *ctx = vb2_get_drv_priv(vq); 1423 struct delta_dev *delta = ctx->dev; 1424 struct delta_streaminfo *streaminfo = &ctx->streaminfo; 1425 struct delta_frameinfo *frameinfo = &ctx->frameinfo; 1426 unsigned int size = frameinfo->size; 1427 1428 /* 1429 * the number of output buffers needed for decoding = 1430 * user need (*num_buffers given, usually for display pipeline) + 1431 * stream need (streaminfo->dpb) + 1432 * decoding peak smoothing (depends on DELTA IP perf) 1433 */ 1434 if (*num_buffers < DELTA_MIN_FRAME_USER) { 1435 dev_dbg(delta->dev, 1436 "%s num_buffers too low (%d), increasing to %d\n", 1437 ctx->name, *num_buffers, DELTA_MIN_FRAME_USER); 1438 *num_buffers = DELTA_MIN_FRAME_USER; 1439 } 1440 1441 *num_buffers += streaminfo->dpb + DELTA_PEAK_FRAME_SMOOTHING; 1442 1443 if (*num_buffers > DELTA_MAX_FRAMES) { 1444 dev_dbg(delta->dev, 1445 "%s output frame count too high (%d), cut to %d\n", 1446 ctx->name, *num_buffers, DELTA_MAX_FRAMES); 1447 *num_buffers = DELTA_MAX_FRAMES; 1448 } 1449 1450 if (*num_planes) 1451 return sizes[0] < size ? -EINVAL : 0; 1452 1453 /* single plane for Y and CbCr */ 1454 *num_planes = 1; 1455 1456 sizes[0] = size; 1457 1458 ctx->nb_of_frames = 0; 1459 1460 return 0; 1461} 1462 1463static int delta_vb2_frame_prepare(struct vb2_buffer *vb) 1464{ 1465 struct vb2_queue *q = vb->vb2_queue; 1466 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1467 struct delta_dev *delta = ctx->dev; 1468 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1469 struct delta_frame *frame = to_frame(vbuf); 1470 int ret = 0; 1471 1472 if (!frame->prepared) { 1473 frame->index = vbuf->vb2_buf.index; 1474 frame->vaddr = vb2_plane_vaddr(&vbuf->vb2_buf, 0); 1475 frame->paddr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0); 1476 frame->info = ctx->frameinfo; 1477 1478 ret = delta_setup_frame(ctx, frame); 1479 if (ret) { 1480 dev_err(delta->dev, 1481 "%s setup_frame() failed (%d)\n", 1482 ctx->name, ret); 1483 return ret; 1484 } 1485 frame->prepared = true; 1486 dev_dbg(delta->dev, 1487 "%s frame[%d] prepared; virt=0x%p, phy=0x%pad\n", 1488 ctx->name, vb->index, frame->vaddr, 1489 &frame->paddr); 1490 } 1491 1492 frame->flags = vbuf->flags; 1493 1494 return 0; 1495} 1496 1497static void delta_vb2_frame_finish(struct vb2_buffer *vb) 1498{ 1499 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1500 struct delta_frame *frame = to_frame(vbuf); 1501 1502 /* update V4L2 fields for user */ 1503 vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->info.size); 1504 vb->timestamp = frame->dts; 1505 vbuf->field = frame->field; 1506 vbuf->flags = frame->flags; 1507} 1508 1509static void delta_vb2_frame_queue(struct vb2_buffer *vb) 1510{ 1511 struct vb2_queue *q = vb->vb2_queue; 1512 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1513 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1514 struct delta_frame *frame = to_frame(vbuf); 1515 1516 if (ctx->state == DELTA_STATE_WF_EOS) { 1517 /* new frame available, EOS can now be completed */ 1518 delta_complete_eos(ctx, frame); 1519 1520 ctx->state = DELTA_STATE_EOS; 1521 1522 /* return, no need to recycle this buffer to decoder */ 1523 return; 1524 } 1525 1526 /* recycle this frame */ 1527 delta_recycle(ctx, frame); 1528} 1529 1530static void delta_vb2_frame_stop_streaming(struct vb2_queue *q) 1531{ 1532 struct delta_ctx *ctx = vb2_get_drv_priv(q); 1533 struct vb2_v4l2_buffer *vbuf; 1534 struct delta_frame *frame; 1535 const struct delta_dec *dec = ctx->dec; 1536 unsigned int i; 1537 1538 delta_flush_dts(ctx); 1539 1540 call_dec_op(dec, flush, ctx); 1541 1542 /* 1543 * return all buffers to vb2 in ERROR state 1544 * & reset each frame state to OUT 1545 */ 1546 for (i = 0; i < ctx->nb_of_frames; i++) { 1547 frame = ctx->frames[i]; 1548 if (!(frame->state & DELTA_FRAME_OUT)) { 1549 vbuf = &frame->vbuf; 1550 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR); 1551 } 1552 frame->state = DELTA_FRAME_OUT; 1553 } 1554 1555 ctx->frame_num = 0; 1556 1557 ctx->aborting = false; 1558} 1559 1560/* VB2 queue ops */ 1561static const struct vb2_ops delta_vb2_au_ops = { 1562 .queue_setup = delta_vb2_au_queue_setup, 1563 .buf_prepare = delta_vb2_au_prepare, 1564 .buf_queue = delta_vb2_au_queue, 1565 .wait_prepare = vb2_ops_wait_prepare, 1566 .wait_finish = vb2_ops_wait_finish, 1567 .start_streaming = delta_vb2_au_start_streaming, 1568 .stop_streaming = delta_vb2_au_stop_streaming, 1569}; 1570 1571static const struct vb2_ops delta_vb2_frame_ops = { 1572 .queue_setup = delta_vb2_frame_queue_setup, 1573 .buf_prepare = delta_vb2_frame_prepare, 1574 .buf_finish = delta_vb2_frame_finish, 1575 .buf_queue = delta_vb2_frame_queue, 1576 .wait_prepare = vb2_ops_wait_prepare, 1577 .wait_finish = vb2_ops_wait_finish, 1578 .stop_streaming = delta_vb2_frame_stop_streaming, 1579}; 1580 1581/* 1582 * V4L2 file operations 1583 */ 1584 1585static int queue_init(void *priv, 1586 struct vb2_queue *src_vq, struct vb2_queue *dst_vq) 1587{ 1588 struct vb2_queue *q; 1589 struct delta_ctx *ctx = priv; 1590 struct delta_dev *delta = ctx->dev; 1591 int ret; 1592 1593 /* setup vb2 queue for stream input */ 1594 q = src_vq; 1595 q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 1596 q->io_modes = VB2_MMAP | VB2_DMABUF; 1597 q->drv_priv = ctx; 1598 /* overload vb2 buf with private au struct */ 1599 q->buf_struct_size = sizeof(struct delta_au); 1600 q->ops = &delta_vb2_au_ops; 1601 q->mem_ops = &vb2_dma_contig_memops; 1602 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1603 q->lock = &delta->lock; 1604 q->dev = delta->dev; 1605 1606 ret = vb2_queue_init(q); 1607 if (ret) 1608 return ret; 1609 1610 /* setup vb2 queue for frame output */ 1611 q = dst_vq; 1612 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1613 q->io_modes = VB2_MMAP | VB2_DMABUF; 1614 q->drv_priv = ctx; 1615 /* overload vb2 buf with private frame struct */ 1616 q->buf_struct_size = sizeof(struct delta_frame) 1617 + DELTA_MAX_FRAME_PRIV_SIZE; 1618 q->ops = &delta_vb2_frame_ops; 1619 q->mem_ops = &vb2_dma_contig_memops; 1620 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1621 q->lock = &delta->lock; 1622 q->dev = delta->dev; 1623 1624 return vb2_queue_init(q); 1625} 1626 1627static int delta_open(struct file *file) 1628{ 1629 struct delta_dev *delta = video_drvdata(file); 1630 struct delta_ctx *ctx = NULL; 1631 int ret = 0; 1632 1633 mutex_lock(&delta->lock); 1634 1635 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 1636 if (!ctx) { 1637 ret = -ENOMEM; 1638 goto err; 1639 } 1640 ctx->dev = delta; 1641 1642 v4l2_fh_init(&ctx->fh, video_devdata(file)); 1643 file->private_data = &ctx->fh; 1644 v4l2_fh_add(&ctx->fh); 1645 1646 INIT_WORK(&ctx->run_work, delta_run_work); 1647 mutex_init(&ctx->lock); 1648 1649 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(delta->m2m_dev, ctx, 1650 queue_init); 1651 if (IS_ERR(ctx->fh.m2m_ctx)) { 1652 ret = PTR_ERR(ctx->fh.m2m_ctx); 1653 dev_err(delta->dev, "%s failed to initialize m2m context (%d)\n", 1654 DELTA_PREFIX, ret); 1655 goto err_fh_del; 1656 } 1657 1658 /* 1659 * wait stream format to determine which 1660 * decoder to open 1661 */ 1662 ctx->state = DELTA_STATE_WF_FORMAT; 1663 1664 INIT_LIST_HEAD(&ctx->dts); 1665 1666 /* set the instance name */ 1667 delta->instance_id++; 1668 snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]", 1669 delta->instance_id); 1670 1671 /* default parameters for frame and stream */ 1672 set_default_params(ctx); 1673 1674 /* enable ST231 clocks */ 1675 if (delta->clk_st231) 1676 if (clk_prepare_enable(delta->clk_st231)) 1677 dev_warn(delta->dev, "failed to enable st231 clk\n"); 1678 1679 /* enable FLASH_PROMIP clock */ 1680 if (delta->clk_flash_promip) 1681 if (clk_prepare_enable(delta->clk_flash_promip)) 1682 dev_warn(delta->dev, "failed to enable delta promip clk\n"); 1683 1684 mutex_unlock(&delta->lock); 1685 1686 dev_dbg(delta->dev, "%s decoder instance created\n", ctx->name); 1687 1688 return 0; 1689 1690err_fh_del: 1691 v4l2_fh_del(&ctx->fh); 1692 v4l2_fh_exit(&ctx->fh); 1693 kfree(ctx); 1694err: 1695 mutex_unlock(&delta->lock); 1696 1697 return ret; 1698} 1699 1700static int delta_release(struct file *file) 1701{ 1702 struct delta_ctx *ctx = to_ctx(file->private_data); 1703 struct delta_dev *delta = ctx->dev; 1704 const struct delta_dec *dec = ctx->dec; 1705 1706 mutex_lock(&delta->lock); 1707 1708 /* close decoder */ 1709 call_dec_op(dec, close, ctx); 1710 1711 /* 1712 * trace a summary of instance 1713 * before closing (debug purpose) 1714 */ 1715 delta_trace_summary(ctx); 1716 1717 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 1718 1719 v4l2_fh_del(&ctx->fh); 1720 v4l2_fh_exit(&ctx->fh); 1721 1722 /* disable ST231 clocks */ 1723 if (delta->clk_st231) 1724 clk_disable_unprepare(delta->clk_st231); 1725 1726 /* disable FLASH_PROMIP clock */ 1727 if (delta->clk_flash_promip) 1728 clk_disable_unprepare(delta->clk_flash_promip); 1729 1730 dev_dbg(delta->dev, "%s decoder instance released\n", ctx->name); 1731 1732 kfree(ctx); 1733 1734 mutex_unlock(&delta->lock); 1735 return 0; 1736} 1737 1738/* V4L2 file ops */ 1739static const struct v4l2_file_operations delta_fops = { 1740 .owner = THIS_MODULE, 1741 .open = delta_open, 1742 .release = delta_release, 1743 .unlocked_ioctl = video_ioctl2, 1744 .mmap = v4l2_m2m_fop_mmap, 1745 .poll = v4l2_m2m_fop_poll, 1746}; 1747 1748/* 1749 * Platform device operations 1750 */ 1751 1752static int delta_register_device(struct delta_dev *delta) 1753{ 1754 int ret; 1755 struct video_device *vdev; 1756 1757 if (!delta) 1758 return -ENODEV; 1759 1760 delta->m2m_dev = v4l2_m2m_init(&delta_m2m_ops); 1761 if (IS_ERR(delta->m2m_dev)) { 1762 dev_err(delta->dev, "%s failed to initialize v4l2-m2m device\n", 1763 DELTA_PREFIX); 1764 ret = PTR_ERR(delta->m2m_dev); 1765 goto err; 1766 } 1767 1768 vdev = video_device_alloc(); 1769 if (!vdev) { 1770 dev_err(delta->dev, "%s failed to allocate video device\n", 1771 DELTA_PREFIX); 1772 ret = -ENOMEM; 1773 goto err_m2m_release; 1774 } 1775 1776 vdev->fops = &delta_fops; 1777 vdev->ioctl_ops = &delta_ioctl_ops; 1778 vdev->release = video_device_release; 1779 vdev->lock = &delta->lock; 1780 vdev->vfl_dir = VFL_DIR_M2M; 1781 vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M; 1782 vdev->v4l2_dev = &delta->v4l2_dev; 1783 snprintf(vdev->name, sizeof(vdev->name), "%s-%s", 1784 DELTA_NAME, DELTA_FW_VERSION); 1785 1786 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1); 1787 if (ret) { 1788 dev_err(delta->dev, "%s failed to register video device\n", 1789 DELTA_PREFIX); 1790 goto err_vdev_release; 1791 } 1792 1793 delta->vdev = vdev; 1794 video_set_drvdata(vdev, delta); 1795 return 0; 1796 1797err_vdev_release: 1798 video_device_release(vdev); 1799err_m2m_release: 1800 v4l2_m2m_release(delta->m2m_dev); 1801err: 1802 return ret; 1803} 1804 1805static void delta_unregister_device(struct delta_dev *delta) 1806{ 1807 if (!delta) 1808 return; 1809 1810 if (delta->m2m_dev) 1811 v4l2_m2m_release(delta->m2m_dev); 1812 1813 video_unregister_device(delta->vdev); 1814} 1815 1816static int delta_probe(struct platform_device *pdev) 1817{ 1818 struct delta_dev *delta; 1819 struct device *dev = &pdev->dev; 1820 int ret; 1821 1822 delta = devm_kzalloc(dev, sizeof(*delta), GFP_KERNEL); 1823 if (!delta) { 1824 ret = -ENOMEM; 1825 goto err; 1826 } 1827 1828 delta->dev = dev; 1829 delta->pdev = pdev; 1830 platform_set_drvdata(pdev, delta); 1831 1832 mutex_init(&delta->lock); 1833 1834 /* get clock resources */ 1835 delta->clk_delta = devm_clk_get(dev, "delta"); 1836 if (IS_ERR(delta->clk_delta)) { 1837 dev_dbg(dev, "%s can't get delta clock\n", DELTA_PREFIX); 1838 delta->clk_delta = NULL; 1839 } 1840 1841 delta->clk_st231 = devm_clk_get(dev, "delta-st231"); 1842 if (IS_ERR(delta->clk_st231)) { 1843 dev_dbg(dev, "%s can't get delta-st231 clock\n", DELTA_PREFIX); 1844 delta->clk_st231 = NULL; 1845 } 1846 1847 delta->clk_flash_promip = devm_clk_get(dev, "delta-flash-promip"); 1848 if (IS_ERR(delta->clk_flash_promip)) { 1849 dev_dbg(dev, "%s can't get delta-flash-promip clock\n", 1850 DELTA_PREFIX); 1851 delta->clk_flash_promip = NULL; 1852 } 1853 1854 /* init pm_runtime used for power management */ 1855 pm_runtime_set_autosuspend_delay(dev, DELTA_HW_AUTOSUSPEND_DELAY_MS); 1856 pm_runtime_use_autosuspend(dev); 1857 pm_runtime_set_suspended(dev); 1858 pm_runtime_enable(dev); 1859 1860 /* init firmware ipc channel */ 1861 ret = delta_ipc_init(delta); 1862 if (ret) { 1863 dev_err(delta->dev, "%s failed to initialize firmware ipc channel\n", 1864 DELTA_PREFIX); 1865 goto err_pm_disable; 1866 } 1867 1868 /* register all available decoders */ 1869 register_decoders(delta); 1870 1871 /* register all supported formats */ 1872 register_formats(delta); 1873 1874 /* register on V4L2 */ 1875 ret = v4l2_device_register(dev, &delta->v4l2_dev); 1876 if (ret) { 1877 dev_err(delta->dev, "%s failed to register V4L2 device\n", 1878 DELTA_PREFIX); 1879 goto err_pm_disable; 1880 } 1881 1882 delta->work_queue = create_workqueue(DELTA_NAME); 1883 if (!delta->work_queue) { 1884 dev_err(delta->dev, "%s failed to allocate work queue\n", 1885 DELTA_PREFIX); 1886 ret = -ENOMEM; 1887 goto err_v4l2; 1888 } 1889 1890 /* register device */ 1891 ret = delta_register_device(delta); 1892 if (ret) 1893 goto err_work_queue; 1894 1895 dev_info(dev, "%s %s registered as /dev/video%d\n", 1896 DELTA_PREFIX, delta->vdev->name, delta->vdev->num); 1897 1898 return 0; 1899 1900err_work_queue: 1901 destroy_workqueue(delta->work_queue); 1902err_v4l2: 1903 v4l2_device_unregister(&delta->v4l2_dev); 1904err_pm_disable: 1905 pm_runtime_disable(dev); 1906err: 1907 return ret; 1908} 1909 1910static int delta_remove(struct platform_device *pdev) 1911{ 1912 struct delta_dev *delta = platform_get_drvdata(pdev); 1913 1914 delta_ipc_exit(delta); 1915 1916 delta_unregister_device(delta); 1917 1918 destroy_workqueue(delta->work_queue); 1919 1920 pm_runtime_put_autosuspend(delta->dev); 1921 pm_runtime_disable(delta->dev); 1922 1923 v4l2_device_unregister(&delta->v4l2_dev); 1924 1925 return 0; 1926} 1927 1928static int delta_runtime_suspend(struct device *dev) 1929{ 1930 struct delta_dev *delta = dev_get_drvdata(dev); 1931 1932 if (delta->clk_delta) 1933 clk_disable_unprepare(delta->clk_delta); 1934 1935 return 0; 1936} 1937 1938static int delta_runtime_resume(struct device *dev) 1939{ 1940 struct delta_dev *delta = dev_get_drvdata(dev); 1941 1942 if (delta->clk_delta) 1943 if (clk_prepare_enable(delta->clk_delta)) 1944 dev_warn(dev, "failed to prepare/enable delta clk\n"); 1945 1946 return 0; 1947} 1948 1949/* PM ops */ 1950static const struct dev_pm_ops delta_pm_ops = { 1951 .runtime_suspend = delta_runtime_suspend, 1952 .runtime_resume = delta_runtime_resume, 1953}; 1954 1955static const struct of_device_id delta_match_types[] = { 1956 { 1957 .compatible = "st,st-delta", 1958 }, 1959 { 1960 /* end node */ 1961 } 1962}; 1963 1964MODULE_DEVICE_TABLE(of, delta_match_types); 1965 1966static struct platform_driver delta_driver = { 1967 .probe = delta_probe, 1968 .remove = delta_remove, 1969 .driver = { 1970 .name = DELTA_NAME, 1971 .of_match_table = delta_match_types, 1972 .pm = &delta_pm_ops}, 1973}; 1974 1975module_platform_driver(delta_driver); 1976 1977MODULE_LICENSE("GPL"); 1978MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>"); 1979MODULE_DESCRIPTION("STMicroelectronics DELTA video decoder V4L2 driver"); 1980