1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * linux/drivers/media/platform/samsung/s5p-mfc/s5p_mfc_dec.c 4 * 5 * Copyright (C) 2011 Samsung Electronics Co., Ltd. 6 * http://www.samsung.com/ 7 * Kamil Debski, <k.debski@samsung.com> 8 */ 9 10 #include <linux/clk.h> 11 #include <linux/interrupt.h> 12 #include <linux/io.h> 13 #include <linux/module.h> 14 #include <linux/platform_device.h> 15 #include <linux/sched.h> 16 #include <linux/slab.h> 17 #include <linux/videodev2.h> 18 #include <linux/workqueue.h> 19 #include <media/v4l2-ctrls.h> 20 #include <media/v4l2-event.h> 21 #include <media/videobuf2-v4l2.h> 22 #include "s5p_mfc_common.h" 23 #include "s5p_mfc_ctrl.h" 24 #include "s5p_mfc_debug.h" 25 #include "s5p_mfc_dec.h" 26 #include "s5p_mfc_intr.h" 27 #include "s5p_mfc_opr.h" 28 #include "s5p_mfc_pm.h" 29 30 static struct s5p_mfc_fmt formats[] = { 31 { 32 .fourcc = V4L2_PIX_FMT_NV12MT_16X16, 33 .codec_mode = S5P_MFC_CODEC_NONE, 34 .type = MFC_FMT_RAW, 35 .num_planes = 2, 36 .versions = MFC_V6_BIT | MFC_V7_BIT, 37 }, 38 { 39 .fourcc = V4L2_PIX_FMT_NV12MT, 40 .codec_mode = S5P_MFC_CODEC_NONE, 41 .type = MFC_FMT_RAW, 42 .num_planes = 2, 43 .versions = MFC_V5_BIT, 44 }, 45 { 46 .fourcc = V4L2_PIX_FMT_NV12M, 47 .codec_mode = S5P_MFC_CODEC_NONE, 48 .type = MFC_FMT_RAW, 49 .num_planes = 2, 50 .versions = MFC_V6PLUS_BITS, 51 }, 52 { 53 .fourcc = V4L2_PIX_FMT_NV21M, 54 .codec_mode = S5P_MFC_CODEC_NONE, 55 .type = MFC_FMT_RAW, 56 .num_planes = 2, 57 .versions = MFC_V6PLUS_BITS, 58 }, 59 { 60 .fourcc = V4L2_PIX_FMT_H264, 61 .codec_mode = S5P_MFC_CODEC_H264_DEC, 62 .type = MFC_FMT_DEC, 63 .num_planes = 1, 64 .versions = MFC_V5PLUS_BITS, 65 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 66 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 67 }, 68 { 69 .fourcc = V4L2_PIX_FMT_H264_MVC, 70 .codec_mode = S5P_MFC_CODEC_H264_MVC_DEC, 71 .type = MFC_FMT_DEC, 72 .num_planes = 1, 73 .versions = MFC_V6PLUS_BITS, 74 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 75 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 76 }, 77 { 78 .fourcc = V4L2_PIX_FMT_H263, 79 .codec_mode = S5P_MFC_CODEC_H263_DEC, 80 .type = MFC_FMT_DEC, 81 .num_planes = 1, 82 .versions = MFC_V5PLUS_BITS, 83 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 84 }, 85 { 86 .fourcc = V4L2_PIX_FMT_MPEG1, 87 .codec_mode = S5P_MFC_CODEC_MPEG2_DEC, 88 .type = MFC_FMT_DEC, 89 .num_planes = 1, 90 .versions = MFC_V5PLUS_BITS, 91 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 92 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 93 }, 94 { 95 .fourcc = V4L2_PIX_FMT_MPEG2, 96 .codec_mode = S5P_MFC_CODEC_MPEG2_DEC, 97 .type = MFC_FMT_DEC, 98 .num_planes = 1, 99 .versions = MFC_V5PLUS_BITS, 100 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 101 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 102 }, 103 { 104 .fourcc = V4L2_PIX_FMT_MPEG4, 105 .codec_mode = S5P_MFC_CODEC_MPEG4_DEC, 106 .type = MFC_FMT_DEC, 107 .num_planes = 1, 108 .versions = MFC_V5PLUS_BITS, 109 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 110 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 111 }, 112 { 113 .fourcc = V4L2_PIX_FMT_XVID, 114 .codec_mode = S5P_MFC_CODEC_MPEG4_DEC, 115 .type = MFC_FMT_DEC, 116 .num_planes = 1, 117 .versions = MFC_V5PLUS_BITS, 118 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 119 }, 120 { 121 .fourcc = V4L2_PIX_FMT_VC1_ANNEX_G, 122 .codec_mode = S5P_MFC_CODEC_VC1_DEC, 123 .type = MFC_FMT_DEC, 124 .num_planes = 1, 125 .versions = MFC_V5PLUS_BITS, 126 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 127 }, 128 { 129 .fourcc = V4L2_PIX_FMT_VC1_ANNEX_L, 130 .codec_mode = S5P_MFC_CODEC_VC1RCV_DEC, 131 .type = MFC_FMT_DEC, 132 .num_planes = 1, 133 .versions = MFC_V5PLUS_BITS, 134 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 135 }, 136 { 137 .fourcc = V4L2_PIX_FMT_VP8, 138 .codec_mode = S5P_MFC_CODEC_VP8_DEC, 139 .type = MFC_FMT_DEC, 140 .num_planes = 1, 141 .versions = MFC_V6PLUS_BITS, 142 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 143 }, 144 { 145 .fourcc = V4L2_PIX_FMT_HEVC, 146 .codec_mode = S5P_FIMV_CODEC_HEVC_DEC, 147 .type = MFC_FMT_DEC, 148 .num_planes = 1, 149 .versions = MFC_V10_BIT, 150 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | 151 V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM, 152 }, 153 { 154 .fourcc = V4L2_PIX_FMT_VP9, 155 .codec_mode = S5P_FIMV_CODEC_VP9_DEC, 156 .type = MFC_FMT_DEC, 157 .num_planes = 1, 158 .versions = MFC_V10_BIT, 159 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION, 160 }, 161 }; 162 163 #define NUM_FORMATS ARRAY_SIZE(formats) 164 165 /* Find selected format description */ 166 static struct s5p_mfc_fmt *find_format(struct v4l2_format *f, unsigned int t) 167 { 168 unsigned int i; 169 170 for (i = 0; i < NUM_FORMATS; i++) { 171 if (formats[i].fourcc == f->fmt.pix_mp.pixelformat && 172 formats[i].type == t) 173 return &formats[i]; 174 } 175 return NULL; 176 } 177 178 static struct mfc_control controls[] = { 179 { 180 .id = V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY, 181 .type = V4L2_CTRL_TYPE_INTEGER, 182 .name = "H264 Display Delay", 183 .minimum = 0, 184 .maximum = 16383, 185 .step = 1, 186 .default_value = 0, 187 }, 188 { 189 .id = V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY, 190 .type = V4L2_CTRL_TYPE_INTEGER, 191 .minimum = 0, 192 .maximum = 16383, 193 .step = 1, 194 .default_value = 0, 195 }, 196 { 197 .id = V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE, 198 .type = V4L2_CTRL_TYPE_BOOLEAN, 199 .name = "H264 Display Delay Enable", 200 .minimum = 0, 201 .maximum = 1, 202 .step = 1, 203 .default_value = 0, 204 }, 205 { 206 .id = V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE, 207 .type = V4L2_CTRL_TYPE_BOOLEAN, 208 .minimum = 0, 209 .maximum = 1, 210 .default_value = 0, 211 }, 212 { 213 .id = V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER, 214 .type = V4L2_CTRL_TYPE_BOOLEAN, 215 .name = "Mpeg4 Loop Filter Enable", 216 .minimum = 0, 217 .maximum = 1, 218 .step = 1, 219 .default_value = 0, 220 }, 221 { 222 .id = V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE, 223 .type = V4L2_CTRL_TYPE_BOOLEAN, 224 .name = "Slice Interface Enable", 225 .minimum = 0, 226 .maximum = 1, 227 .step = 1, 228 .default_value = 0, 229 }, 230 { 231 .id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 232 .type = V4L2_CTRL_TYPE_INTEGER, 233 .name = "Minimum number of cap bufs", 234 .minimum = 1, 235 .maximum = 32, 236 .step = 1, 237 .default_value = 1, 238 .is_volatile = 1, 239 }, 240 }; 241 242 #define NUM_CTRLS ARRAY_SIZE(controls) 243 244 /* Check whether a context should be run on hardware */ 245 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx *ctx) 246 { 247 /* Context is to parse header */ 248 if (ctx->src_queue_cnt >= 1 && ctx->state == MFCINST_GOT_INST) 249 return 1; 250 /* Context is to decode a frame */ 251 if (ctx->src_queue_cnt >= 1 && 252 ctx->state == MFCINST_RUNNING && 253 ctx->dst_queue_cnt >= ctx->pb_count) 254 return 1; 255 /* Context is to return last frame */ 256 if (ctx->state == MFCINST_FINISHING && 257 ctx->dst_queue_cnt >= ctx->pb_count) 258 return 1; 259 /* Context is to set buffers */ 260 if (ctx->src_queue_cnt >= 1 && 261 ctx->state == MFCINST_HEAD_PARSED && 262 ctx->capture_state == QUEUE_BUFS_MMAPED) 263 return 1; 264 /* Resolution change */ 265 if ((ctx->state == MFCINST_RES_CHANGE_INIT || 266 ctx->state == MFCINST_RES_CHANGE_FLUSH) && 267 ctx->dst_queue_cnt >= ctx->pb_count) 268 return 1; 269 if (ctx->state == MFCINST_RES_CHANGE_END && 270 ctx->src_queue_cnt >= 1) 271 return 1; 272 mfc_debug(2, "ctx is not ready\n"); 273 return 0; 274 } 275 276 static const struct s5p_mfc_codec_ops decoder_codec_ops = { 277 .pre_seq_start = NULL, 278 .post_seq_start = NULL, 279 .pre_frame_start = NULL, 280 .post_frame_start = NULL, 281 }; 282 283 /* Query capabilities of the device */ 284 static int vidioc_querycap(struct file *file, void *priv, 285 struct v4l2_capability *cap) 286 { 287 struct s5p_mfc_dev *dev = video_drvdata(file); 288 289 strscpy(cap->driver, S5P_MFC_NAME, sizeof(cap->driver)); 290 strscpy(cap->card, dev->vfd_dec->name, sizeof(cap->card)); 291 return 0; 292 } 293 294 /* Enumerate format */ 295 static int vidioc_enum_fmt(struct file *file, struct v4l2_fmtdesc *f, 296 bool out) 297 { 298 struct s5p_mfc_dev *dev = video_drvdata(file); 299 int i, j = 0; 300 301 for (i = 0; i < ARRAY_SIZE(formats); ++i) { 302 if (out && formats[i].type != MFC_FMT_DEC) 303 continue; 304 else if (!out && formats[i].type != MFC_FMT_RAW) 305 continue; 306 else if ((dev->variant->version_bit & formats[i].versions) == 0) 307 continue; 308 309 if (j == f->index) 310 break; 311 ++j; 312 } 313 if (i == ARRAY_SIZE(formats)) 314 return -EINVAL; 315 f->pixelformat = formats[i].fourcc; 316 return 0; 317 } 318 319 static int vidioc_enum_fmt_vid_cap(struct file *file, void *pirv, 320 struct v4l2_fmtdesc *f) 321 { 322 return vidioc_enum_fmt(file, f, false); 323 } 324 325 static int vidioc_enum_fmt_vid_out(struct file *file, void *priv, 326 struct v4l2_fmtdesc *f) 327 { 328 return vidioc_enum_fmt(file, f, true); 329 } 330 331 /* Get format */ 332 static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f) 333 { 334 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 335 struct v4l2_pix_format_mplane *pix_mp; 336 337 mfc_debug_enter(); 338 pix_mp = &f->fmt.pix_mp; 339 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 340 (ctx->state == MFCINST_GOT_INST || ctx->state == 341 MFCINST_RES_CHANGE_END)) { 342 /* If the MFC is parsing the header, 343 * so wait until it is finished */ 344 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_SEQ_DONE_RET, 345 0); 346 } 347 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 348 ctx->state >= MFCINST_HEAD_PARSED && 349 ctx->state < MFCINST_ABORT) { 350 /* This is run on CAPTURE (decode output) */ 351 /* Width and height are set to the dimensions 352 of the movie, the buffer is bigger and 353 further processing stages should crop to this 354 rectangle. */ 355 pix_mp->width = ctx->buf_width; 356 pix_mp->height = ctx->buf_height; 357 pix_mp->field = V4L2_FIELD_NONE; 358 pix_mp->num_planes = 2; 359 /* Set pixelformat to the format in which MFC 360 outputs the decoded frame */ 361 pix_mp->pixelformat = ctx->dst_fmt->fourcc; 362 pix_mp->plane_fmt[0].bytesperline = ctx->buf_width; 363 pix_mp->plane_fmt[0].sizeimage = ctx->luma_size; 364 pix_mp->plane_fmt[1].bytesperline = ctx->buf_width; 365 pix_mp->plane_fmt[1].sizeimage = ctx->chroma_size; 366 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 367 /* This is run on OUTPUT 368 The buffer contains compressed image 369 so width and height have no meaning */ 370 pix_mp->width = 0; 371 pix_mp->height = 0; 372 pix_mp->field = V4L2_FIELD_NONE; 373 pix_mp->plane_fmt[0].bytesperline = ctx->dec_src_buf_size; 374 pix_mp->plane_fmt[0].sizeimage = ctx->dec_src_buf_size; 375 pix_mp->pixelformat = ctx->src_fmt->fourcc; 376 pix_mp->num_planes = ctx->src_fmt->num_planes; 377 } else { 378 mfc_err("Format could not be read\n"); 379 mfc_debug(2, "%s-- with error\n", __func__); 380 return -EINVAL; 381 } 382 mfc_debug_leave(); 383 return 0; 384 } 385 386 /* Try format */ 387 static int vidioc_try_fmt(struct file *file, void *priv, struct v4l2_format *f) 388 { 389 struct s5p_mfc_dev *dev = video_drvdata(file); 390 struct s5p_mfc_fmt *fmt; 391 392 mfc_debug(2, "Type is %d\n", f->type); 393 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 394 fmt = find_format(f, MFC_FMT_DEC); 395 if (!fmt) { 396 mfc_err("Unsupported format for source.\n"); 397 return -EINVAL; 398 } 399 if (fmt->codec_mode == S5P_FIMV_CODEC_NONE) { 400 mfc_err("Unknown codec\n"); 401 return -EINVAL; 402 } 403 if ((dev->variant->version_bit & fmt->versions) == 0) { 404 mfc_err("Unsupported format by this MFC version.\n"); 405 return -EINVAL; 406 } 407 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 408 fmt = find_format(f, MFC_FMT_RAW); 409 if (!fmt) { 410 mfc_err("Unsupported format for destination.\n"); 411 return -EINVAL; 412 } 413 if ((dev->variant->version_bit & fmt->versions) == 0) { 414 mfc_err("Unsupported format by this MFC version.\n"); 415 return -EINVAL; 416 } 417 } 418 419 return 0; 420 } 421 422 /* Set format */ 423 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f) 424 { 425 struct s5p_mfc_dev *dev = video_drvdata(file); 426 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 427 int ret = 0; 428 struct v4l2_pix_format_mplane *pix_mp; 429 struct s5p_mfc_buf_size *buf_size = dev->variant->buf_size; 430 431 mfc_debug_enter(); 432 ret = vidioc_try_fmt(file, priv, f); 433 pix_mp = &f->fmt.pix_mp; 434 if (ret) 435 return ret; 436 if (vb2_is_streaming(&ctx->vq_src) || vb2_is_streaming(&ctx->vq_dst)) { 437 v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__); 438 ret = -EBUSY; 439 goto out; 440 } 441 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 442 /* dst_fmt is validated by call to vidioc_try_fmt */ 443 ctx->dst_fmt = find_format(f, MFC_FMT_RAW); 444 ret = 0; 445 goto out; 446 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 447 /* src_fmt is validated by call to vidioc_try_fmt */ 448 ctx->src_fmt = find_format(f, MFC_FMT_DEC); 449 ctx->codec_mode = ctx->src_fmt->codec_mode; 450 mfc_debug(2, "The codec number is: %d\n", ctx->codec_mode); 451 pix_mp->height = 0; 452 pix_mp->width = 0; 453 if (pix_mp->plane_fmt[0].sizeimage == 0) 454 pix_mp->plane_fmt[0].sizeimage = ctx->dec_src_buf_size = 455 DEF_CPB_SIZE; 456 else if (pix_mp->plane_fmt[0].sizeimage > buf_size->cpb) 457 ctx->dec_src_buf_size = buf_size->cpb; 458 else 459 ctx->dec_src_buf_size = pix_mp->plane_fmt[0].sizeimage; 460 pix_mp->plane_fmt[0].bytesperline = 0; 461 ctx->state = MFCINST_INIT; 462 ret = 0; 463 goto out; 464 } else { 465 mfc_err("Wrong type error for S_FMT : %d", f->type); 466 ret = -EINVAL; 467 goto out; 468 } 469 470 out: 471 mfc_debug_leave(); 472 return ret; 473 } 474 475 static int reqbufs_output(struct s5p_mfc_dev *dev, struct s5p_mfc_ctx *ctx, 476 struct v4l2_requestbuffers *reqbufs) 477 { 478 int ret = 0; 479 480 s5p_mfc_clock_on(); 481 482 if (reqbufs->count == 0) { 483 mfc_debug(2, "Freeing buffers\n"); 484 ret = vb2_reqbufs(&ctx->vq_src, reqbufs); 485 if (ret) 486 goto out; 487 ctx->src_bufs_cnt = 0; 488 ctx->output_state = QUEUE_FREE; 489 } else if (ctx->output_state == QUEUE_FREE) { 490 /* Can only request buffers when we have a valid format set. */ 491 WARN_ON(ctx->src_bufs_cnt != 0); 492 if (ctx->state != MFCINST_INIT) { 493 mfc_err("Reqbufs called in an invalid state\n"); 494 ret = -EINVAL; 495 goto out; 496 } 497 498 mfc_debug(2, "Allocating %d buffers for OUTPUT queue\n", 499 reqbufs->count); 500 ret = vb2_reqbufs(&ctx->vq_src, reqbufs); 501 if (ret) 502 goto out; 503 504 ret = s5p_mfc_open_mfc_inst(dev, ctx); 505 if (ret) { 506 reqbufs->count = 0; 507 vb2_reqbufs(&ctx->vq_src, reqbufs); 508 goto out; 509 } 510 511 ctx->output_state = QUEUE_BUFS_REQUESTED; 512 } else { 513 mfc_err("Buffers have already been requested\n"); 514 ret = -EINVAL; 515 } 516 out: 517 s5p_mfc_clock_off(); 518 if (ret) 519 mfc_err("Failed allocating buffers for OUTPUT queue\n"); 520 return ret; 521 } 522 523 static int reqbufs_capture(struct s5p_mfc_dev *dev, struct s5p_mfc_ctx *ctx, 524 struct v4l2_requestbuffers *reqbufs) 525 { 526 int ret = 0; 527 528 s5p_mfc_clock_on(); 529 530 if (reqbufs->count == 0) { 531 mfc_debug(2, "Freeing buffers\n"); 532 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs); 533 if (ret) 534 goto out; 535 s5p_mfc_hw_call(dev->mfc_ops, release_codec_buffers, ctx); 536 ctx->dst_bufs_cnt = 0; 537 } else if (ctx->capture_state == QUEUE_FREE) { 538 WARN_ON(ctx->dst_bufs_cnt != 0); 539 mfc_debug(2, "Allocating %d buffers for CAPTURE queue\n", 540 reqbufs->count); 541 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs); 542 if (ret) 543 goto out; 544 545 ctx->capture_state = QUEUE_BUFS_REQUESTED; 546 ctx->total_dpb_count = reqbufs->count; 547 548 ret = s5p_mfc_hw_call(dev->mfc_ops, alloc_codec_buffers, ctx); 549 if (ret) { 550 mfc_err("Failed to allocate decoding buffers\n"); 551 reqbufs->count = 0; 552 vb2_reqbufs(&ctx->vq_dst, reqbufs); 553 ret = -ENOMEM; 554 ctx->capture_state = QUEUE_FREE; 555 goto out; 556 } 557 558 WARN_ON(ctx->dst_bufs_cnt != ctx->total_dpb_count); 559 ctx->capture_state = QUEUE_BUFS_MMAPED; 560 561 if (s5p_mfc_ctx_ready(ctx)) 562 set_work_bit_irqsave(ctx); 563 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev); 564 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_INIT_BUFFERS_RET, 565 0); 566 } else { 567 mfc_err("Buffers have already been requested\n"); 568 ret = -EINVAL; 569 } 570 out: 571 s5p_mfc_clock_off(); 572 if (ret) 573 mfc_err("Failed allocating buffers for CAPTURE queue\n"); 574 return ret; 575 } 576 577 /* Request buffers */ 578 static int vidioc_reqbufs(struct file *file, void *priv, 579 struct v4l2_requestbuffers *reqbufs) 580 { 581 struct s5p_mfc_dev *dev = video_drvdata(file); 582 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 583 584 if (reqbufs->memory != V4L2_MEMORY_MMAP) { 585 mfc_debug(2, "Only V4L2_MEMORY_MMAP is supported\n"); 586 return -EINVAL; 587 } 588 589 if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 590 return reqbufs_output(dev, ctx, reqbufs); 591 } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 592 return reqbufs_capture(dev, ctx, reqbufs); 593 } else { 594 mfc_err("Invalid type requested\n"); 595 return -EINVAL; 596 } 597 } 598 599 /* Query buffer */ 600 static int vidioc_querybuf(struct file *file, void *priv, 601 struct v4l2_buffer *buf) 602 { 603 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 604 int ret; 605 int i; 606 607 if (buf->memory != V4L2_MEMORY_MMAP) { 608 mfc_err("Only mmapped buffers can be used\n"); 609 return -EINVAL; 610 } 611 mfc_debug(2, "State: %d, buf->type: %d\n", ctx->state, buf->type); 612 if (ctx->state == MFCINST_GOT_INST && 613 buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 614 ret = vb2_querybuf(&ctx->vq_src, buf); 615 } else if (ctx->state == MFCINST_RUNNING && 616 buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 617 ret = vb2_querybuf(&ctx->vq_dst, buf); 618 for (i = 0; i < buf->length; i++) 619 buf->m.planes[i].m.mem_offset += DST_QUEUE_OFF_BASE; 620 } else { 621 mfc_err("vidioc_querybuf called in an inappropriate state\n"); 622 ret = -EINVAL; 623 } 624 mfc_debug_leave(); 625 return ret; 626 } 627 628 /* Queue a buffer */ 629 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf) 630 { 631 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 632 633 if (ctx->state == MFCINST_ERROR) { 634 mfc_err("Call on QBUF after unrecoverable error\n"); 635 return -EIO; 636 } 637 if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 638 return vb2_qbuf(&ctx->vq_src, NULL, buf); 639 else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 640 return vb2_qbuf(&ctx->vq_dst, NULL, buf); 641 return -EINVAL; 642 } 643 644 /* Dequeue a buffer */ 645 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf) 646 { 647 const struct v4l2_event ev = { 648 .type = V4L2_EVENT_EOS 649 }; 650 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 651 int ret; 652 653 if (ctx->state == MFCINST_ERROR) { 654 mfc_err_limited("Call on DQBUF after unrecoverable error\n"); 655 return -EIO; 656 } 657 658 switch (buf->type) { 659 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 660 return vb2_dqbuf(&ctx->vq_src, buf, file->f_flags & O_NONBLOCK); 661 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 662 ret = vb2_dqbuf(&ctx->vq_dst, buf, file->f_flags & O_NONBLOCK); 663 if (ret) 664 return ret; 665 666 if (ctx->state == MFCINST_FINISHED && 667 (ctx->dst_bufs[buf->index].flags & MFC_BUF_FLAG_EOS)) 668 v4l2_event_queue_fh(&ctx->fh, &ev); 669 return 0; 670 default: 671 return -EINVAL; 672 } 673 } 674 675 /* Export DMA buffer */ 676 static int vidioc_expbuf(struct file *file, void *priv, 677 struct v4l2_exportbuffer *eb) 678 { 679 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 680 681 if (eb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 682 return vb2_expbuf(&ctx->vq_src, eb); 683 if (eb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 684 return vb2_expbuf(&ctx->vq_dst, eb); 685 return -EINVAL; 686 } 687 688 /* Stream on */ 689 static int vidioc_streamon(struct file *file, void *priv, 690 enum v4l2_buf_type type) 691 { 692 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 693 int ret = -EINVAL; 694 695 mfc_debug_enter(); 696 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 697 ret = vb2_streamon(&ctx->vq_src, type); 698 else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 699 ret = vb2_streamon(&ctx->vq_dst, type); 700 mfc_debug_leave(); 701 return ret; 702 } 703 704 /* Stream off, which equals to a pause */ 705 static int vidioc_streamoff(struct file *file, void *priv, 706 enum v4l2_buf_type type) 707 { 708 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 709 710 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 711 return vb2_streamoff(&ctx->vq_src, type); 712 else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 713 return vb2_streamoff(&ctx->vq_dst, type); 714 return -EINVAL; 715 } 716 717 /* Set controls - v4l2 control framework */ 718 static int s5p_mfc_dec_s_ctrl(struct v4l2_ctrl *ctrl) 719 { 720 struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl); 721 722 switch (ctrl->id) { 723 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY: 724 case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY: 725 ctx->display_delay = ctrl->val; 726 break; 727 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE: 728 case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE: 729 ctx->display_delay_enable = ctrl->val; 730 break; 731 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: 732 ctx->loop_filter_mpeg4 = ctrl->val; 733 break; 734 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: 735 ctx->slice_interface = ctrl->val; 736 break; 737 default: 738 mfc_err("Invalid control 0x%08x\n", ctrl->id); 739 return -EINVAL; 740 } 741 return 0; 742 } 743 744 static int s5p_mfc_dec_g_v_ctrl(struct v4l2_ctrl *ctrl) 745 { 746 struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl); 747 struct s5p_mfc_dev *dev = ctx->dev; 748 749 switch (ctrl->id) { 750 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: 751 if (ctx->state >= MFCINST_HEAD_PARSED && 752 ctx->state < MFCINST_ABORT) { 753 ctrl->val = ctx->pb_count; 754 break; 755 } else if (ctx->state != MFCINST_INIT && 756 ctx->state != MFCINST_RES_CHANGE_END) { 757 v4l2_err(&dev->v4l2_dev, "Decoding not initialised\n"); 758 return -EINVAL; 759 } 760 /* Should wait for the header to be parsed */ 761 s5p_mfc_wait_for_done_ctx(ctx, 762 S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0); 763 if (ctx->state >= MFCINST_HEAD_PARSED && 764 ctx->state < MFCINST_ABORT) { 765 ctrl->val = ctx->pb_count; 766 } else { 767 v4l2_err(&dev->v4l2_dev, "Decoding not initialised\n"); 768 return -EINVAL; 769 } 770 break; 771 } 772 return 0; 773 } 774 775 776 static const struct v4l2_ctrl_ops s5p_mfc_dec_ctrl_ops = { 777 .s_ctrl = s5p_mfc_dec_s_ctrl, 778 .g_volatile_ctrl = s5p_mfc_dec_g_v_ctrl, 779 }; 780 781 /* Get compose information */ 782 static int vidioc_g_selection(struct file *file, void *priv, 783 struct v4l2_selection *s) 784 { 785 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 786 struct s5p_mfc_dev *dev = ctx->dev; 787 u32 left, right, top, bottom; 788 u32 width, height; 789 790 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 791 return -EINVAL; 792 793 if (ctx->state != MFCINST_HEAD_PARSED && 794 ctx->state != MFCINST_RUNNING && 795 ctx->state != MFCINST_FINISHING && 796 ctx->state != MFCINST_FINISHED) { 797 mfc_err("Can not get compose information\n"); 798 return -EINVAL; 799 } 800 if (ctx->src_fmt->fourcc == V4L2_PIX_FMT_H264) { 801 left = s5p_mfc_hw_call(dev->mfc_ops, get_crop_info_h, ctx); 802 right = left >> S5P_FIMV_SHARED_CROP_RIGHT_SHIFT; 803 left = left & S5P_FIMV_SHARED_CROP_LEFT_MASK; 804 top = s5p_mfc_hw_call(dev->mfc_ops, get_crop_info_v, ctx); 805 bottom = top >> S5P_FIMV_SHARED_CROP_BOTTOM_SHIFT; 806 top = top & S5P_FIMV_SHARED_CROP_TOP_MASK; 807 width = ctx->img_width - left - right; 808 height = ctx->img_height - top - bottom; 809 mfc_debug(2, "Composing info [h264]: l=%d t=%d w=%d h=%d (r=%d b=%d fw=%d fh=%d\n", 810 left, top, s->r.width, s->r.height, right, bottom, 811 ctx->buf_width, ctx->buf_height); 812 } else { 813 left = 0; 814 top = 0; 815 width = ctx->img_width; 816 height = ctx->img_height; 817 mfc_debug(2, "Composing info: w=%d h=%d fw=%d fh=%d\n", 818 s->r.width, s->r.height, ctx->buf_width, 819 ctx->buf_height); 820 } 821 822 switch (s->target) { 823 case V4L2_SEL_TGT_COMPOSE: 824 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 825 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 826 s->r.left = left; 827 s->r.top = top; 828 s->r.width = width; 829 s->r.height = height; 830 break; 831 default: 832 return -EINVAL; 833 } 834 return 0; 835 } 836 837 static int vidioc_decoder_cmd(struct file *file, void *priv, 838 struct v4l2_decoder_cmd *cmd) 839 { 840 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv); 841 struct s5p_mfc_dev *dev = ctx->dev; 842 struct s5p_mfc_buf *buf; 843 unsigned long flags; 844 845 switch (cmd->cmd) { 846 case V4L2_DEC_CMD_STOP: 847 if (cmd->flags != 0) 848 return -EINVAL; 849 850 if (!vb2_is_streaming(&ctx->vq_src)) 851 return -EINVAL; 852 853 spin_lock_irqsave(&dev->irqlock, flags); 854 if (list_empty(&ctx->src_queue)) { 855 mfc_err("EOS: empty src queue, entering finishing state"); 856 ctx->state = MFCINST_FINISHING; 857 if (s5p_mfc_ctx_ready(ctx)) 858 set_work_bit_irqsave(ctx); 859 spin_unlock_irqrestore(&dev->irqlock, flags); 860 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev); 861 } else { 862 mfc_err("EOS: marking last buffer of stream"); 863 buf = list_entry(ctx->src_queue.prev, 864 struct s5p_mfc_buf, list); 865 if (buf->flags & MFC_BUF_FLAG_USED) 866 ctx->state = MFCINST_FINISHING; 867 else 868 buf->flags |= MFC_BUF_FLAG_EOS; 869 spin_unlock_irqrestore(&dev->irqlock, flags); 870 } 871 break; 872 default: 873 return -EINVAL; 874 } 875 return 0; 876 } 877 878 static int vidioc_subscribe_event(struct v4l2_fh *fh, 879 const struct v4l2_event_subscription *sub) 880 { 881 switch (sub->type) { 882 case V4L2_EVENT_EOS: 883 return v4l2_event_subscribe(fh, sub, 2, NULL); 884 case V4L2_EVENT_SOURCE_CHANGE: 885 return v4l2_src_change_event_subscribe(fh, sub); 886 default: 887 return -EINVAL; 888 } 889 } 890 891 892 /* v4l2_ioctl_ops */ 893 static const struct v4l2_ioctl_ops s5p_mfc_dec_ioctl_ops = { 894 .vidioc_querycap = vidioc_querycap, 895 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 896 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out, 897 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt, 898 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt, 899 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt, 900 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt, 901 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt, 902 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt, 903 .vidioc_reqbufs = vidioc_reqbufs, 904 .vidioc_querybuf = vidioc_querybuf, 905 .vidioc_qbuf = vidioc_qbuf, 906 .vidioc_dqbuf = vidioc_dqbuf, 907 .vidioc_expbuf = vidioc_expbuf, 908 .vidioc_streamon = vidioc_streamon, 909 .vidioc_streamoff = vidioc_streamoff, 910 .vidioc_g_selection = vidioc_g_selection, 911 .vidioc_decoder_cmd = vidioc_decoder_cmd, 912 .vidioc_subscribe_event = vidioc_subscribe_event, 913 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 914 }; 915 916 static int s5p_mfc_queue_setup(struct vb2_queue *vq, 917 unsigned int *buf_count, 918 unsigned int *plane_count, unsigned int psize[], 919 struct device *alloc_devs[]) 920 { 921 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv); 922 struct s5p_mfc_dev *dev = ctx->dev; 923 924 /* Video output for decoding (source) 925 * this can be set after getting an instance */ 926 if (ctx->state == MFCINST_INIT && 927 vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 928 /* A single plane is required for input */ 929 *plane_count = 1; 930 if (*buf_count < 1) 931 *buf_count = 1; 932 if (*buf_count > MFC_MAX_BUFFERS) 933 *buf_count = MFC_MAX_BUFFERS; 934 /* Video capture for decoding (destination) 935 * this can be set after the header was parsed */ 936 } else if (ctx->state == MFCINST_HEAD_PARSED && 937 vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 938 /* Output plane count is 2 - one for Y and one for CbCr */ 939 *plane_count = 2; 940 /* Setup buffer count */ 941 if (*buf_count < ctx->pb_count) 942 *buf_count = ctx->pb_count; 943 if (*buf_count > ctx->pb_count + MFC_MAX_EXTRA_DPB) 944 *buf_count = ctx->pb_count + MFC_MAX_EXTRA_DPB; 945 if (*buf_count > MFC_MAX_BUFFERS) 946 *buf_count = MFC_MAX_BUFFERS; 947 } else { 948 mfc_err("State seems invalid. State = %d, vq->type = %d\n", 949 ctx->state, vq->type); 950 return -EINVAL; 951 } 952 mfc_debug(2, "Buffer count=%d, plane count=%d\n", 953 *buf_count, *plane_count); 954 if (ctx->state == MFCINST_HEAD_PARSED && 955 vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 956 psize[0] = ctx->luma_size; 957 psize[1] = ctx->chroma_size; 958 959 if (IS_MFCV6_PLUS(dev)) 960 alloc_devs[0] = ctx->dev->mem_dev[BANK_L_CTX]; 961 else 962 alloc_devs[0] = ctx->dev->mem_dev[BANK_R_CTX]; 963 alloc_devs[1] = ctx->dev->mem_dev[BANK_L_CTX]; 964 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE && 965 ctx->state == MFCINST_INIT) { 966 psize[0] = ctx->dec_src_buf_size; 967 alloc_devs[0] = ctx->dev->mem_dev[BANK_L_CTX]; 968 } else { 969 mfc_err("This video node is dedicated to decoding. Decoding not initialized\n"); 970 return -EINVAL; 971 } 972 return 0; 973 } 974 975 static int s5p_mfc_buf_init(struct vb2_buffer *vb) 976 { 977 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 978 struct vb2_queue *vq = vb->vb2_queue; 979 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv); 980 unsigned int i; 981 982 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 983 if (ctx->capture_state == QUEUE_BUFS_MMAPED) 984 return 0; 985 for (i = 0; i < ctx->dst_fmt->num_planes; i++) { 986 if (IS_ERR_OR_NULL(ERR_PTR( 987 vb2_dma_contig_plane_dma_addr(vb, i)))) { 988 mfc_err("Plane mem not allocated\n"); 989 return -EINVAL; 990 } 991 } 992 if (vb2_plane_size(vb, 0) < ctx->luma_size || 993 vb2_plane_size(vb, 1) < ctx->chroma_size) { 994 mfc_err("Plane buffer (CAPTURE) is too small\n"); 995 return -EINVAL; 996 } 997 i = vb->index; 998 ctx->dst_bufs[i].b = vbuf; 999 ctx->dst_bufs[i].cookie.raw.luma = 1000 vb2_dma_contig_plane_dma_addr(vb, 0); 1001 ctx->dst_bufs[i].cookie.raw.chroma = 1002 vb2_dma_contig_plane_dma_addr(vb, 1); 1003 ctx->dst_bufs_cnt++; 1004 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 1005 if (IS_ERR_OR_NULL(ERR_PTR( 1006 vb2_dma_contig_plane_dma_addr(vb, 0)))) { 1007 mfc_err("Plane memory not allocated\n"); 1008 return -EINVAL; 1009 } 1010 if (vb2_plane_size(vb, 0) < ctx->dec_src_buf_size) { 1011 mfc_err("Plane buffer (OUTPUT) is too small\n"); 1012 return -EINVAL; 1013 } 1014 1015 i = vb->index; 1016 ctx->src_bufs[i].b = vbuf; 1017 ctx->src_bufs[i].cookie.stream = 1018 vb2_dma_contig_plane_dma_addr(vb, 0); 1019 ctx->src_bufs_cnt++; 1020 } else { 1021 mfc_err("s5p_mfc_buf_init: unknown queue type\n"); 1022 return -EINVAL; 1023 } 1024 return 0; 1025 } 1026 1027 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count) 1028 { 1029 struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv); 1030 struct s5p_mfc_dev *dev = ctx->dev; 1031 1032 v4l2_ctrl_handler_setup(&ctx->ctrl_handler); 1033 if (ctx->state == MFCINST_FINISHING || 1034 ctx->state == MFCINST_FINISHED) 1035 ctx->state = MFCINST_RUNNING; 1036 /* If context is ready then dev = work->data;schedule it to run */ 1037 if (s5p_mfc_ctx_ready(ctx)) 1038 set_work_bit_irqsave(ctx); 1039 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev); 1040 return 0; 1041 } 1042 1043 static void s5p_mfc_stop_streaming(struct vb2_queue *q) 1044 { 1045 unsigned long flags; 1046 struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv); 1047 struct s5p_mfc_dev *dev = ctx->dev; 1048 int aborted = 0; 1049 1050 spin_lock_irqsave(&dev->irqlock, flags); 1051 if ((ctx->state == MFCINST_FINISHING || 1052 ctx->state == MFCINST_RUNNING) && 1053 dev->curr_ctx == ctx->num && dev->hw_lock) { 1054 ctx->state = MFCINST_ABORT; 1055 spin_unlock_irqrestore(&dev->irqlock, flags); 1056 s5p_mfc_wait_for_done_ctx(ctx, 1057 S5P_MFC_R2H_CMD_FRAME_DONE_RET, 0); 1058 aborted = 1; 1059 spin_lock_irqsave(&dev->irqlock, flags); 1060 } 1061 if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 1062 s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst); 1063 INIT_LIST_HEAD(&ctx->dst_queue); 1064 ctx->dst_queue_cnt = 0; 1065 ctx->dpb_flush_flag = 1; 1066 ctx->dec_dst_flag = 0; 1067 if (IS_MFCV6_PLUS(dev) && (ctx->state == MFCINST_RUNNING)) { 1068 ctx->state = MFCINST_FLUSH; 1069 set_work_bit_irqsave(ctx); 1070 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev); 1071 spin_unlock_irqrestore(&dev->irqlock, flags); 1072 if (s5p_mfc_wait_for_done_ctx(ctx, 1073 S5P_MFC_R2H_CMD_DPB_FLUSH_RET, 0)) 1074 mfc_err("Err flushing buffers\n"); 1075 spin_lock_irqsave(&dev->irqlock, flags); 1076 } 1077 } else if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 1078 s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src); 1079 INIT_LIST_HEAD(&ctx->src_queue); 1080 ctx->src_queue_cnt = 0; 1081 } 1082 if (aborted) 1083 ctx->state = MFCINST_RUNNING; 1084 spin_unlock_irqrestore(&dev->irqlock, flags); 1085 } 1086 1087 1088 static void s5p_mfc_buf_queue(struct vb2_buffer *vb) 1089 { 1090 struct vb2_queue *vq = vb->vb2_queue; 1091 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv); 1092 struct s5p_mfc_dev *dev = ctx->dev; 1093 unsigned long flags; 1094 struct s5p_mfc_buf *mfc_buf; 1095 1096 if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 1097 mfc_buf = &ctx->src_bufs[vb->index]; 1098 mfc_buf->flags &= ~MFC_BUF_FLAG_USED; 1099 spin_lock_irqsave(&dev->irqlock, flags); 1100 list_add_tail(&mfc_buf->list, &ctx->src_queue); 1101 ctx->src_queue_cnt++; 1102 spin_unlock_irqrestore(&dev->irqlock, flags); 1103 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 1104 mfc_buf = &ctx->dst_bufs[vb->index]; 1105 mfc_buf->flags &= ~MFC_BUF_FLAG_USED; 1106 /* Mark destination as available for use by MFC */ 1107 spin_lock_irqsave(&dev->irqlock, flags); 1108 set_bit(vb->index, &ctx->dec_dst_flag); 1109 list_add_tail(&mfc_buf->list, &ctx->dst_queue); 1110 ctx->dst_queue_cnt++; 1111 spin_unlock_irqrestore(&dev->irqlock, flags); 1112 } else { 1113 mfc_err("Unsupported buffer type (%d)\n", vq->type); 1114 } 1115 if (s5p_mfc_ctx_ready(ctx)) 1116 set_work_bit_irqsave(ctx); 1117 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev); 1118 } 1119 1120 static struct vb2_ops s5p_mfc_dec_qops = { 1121 .queue_setup = s5p_mfc_queue_setup, 1122 .wait_prepare = vb2_ops_wait_prepare, 1123 .wait_finish = vb2_ops_wait_finish, 1124 .buf_init = s5p_mfc_buf_init, 1125 .start_streaming = s5p_mfc_start_streaming, 1126 .stop_streaming = s5p_mfc_stop_streaming, 1127 .buf_queue = s5p_mfc_buf_queue, 1128 }; 1129 1130 const struct s5p_mfc_codec_ops *get_dec_codec_ops(void) 1131 { 1132 return &decoder_codec_ops; 1133 } 1134 1135 struct vb2_ops *get_dec_queue_ops(void) 1136 { 1137 return &s5p_mfc_dec_qops; 1138 } 1139 1140 const struct v4l2_ioctl_ops *get_dec_v4l2_ioctl_ops(void) 1141 { 1142 return &s5p_mfc_dec_ioctl_ops; 1143 } 1144 1145 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2WHICH(x) == V4L2_CTRL_CLASS_CODEC) \ 1146 && V4L2_CTRL_DRIVER_PRIV(x)) 1147 1148 int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx *ctx) 1149 { 1150 struct v4l2_ctrl_config cfg; 1151 int i; 1152 1153 v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS); 1154 if (ctx->ctrl_handler.error) { 1155 mfc_err("v4l2_ctrl_handler_init failed\n"); 1156 return ctx->ctrl_handler.error; 1157 } 1158 1159 for (i = 0; i < NUM_CTRLS; i++) { 1160 if (IS_MFC51_PRIV(controls[i].id)) { 1161 memset(&cfg, 0, sizeof(struct v4l2_ctrl_config)); 1162 cfg.ops = &s5p_mfc_dec_ctrl_ops; 1163 cfg.id = controls[i].id; 1164 cfg.min = controls[i].minimum; 1165 cfg.max = controls[i].maximum; 1166 cfg.def = controls[i].default_value; 1167 cfg.name = controls[i].name; 1168 cfg.type = controls[i].type; 1169 1170 cfg.step = controls[i].step; 1171 cfg.menu_skip_mask = 0; 1172 1173 ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler, 1174 &cfg, NULL); 1175 } else { 1176 ctx->ctrls[i] = v4l2_ctrl_new_std(&ctx->ctrl_handler, 1177 &s5p_mfc_dec_ctrl_ops, 1178 controls[i].id, controls[i].minimum, 1179 controls[i].maximum, controls[i].step, 1180 controls[i].default_value); 1181 } 1182 if (ctx->ctrl_handler.error) { 1183 mfc_err("Adding control (%d) failed\n", i); 1184 return ctx->ctrl_handler.error; 1185 } 1186 if (controls[i].is_volatile && ctx->ctrls[i]) 1187 ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE; 1188 } 1189 return 0; 1190 } 1191 1192 void s5p_mfc_dec_ctrls_delete(struct s5p_mfc_ctx *ctx) 1193 { 1194 int i; 1195 1196 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 1197 for (i = 0; i < NUM_CTRLS; i++) 1198 ctx->ctrls[i] = NULL; 1199 } 1200 1201 void s5p_mfc_dec_init(struct s5p_mfc_ctx *ctx) 1202 { 1203 struct v4l2_format f; 1204 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264; 1205 ctx->src_fmt = find_format(&f, MFC_FMT_DEC); 1206 if (IS_MFCV8_PLUS(ctx->dev)) 1207 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M; 1208 else if (IS_MFCV6_PLUS(ctx->dev)) 1209 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT_16X16; 1210 else 1211 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT; 1212 ctx->dst_fmt = find_format(&f, MFC_FMT_RAW); 1213 mfc_debug(2, "Default src_fmt is %p, dest_fmt is %p\n", 1214 ctx->src_fmt, ctx->dst_fmt); 1215 } 1216 1217