FILE
coda-common.c
File preview with syntax highlighting.
linux-6.19.14/drivers/media/platform/chips-media/coda/coda-common.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Coda multi-standard codec IP 4 * 5 * Copyright (C) 2012 Vista Silicon S.L. 6 * Javier Martin, <javier.martin@vista-silicon.com> 7 * Xavier Duret 8 */ 9 10#include <linux/clk.h> 11#include <linux/debugfs.h> 12#include <linux/delay.h> 13#include <linux/firmware.h> 14#include <linux/gcd.h> 15#include <linux/genalloc.h> 16#include <linux/idr.h> 17#include <linux/interrupt.h> 18#include <linux/io.h> 19#include <linux/irq.h> 20#include <linux/kfifo.h> 21#include <linux/module.h> 22#include <linux/of.h> 23#include <linux/of_platform.h> 24#include <linux/platform_device.h> 25#include <linux/pm_runtime.h> 26#include <linux/slab.h> 27#include <linux/videodev2.h> 28#include <linux/ratelimit.h> 29#include <linux/reset.h> 30 31#include <media/v4l2-ctrls.h> 32#include <media/v4l2-device.h> 33#include <media/v4l2-event.h> 34#include <media/v4l2-ioctl.h> 35#include <media/v4l2-mem2mem.h> 36#include <media/videobuf2-v4l2.h> 37#include <media/videobuf2-dma-contig.h> 38#include <media/videobuf2-vmalloc.h> 39 40#include "coda.h" 41#include "imx-vdoa.h" 42 43#define CODA_NAME "coda" 44 45#define CODADX6_MAX_INSTANCES 4 46#define CODA_MAX_FORMATS 5 47 48#define CODA_ISRAM_SIZE (2048 * 2) 49 50#define MIN_W 48 51#define MIN_H 16 52 53#define S_ALIGN 1 /* multiple of 2 */ 54#define W_ALIGN 1 /* multiple of 2 */ 55#define H_ALIGN 1 /* multiple of 2 */ 56 57#define fh_to_ctx(__fh) container_of(__fh, struct coda_ctx, fh) 58 59static inline struct coda_ctx *file_to_ctx(struct file *filp) 60{ 61 return fh_to_ctx(file_to_v4l2_fh(filp)); 62} 63 64int coda_debug; 65module_param(coda_debug, int, 0644); 66MODULE_PARM_DESC(coda_debug, "Debug level (0-2)"); 67 68static int disable_tiling; 69module_param(disable_tiling, int, 0644); 70MODULE_PARM_DESC(disable_tiling, "Disable tiled frame buffers"); 71 72static int disable_vdoa; 73module_param(disable_vdoa, int, 0644); 74MODULE_PARM_DESC(disable_vdoa, "Disable Video Data Order Adapter tiled to raster-scan conversion"); 75 76static int enable_bwb = 0; 77module_param(enable_bwb, int, 0644); 78MODULE_PARM_DESC(enable_bwb, "Enable BWB unit for decoding, may crash on certain streams"); 79 80void coda_write(struct coda_dev *dev, u32 data, u32 reg) 81{ 82 v4l2_dbg(3, coda_debug, &dev->v4l2_dev, 83 "%s: data=0x%x, reg=0x%x\n", __func__, data, reg); 84 writel(data, dev->regs_base + reg); 85} 86 87unsigned int coda_read(struct coda_dev *dev, u32 reg) 88{ 89 u32 data; 90 91 data = readl(dev->regs_base + reg); 92 v4l2_dbg(3, coda_debug, &dev->v4l2_dev, 93 "%s: data=0x%x, reg=0x%x\n", __func__, data, reg); 94 return data; 95} 96 97void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data, 98 struct vb2_v4l2_buffer *buf, unsigned int reg_y) 99{ 100 u32 base_y = vb2_dma_contig_plane_dma_addr(&buf->vb2_buf, 0); 101 u32 base_cb, base_cr; 102 103 switch (q_data->fourcc) { 104 case V4L2_PIX_FMT_YUYV: 105 /* Fallthrough: IN -H264-> CODA -NV12 MB-> VDOA -YUYV-> OUT */ 106 case V4L2_PIX_FMT_NV12: 107 case V4L2_PIX_FMT_YUV420: 108 default: 109 base_cb = base_y + q_data->bytesperline * q_data->height; 110 base_cr = base_cb + q_data->bytesperline * q_data->height / 4; 111 break; 112 case V4L2_PIX_FMT_YVU420: 113 /* Switch Cb and Cr for YVU420 format */ 114 base_cr = base_y + q_data->bytesperline * q_data->height; 115 base_cb = base_cr + q_data->bytesperline * q_data->height / 4; 116 break; 117 case V4L2_PIX_FMT_YUV422P: 118 base_cb = base_y + q_data->bytesperline * q_data->height; 119 base_cr = base_cb + q_data->bytesperline * q_data->height / 2; 120 } 121 122 coda_write(ctx->dev, base_y, reg_y); 123 coda_write(ctx->dev, base_cb, reg_y + 4); 124 coda_write(ctx->dev, base_cr, reg_y + 8); 125} 126 127#define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \ 128 { mode, src_fourcc, dst_fourcc, max_w, max_h } 129 130/* 131 * Arrays of codecs supported by each given version of Coda: 132 * i.MX27 -> codadx6 133 * i.MX51 -> codahx4 134 * i.MX53 -> coda7 135 * i.MX6 -> coda960 136 * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants 137 */ 138static const struct coda_codec codadx6_codecs[] = { 139 CODA_CODEC(CODADX6_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 720, 576), 140 CODA_CODEC(CODADX6_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 720, 576), 141}; 142 143static const struct coda_codec codahx4_codecs[] = { 144 CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 720, 576), 145 CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 146 CODA_CODEC(CODA7_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 147 CODA_CODEC(CODA7_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1280, 720), 148}; 149 150static const struct coda_codec coda7_codecs[] = { 151 CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 1280, 720), 152 CODA_CODEC(CODA7_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 1280, 720), 153 CODA_CODEC(CODA7_MODE_ENCODE_MJPG, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_JPEG, 8192, 8192), 154 CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 155 CODA_CODEC(CODA7_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 156 CODA_CODEC(CODA7_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1920, 1088), 157 CODA_CODEC(CODA7_MODE_DECODE_MJPG, V4L2_PIX_FMT_JPEG, V4L2_PIX_FMT_YUV420, 8192, 8192), 158}; 159 160static const struct coda_codec coda9_codecs[] = { 161 CODA_CODEC(CODA9_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 1920, 1088), 162 CODA_CODEC(CODA9_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 1920, 1088), 163 CODA_CODEC(CODA9_MODE_ENCODE_MJPG, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_JPEG, 8192, 8192), 164 CODA_CODEC(CODA9_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 165 CODA_CODEC(CODA9_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 166 CODA_CODEC(CODA9_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1920, 1088), 167 CODA_CODEC(CODA9_MODE_DECODE_MJPG, V4L2_PIX_FMT_JPEG, V4L2_PIX_FMT_YUV420, 8192, 8192), 168}; 169 170struct coda_video_device { 171 const char *name; 172 enum coda_inst_type type; 173 const struct coda_context_ops *ops; 174 bool direct; 175 u32 src_formats[CODA_MAX_FORMATS]; 176 u32 dst_formats[CODA_MAX_FORMATS]; 177}; 178 179static const struct coda_video_device coda_bit_encoder = { 180 .name = "coda-video-encoder", 181 .type = CODA_INST_ENCODER, 182 .ops = &coda_bit_encode_ops, 183 .src_formats = { 184 V4L2_PIX_FMT_NV12, 185 V4L2_PIX_FMT_YUV420, 186 V4L2_PIX_FMT_YVU420, 187 }, 188 .dst_formats = { 189 V4L2_PIX_FMT_H264, 190 V4L2_PIX_FMT_MPEG4, 191 }, 192}; 193 194static const struct coda_video_device coda_bit_jpeg_encoder = { 195 .name = "coda-jpeg-encoder", 196 .type = CODA_INST_ENCODER, 197 .ops = &coda_bit_encode_ops, 198 .src_formats = { 199 V4L2_PIX_FMT_NV12, 200 V4L2_PIX_FMT_YUV420, 201 V4L2_PIX_FMT_YVU420, 202 V4L2_PIX_FMT_YUV422P, 203 }, 204 .dst_formats = { 205 V4L2_PIX_FMT_JPEG, 206 }, 207}; 208 209static const struct coda_video_device coda_bit_decoder = { 210 .name = "coda-video-decoder", 211 .type = CODA_INST_DECODER, 212 .ops = &coda_bit_decode_ops, 213 .src_formats = { 214 V4L2_PIX_FMT_H264, 215 V4L2_PIX_FMT_MPEG2, 216 V4L2_PIX_FMT_MPEG4, 217 }, 218 .dst_formats = { 219 V4L2_PIX_FMT_NV12, 220 V4L2_PIX_FMT_YUV420, 221 V4L2_PIX_FMT_YVU420, 222 /* 223 * If V4L2_PIX_FMT_YUYV should be default, 224 * set_default_params() must be adjusted. 225 */ 226 V4L2_PIX_FMT_YUYV, 227 }, 228}; 229 230static const struct coda_video_device coda_bit_jpeg_decoder = { 231 .name = "coda-jpeg-decoder", 232 .type = CODA_INST_DECODER, 233 .ops = &coda_bit_decode_ops, 234 .src_formats = { 235 V4L2_PIX_FMT_JPEG, 236 }, 237 .dst_formats = { 238 V4L2_PIX_FMT_NV12, 239 V4L2_PIX_FMT_YUV420, 240 V4L2_PIX_FMT_YVU420, 241 V4L2_PIX_FMT_YUV422P, 242 }, 243}; 244 245static const struct coda_video_device coda9_jpeg_encoder = { 246 .name = "coda-jpeg-encoder", 247 .type = CODA_INST_ENCODER, 248 .ops = &coda9_jpeg_encode_ops, 249 .direct = true, 250 .src_formats = { 251 V4L2_PIX_FMT_NV12, 252 V4L2_PIX_FMT_YUV420, 253 V4L2_PIX_FMT_YVU420, 254 V4L2_PIX_FMT_YUV422P, 255 V4L2_PIX_FMT_GREY, 256 }, 257 .dst_formats = { 258 V4L2_PIX_FMT_JPEG, 259 }, 260}; 261 262static const struct coda_video_device coda9_jpeg_decoder = { 263 .name = "coda-jpeg-decoder", 264 .type = CODA_INST_DECODER, 265 .ops = &coda9_jpeg_decode_ops, 266 .direct = true, 267 .src_formats = { 268 V4L2_PIX_FMT_JPEG, 269 }, 270 .dst_formats = { 271 V4L2_PIX_FMT_NV12, 272 V4L2_PIX_FMT_YUV420, 273 V4L2_PIX_FMT_YVU420, 274 V4L2_PIX_FMT_YUV422P, 275 }, 276}; 277 278static const struct coda_video_device *codadx6_video_devices[] = { 279 &coda_bit_encoder, 280}; 281 282static const struct coda_video_device *codahx4_video_devices[] = { 283 &coda_bit_encoder, 284 &coda_bit_decoder, 285}; 286 287static const struct coda_video_device *coda7_video_devices[] = { 288 &coda_bit_jpeg_encoder, 289 &coda_bit_jpeg_decoder, 290 &coda_bit_encoder, 291 &coda_bit_decoder, 292}; 293 294static const struct coda_video_device *coda9_video_devices[] = { 295 &coda9_jpeg_encoder, 296 &coda9_jpeg_decoder, 297 &coda_bit_encoder, 298 &coda_bit_decoder, 299}; 300 301/* 302 * Normalize all supported YUV 4:2:0 formats to the value used in the codec 303 * tables. 304 */ 305static u32 coda_format_normalize_yuv(u32 fourcc) 306{ 307 switch (fourcc) { 308 case V4L2_PIX_FMT_NV12: 309 case V4L2_PIX_FMT_YUV420: 310 case V4L2_PIX_FMT_YVU420: 311 case V4L2_PIX_FMT_YUV422P: 312 case V4L2_PIX_FMT_YUYV: 313 return V4L2_PIX_FMT_YUV420; 314 default: 315 return fourcc; 316 } 317} 318 319static const struct coda_codec *coda_find_codec(struct coda_dev *dev, 320 int src_fourcc, int dst_fourcc) 321{ 322 const struct coda_codec *codecs = dev->devtype->codecs; 323 int num_codecs = dev->devtype->num_codecs; 324 int k; 325 326 src_fourcc = coda_format_normalize_yuv(src_fourcc); 327 dst_fourcc = coda_format_normalize_yuv(dst_fourcc); 328 if (src_fourcc == dst_fourcc) 329 return NULL; 330 331 for (k = 0; k < num_codecs; k++) { 332 if (codecs[k].src_fourcc == src_fourcc && 333 codecs[k].dst_fourcc == dst_fourcc) 334 break; 335 } 336 337 if (k == num_codecs) 338 return NULL; 339 340 return &codecs[k]; 341} 342 343static void coda_get_max_dimensions(struct coda_dev *dev, 344 const struct coda_codec *codec, 345 int *max_w, int *max_h) 346{ 347 const struct coda_codec *codecs = dev->devtype->codecs; 348 int num_codecs = dev->devtype->num_codecs; 349 unsigned int w, h; 350 int k; 351 352 if (codec) { 353 w = codec->max_w; 354 h = codec->max_h; 355 } else { 356 for (k = 0, w = 0, h = 0; k < num_codecs; k++) { 357 w = max(w, codecs[k].max_w); 358 h = max(h, codecs[k].max_h); 359 } 360 } 361 362 if (max_w) 363 *max_w = w; 364 if (max_h) 365 *max_h = h; 366} 367 368static const struct coda_video_device *to_coda_video_device(struct video_device 369 *vdev) 370{ 371 struct coda_dev *dev = video_get_drvdata(vdev); 372 unsigned int i = vdev - dev->vfd; 373 374 if (i >= dev->devtype->num_vdevs) 375 return NULL; 376 377 return dev->devtype->vdevs[i]; 378} 379 380const char *coda_product_name(int product) 381{ 382 static char buf[9]; 383 384 switch (product) { 385 case CODA_DX6: 386 return "CodaDx6"; 387 case CODA_HX4: 388 return "CodaHx4"; 389 case CODA_7541: 390 return "CODA7541"; 391 case CODA_960: 392 return "CODA960"; 393 default: 394 snprintf(buf, sizeof(buf), "(0x%04x)", product); 395 return buf; 396 } 397} 398 399static struct vdoa_data *coda_get_vdoa_data(void) 400{ 401 struct device_node *vdoa_node; 402 struct platform_device *vdoa_pdev; 403 struct vdoa_data *vdoa_data = NULL; 404 405 vdoa_node = of_find_compatible_node(NULL, NULL, "fsl,imx6q-vdoa"); 406 if (!vdoa_node) 407 return NULL; 408 409 vdoa_pdev = of_find_device_by_node(vdoa_node); 410 if (!vdoa_pdev) 411 goto out; 412 413 vdoa_data = platform_get_drvdata(vdoa_pdev); 414 if (!vdoa_data) 415 vdoa_data = ERR_PTR(-EPROBE_DEFER); 416 417 put_device(&vdoa_pdev->dev); 418out: 419 of_node_put(vdoa_node); 420 421 return vdoa_data; 422} 423 424/* 425 * V4L2 ioctl() operations. 426 */ 427static int coda_querycap(struct file *file, void *priv, 428 struct v4l2_capability *cap) 429{ 430 struct coda_ctx *ctx = file_to_ctx(file); 431 432 strscpy(cap->driver, CODA_NAME, sizeof(cap->driver)); 433 strscpy(cap->card, coda_product_name(ctx->dev->devtype->product), 434 sizeof(cap->card)); 435 strscpy(cap->bus_info, "platform:" CODA_NAME, sizeof(cap->bus_info)); 436 return 0; 437} 438 439static const u32 coda_formats_420[CODA_MAX_FORMATS] = { 440 V4L2_PIX_FMT_NV12, 441 V4L2_PIX_FMT_YUV420, 442 V4L2_PIX_FMT_YVU420, 443}; 444 445static int coda_enum_fmt(struct file *file, void *priv, 446 struct v4l2_fmtdesc *f) 447{ 448 struct video_device *vdev = video_devdata(file); 449 const struct coda_video_device *cvd = to_coda_video_device(vdev); 450 struct coda_ctx *ctx = file_to_ctx(file); 451 const u32 *formats; 452 453 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 454 formats = cvd->src_formats; 455 else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 456 struct coda_q_data *q_data_src; 457 struct vb2_queue *src_vq; 458 459 formats = cvd->dst_formats; 460 461 /* 462 * If the source format is already fixed, only allow the same 463 * chroma subsampling. 464 */ 465 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 466 src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, 467 V4L2_BUF_TYPE_VIDEO_OUTPUT); 468 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 469 vb2_is_streaming(src_vq)) { 470 if (ctx->params.jpeg_chroma_subsampling == 471 V4L2_JPEG_CHROMA_SUBSAMPLING_420) { 472 formats = coda_formats_420; 473 } else if (ctx->params.jpeg_chroma_subsampling == 474 V4L2_JPEG_CHROMA_SUBSAMPLING_422) { 475 f->pixelformat = V4L2_PIX_FMT_YUV422P; 476 return f->index ? -EINVAL : 0; 477 } 478 } 479 } else { 480 return -EINVAL; 481 } 482 483 if (f->index >= CODA_MAX_FORMATS || formats[f->index] == 0) 484 return -EINVAL; 485 486 /* Skip YUYV if the vdoa is not available */ 487 if (!ctx->vdoa && f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 488 formats[f->index] == V4L2_PIX_FMT_YUYV) 489 return -EINVAL; 490 491 f->pixelformat = formats[f->index]; 492 493 return 0; 494} 495 496static int coda_g_fmt(struct file *file, void *priv, 497 struct v4l2_format *f) 498{ 499 struct coda_q_data *q_data; 500 struct coda_ctx *ctx = file_to_ctx(file); 501 502 q_data = get_q_data(ctx, f->type); 503 if (!q_data) 504 return -EINVAL; 505 506 f->fmt.pix.field = V4L2_FIELD_NONE; 507 f->fmt.pix.pixelformat = q_data->fourcc; 508 f->fmt.pix.width = q_data->width; 509 f->fmt.pix.height = q_data->height; 510 f->fmt.pix.bytesperline = q_data->bytesperline; 511 512 f->fmt.pix.sizeimage = q_data->sizeimage; 513 f->fmt.pix.colorspace = ctx->colorspace; 514 f->fmt.pix.xfer_func = ctx->xfer_func; 515 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc; 516 f->fmt.pix.quantization = ctx->quantization; 517 518 return 0; 519} 520 521static int coda_try_pixelformat(struct coda_ctx *ctx, struct v4l2_format *f) 522{ 523 struct coda_q_data *q_data; 524 const u32 *formats; 525 int i; 526 527 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 528 formats = ctx->cvd->src_formats; 529 else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 530 formats = ctx->cvd->dst_formats; 531 else 532 return -EINVAL; 533 534 for (i = 0; i < CODA_MAX_FORMATS; i++) { 535 /* Skip YUYV if the vdoa is not available */ 536 if (!ctx->vdoa && f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 537 formats[i] == V4L2_PIX_FMT_YUYV) 538 continue; 539 540 if (formats[i] == f->fmt.pix.pixelformat) { 541 f->fmt.pix.pixelformat = formats[i]; 542 return 0; 543 } 544 } 545 546 /* Fall back to currently set pixelformat */ 547 q_data = get_q_data(ctx, f->type); 548 f->fmt.pix.pixelformat = q_data->fourcc; 549 550 return 0; 551} 552 553static int coda_try_fmt_vdoa(struct coda_ctx *ctx, struct v4l2_format *f, 554 bool *use_vdoa) 555{ 556 int err; 557 558 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 559 return -EINVAL; 560 561 if (!use_vdoa) 562 return -EINVAL; 563 564 if (!ctx->vdoa) { 565 *use_vdoa = false; 566 return 0; 567 } 568 569 err = vdoa_context_configure(NULL, round_up(f->fmt.pix.width, 16), 570 f->fmt.pix.height, f->fmt.pix.pixelformat); 571 if (err) { 572 *use_vdoa = false; 573 return 0; 574 } 575 576 *use_vdoa = true; 577 return 0; 578} 579 580static unsigned int coda_estimate_sizeimage(struct coda_ctx *ctx, u32 sizeimage, 581 u32 width, u32 height) 582{ 583 /* 584 * This is a rough estimate for sensible compressed buffer 585 * sizes (between 1 and 16 bits per pixel). This could be 586 * improved by better format specific worst case estimates. 587 */ 588 return round_up(clamp(sizeimage, width * height / 8, 589 width * height * 2), PAGE_SIZE); 590} 591 592static int coda_try_fmt(struct coda_ctx *ctx, const struct coda_codec *codec, 593 struct v4l2_format *f) 594{ 595 struct coda_dev *dev = ctx->dev; 596 unsigned int max_w, max_h; 597 enum v4l2_field field; 598 599 field = f->fmt.pix.field; 600 if (field == V4L2_FIELD_ANY) 601 field = V4L2_FIELD_NONE; 602 else if (V4L2_FIELD_NONE != field) 603 return -EINVAL; 604 605 /* V4L2 specification suggests the driver corrects the format struct 606 * if any of the dimensions is unsupported */ 607 f->fmt.pix.field = field; 608 609 coda_get_max_dimensions(dev, codec, &max_w, &max_h); 610 v4l_bound_align_image(&f->fmt.pix.width, MIN_W, max_w, W_ALIGN, 611 &f->fmt.pix.height, MIN_H, max_h, H_ALIGN, 612 S_ALIGN); 613 614 switch (f->fmt.pix.pixelformat) { 615 case V4L2_PIX_FMT_NV12: 616 case V4L2_PIX_FMT_YUV420: 617 case V4L2_PIX_FMT_YVU420: 618 /* 619 * Frame stride must be at least multiple of 8, 620 * but multiple of 16 for h.264 or JPEG 4:2:x 621 */ 622 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 623 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 624 f->fmt.pix.height * 3 / 2; 625 break; 626 case V4L2_PIX_FMT_YUYV: 627 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16) * 2; 628 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 629 f->fmt.pix.height; 630 break; 631 case V4L2_PIX_FMT_YUV422P: 632 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 633 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 634 f->fmt.pix.height * 2; 635 break; 636 case V4L2_PIX_FMT_GREY: 637 /* keep 16 pixel alignment of 8-bit pixel data */ 638 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 639 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height; 640 break; 641 case V4L2_PIX_FMT_JPEG: 642 case V4L2_PIX_FMT_H264: 643 case V4L2_PIX_FMT_MPEG4: 644 case V4L2_PIX_FMT_MPEG2: 645 f->fmt.pix.bytesperline = 0; 646 f->fmt.pix.sizeimage = coda_estimate_sizeimage(ctx, 647 f->fmt.pix.sizeimage, 648 f->fmt.pix.width, 649 f->fmt.pix.height); 650 break; 651 default: 652 BUG(); 653 } 654 655 return 0; 656} 657 658static int coda_try_fmt_vid_cap(struct file *file, void *priv, 659 struct v4l2_format *f) 660{ 661 struct coda_ctx *ctx = file_to_ctx(file); 662 const struct coda_q_data *q_data_src; 663 const struct coda_codec *codec; 664 struct vb2_queue *src_vq; 665 int hscale = 0; 666 int vscale = 0; 667 int ret; 668 bool use_vdoa; 669 670 ret = coda_try_pixelformat(ctx, f); 671 if (ret < 0) 672 return ret; 673 674 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 675 676 /* 677 * If the source format is already fixed, only allow the same output 678 * resolution. When decoding JPEG images, we also have to make sure to 679 * use the same chroma subsampling. 680 */ 681 src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 682 if (vb2_is_streaming(src_vq)) { 683 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 684 ctx->dev->devtype->product == CODA_960) { 685 hscale = coda_jpeg_scale(q_data_src->width, f->fmt.pix.width); 686 vscale = coda_jpeg_scale(q_data_src->height, f->fmt.pix.height); 687 } 688 f->fmt.pix.width = q_data_src->width >> hscale; 689 f->fmt.pix.height = q_data_src->height >> vscale; 690 691 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG) { 692 if (ctx->params.jpeg_chroma_subsampling == 693 V4L2_JPEG_CHROMA_SUBSAMPLING_420 && 694 f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) 695 f->fmt.pix.pixelformat = V4L2_PIX_FMT_NV12; 696 else if (ctx->params.jpeg_chroma_subsampling == 697 V4L2_JPEG_CHROMA_SUBSAMPLING_422) 698 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; 699 } 700 } 701 702 f->fmt.pix.colorspace = ctx->colorspace; 703 f->fmt.pix.xfer_func = ctx->xfer_func; 704 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc; 705 f->fmt.pix.quantization = ctx->quantization; 706 707 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 708 codec = coda_find_codec(ctx->dev, q_data_src->fourcc, 709 f->fmt.pix.pixelformat); 710 if (!codec) 711 return -EINVAL; 712 713 ret = coda_try_fmt(ctx, codec, f); 714 if (ret < 0) 715 return ret; 716 717 /* The decoders always write complete macroblocks or MCUs */ 718 if (ctx->inst_type == CODA_INST_DECODER) { 719 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16 >> hscale); 720 f->fmt.pix.height = round_up(f->fmt.pix.height, 16 >> vscale); 721 if (codec->src_fourcc == V4L2_PIX_FMT_JPEG && 722 f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { 723 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 724 f->fmt.pix.height * 2; 725 } else { 726 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 727 f->fmt.pix.height * 3 / 2; 728 } 729 730 ret = coda_try_fmt_vdoa(ctx, f, &use_vdoa); 731 if (ret < 0) 732 return ret; 733 734 if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) { 735 if (!use_vdoa) 736 return -EINVAL; 737 738 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16) * 2; 739 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 740 f->fmt.pix.height; 741 } 742 } 743 744 return 0; 745} 746 747static void coda_set_default_colorspace(struct v4l2_pix_format *fmt) 748{ 749 enum v4l2_colorspace colorspace; 750 751 if (fmt->pixelformat == V4L2_PIX_FMT_JPEG) 752 colorspace = V4L2_COLORSPACE_JPEG; 753 else if (fmt->width <= 720 && fmt->height <= 576) 754 colorspace = V4L2_COLORSPACE_SMPTE170M; 755 else 756 colorspace = V4L2_COLORSPACE_REC709; 757 758 fmt->colorspace = colorspace; 759 fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT; 760 fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 761 fmt->quantization = V4L2_QUANTIZATION_DEFAULT; 762} 763 764static int coda_try_fmt_vid_out(struct file *file, void *priv, 765 struct v4l2_format *f) 766{ 767 struct coda_ctx *ctx = file_to_ctx(file); 768 struct coda_dev *dev = ctx->dev; 769 const struct coda_q_data *q_data_dst; 770 const struct coda_codec *codec; 771 int ret; 772 773 ret = coda_try_pixelformat(ctx, f); 774 if (ret < 0) 775 return ret; 776 777 if (f->fmt.pix.colorspace == V4L2_COLORSPACE_DEFAULT) 778 coda_set_default_colorspace(&f->fmt.pix); 779 780 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 781 codec = coda_find_codec(dev, f->fmt.pix.pixelformat, q_data_dst->fourcc); 782 783 return coda_try_fmt(ctx, codec, f); 784} 785 786static int coda_s_fmt(struct coda_ctx *ctx, struct v4l2_format *f, 787 struct v4l2_rect *r) 788{ 789 struct coda_q_data *q_data; 790 struct vb2_queue *vq; 791 792 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); 793 794 q_data = get_q_data(ctx, f->type); 795 if (!q_data) 796 return -EINVAL; 797 798 if (vb2_is_busy(vq)) { 799 v4l2_err(&ctx->dev->v4l2_dev, "%s: %s queue busy: %d\n", 800 __func__, v4l2_type_names[f->type], vb2_get_num_buffers(vq)); 801 return -EBUSY; 802 } 803 804 q_data->fourcc = f->fmt.pix.pixelformat; 805 q_data->width = f->fmt.pix.width; 806 q_data->height = f->fmt.pix.height; 807 q_data->bytesperline = f->fmt.pix.bytesperline; 808 q_data->sizeimage = f->fmt.pix.sizeimage; 809 if (r) { 810 q_data->rect = *r; 811 } else { 812 q_data->rect.left = 0; 813 q_data->rect.top = 0; 814 q_data->rect.width = f->fmt.pix.width; 815 q_data->rect.height = f->fmt.pix.height; 816 } 817 818 switch (f->fmt.pix.pixelformat) { 819 case V4L2_PIX_FMT_YUYV: 820 ctx->tiled_map_type = GDI_TILED_FRAME_MB_RASTER_MAP; 821 break; 822 case V4L2_PIX_FMT_NV12: 823 if (!disable_tiling && ctx->use_bit && 824 ctx->dev->devtype->product == CODA_960) { 825 ctx->tiled_map_type = GDI_TILED_FRAME_MB_RASTER_MAP; 826 break; 827 } 828 fallthrough; 829 case V4L2_PIX_FMT_YUV420: 830 case V4L2_PIX_FMT_YVU420: 831 case V4L2_PIX_FMT_YUV422P: 832 ctx->tiled_map_type = GDI_LINEAR_FRAME_MAP; 833 break; 834 default: 835 break; 836 } 837 838 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP && 839 !coda_try_fmt_vdoa(ctx, f, &ctx->use_vdoa) && 840 ctx->use_vdoa) 841 vdoa_context_configure(ctx->vdoa, 842 round_up(f->fmt.pix.width, 16), 843 f->fmt.pix.height, 844 f->fmt.pix.pixelformat); 845 else 846 ctx->use_vdoa = false; 847 848 coda_dbg(1, ctx, "Setting %s format, wxh: %dx%d, fmt: %4.4s %c\n", 849 v4l2_type_names[f->type], q_data->width, q_data->height, 850 (char *)&q_data->fourcc, 851 (ctx->tiled_map_type == GDI_LINEAR_FRAME_MAP) ? 'L' : 'T'); 852 853 return 0; 854} 855 856static int coda_s_fmt_vid_cap(struct file *file, void *priv, 857 struct v4l2_format *f) 858{ 859 struct coda_ctx *ctx = file_to_ctx(file); 860 struct coda_q_data *q_data_src; 861 const struct coda_codec *codec; 862 struct v4l2_rect r; 863 int hscale = 0; 864 int vscale = 0; 865 int ret; 866 867 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 868 869 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 870 ctx->dev->devtype->product == CODA_960) { 871 hscale = coda_jpeg_scale(q_data_src->width, f->fmt.pix.width); 872 vscale = coda_jpeg_scale(q_data_src->height, f->fmt.pix.height); 873 } 874 875 ret = coda_try_fmt_vid_cap(file, priv, f); 876 if (ret) 877 return ret; 878 879 r.left = 0; 880 r.top = 0; 881 r.width = q_data_src->width >> hscale; 882 r.height = q_data_src->height >> vscale; 883 884 ret = coda_s_fmt(ctx, f, &r); 885 if (ret) 886 return ret; 887 888 if (ctx->inst_type != CODA_INST_ENCODER) 889 return 0; 890 891 /* Setting the coded format determines the selected codec */ 892 codec = coda_find_codec(ctx->dev, q_data_src->fourcc, 893 f->fmt.pix.pixelformat); 894 if (!codec) { 895 v4l2_err(&ctx->dev->v4l2_dev, "failed to determine codec\n"); 896 return -EINVAL; 897 } 898 ctx->codec = codec; 899 900 ctx->colorspace = f->fmt.pix.colorspace; 901 ctx->xfer_func = f->fmt.pix.xfer_func; 902 ctx->ycbcr_enc = f->fmt.pix.ycbcr_enc; 903 ctx->quantization = f->fmt.pix.quantization; 904 905 return 0; 906} 907 908static int coda_s_fmt_vid_out(struct file *file, void *priv, 909 struct v4l2_format *f) 910{ 911 struct coda_ctx *ctx = file_to_ctx(file); 912 const struct coda_codec *codec; 913 struct v4l2_format f_cap; 914 struct vb2_queue *dst_vq; 915 int ret; 916 917 ret = coda_try_fmt_vid_out(file, priv, f); 918 if (ret) 919 return ret; 920 921 ret = coda_s_fmt(ctx, f, NULL); 922 if (ret) 923 return ret; 924 925 ctx->colorspace = f->fmt.pix.colorspace; 926 ctx->xfer_func = f->fmt.pix.xfer_func; 927 ctx->ycbcr_enc = f->fmt.pix.ycbcr_enc; 928 ctx->quantization = f->fmt.pix.quantization; 929 930 if (ctx->inst_type != CODA_INST_DECODER) 931 return 0; 932 933 /* Setting the coded format determines the selected codec */ 934 codec = coda_find_codec(ctx->dev, f->fmt.pix.pixelformat, 935 V4L2_PIX_FMT_YUV420); 936 if (!codec) { 937 v4l2_err(&ctx->dev->v4l2_dev, "failed to determine codec\n"); 938 return -EINVAL; 939 } 940 ctx->codec = codec; 941 942 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 943 944 /* 945 * Setting the capture queue format is not possible while the capture 946 * queue is still busy. This is not an error, but the user will have to 947 * make sure themselves that the capture format is set correctly before 948 * starting the output queue again. 949 */ 950 if (vb2_is_busy(dst_vq)) 951 return 0; 952 953 memset(&f_cap, 0, sizeof(f_cap)); 954 f_cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 955 coda_g_fmt(file, priv, &f_cap); 956 f_cap.fmt.pix.width = f->fmt.pix.width; 957 f_cap.fmt.pix.height = f->fmt.pix.height; 958 959 return coda_s_fmt_vid_cap(file, priv, &f_cap); 960} 961 962static int coda_reqbufs(struct file *file, void *priv, 963 struct v4l2_requestbuffers *rb) 964{ 965 struct coda_ctx *ctx = file_to_ctx(file); 966 int ret; 967 968 ret = v4l2_m2m_reqbufs(file, ctx->fh.m2m_ctx, rb); 969 if (ret) 970 return ret; 971 972 /* 973 * Allow to allocate instance specific per-context buffers, such as 974 * bitstream ringbuffer, slice buffer, work buffer, etc. if needed. 975 */ 976 if (rb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT && ctx->ops->reqbufs) 977 return ctx->ops->reqbufs(ctx, rb); 978 979 return 0; 980} 981 982static int coda_qbuf(struct file *file, void *priv, 983 struct v4l2_buffer *buf) 984{ 985 struct coda_ctx *ctx = file_to_ctx(file); 986 987 if (ctx->inst_type == CODA_INST_DECODER && 988 buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 989 buf->flags &= ~V4L2_BUF_FLAG_LAST; 990 991 return v4l2_m2m_qbuf(file, ctx->fh.m2m_ctx, buf); 992} 993 994static int coda_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf) 995{ 996 struct coda_ctx *ctx = file_to_ctx(file); 997 int ret; 998 999 ret = v4l2_m2m_dqbuf(file, ctx->fh.m2m_ctx, buf); 1000 1001 if (ctx->inst_type == CODA_INST_DECODER && 1002 buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1003 buf->flags &= ~V4L2_BUF_FLAG_LAST; 1004 1005 return ret; 1006} 1007 1008void coda_m2m_buf_done(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf, 1009 enum vb2_buffer_state state) 1010{ 1011 const struct v4l2_event eos_event = { 1012 .type = V4L2_EVENT_EOS 1013 }; 1014 1015 if (buf->flags & V4L2_BUF_FLAG_LAST) 1016 v4l2_event_queue_fh(&ctx->fh, &eos_event); 1017 1018 v4l2_m2m_buf_done(buf, state); 1019} 1020 1021static int coda_g_selection(struct file *file, void *fh, 1022 struct v4l2_selection *s) 1023{ 1024 struct coda_ctx *ctx = file_to_ctx(file); 1025 struct coda_q_data *q_data; 1026 struct v4l2_rect r, *rsel; 1027 1028 q_data = get_q_data(ctx, s->type); 1029 if (!q_data) 1030 return -EINVAL; 1031 1032 r.left = 0; 1033 r.top = 0; 1034 r.width = q_data->width; 1035 r.height = q_data->height; 1036 rsel = &q_data->rect; 1037 1038 switch (s->target) { 1039 case V4L2_SEL_TGT_CROP_DEFAULT: 1040 case V4L2_SEL_TGT_CROP_BOUNDS: 1041 rsel = &r; 1042 fallthrough; 1043 case V4L2_SEL_TGT_CROP: 1044 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT || 1045 ctx->inst_type == CODA_INST_DECODER) 1046 return -EINVAL; 1047 break; 1048 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 1049 case V4L2_SEL_TGT_COMPOSE_PADDED: 1050 rsel = &r; 1051 fallthrough; 1052 case V4L2_SEL_TGT_COMPOSE: 1053 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 1054 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1055 ctx->inst_type == CODA_INST_ENCODER) 1056 return -EINVAL; 1057 break; 1058 default: 1059 return -EINVAL; 1060 } 1061 1062 s->r = *rsel; 1063 1064 return 0; 1065} 1066 1067static int coda_s_selection(struct file *file, void *fh, 1068 struct v4l2_selection *s) 1069{ 1070 struct coda_ctx *ctx = file_to_ctx(file); 1071 struct coda_q_data *q_data; 1072 1073 switch (s->target) { 1074 case V4L2_SEL_TGT_CROP: 1075 if (ctx->inst_type == CODA_INST_ENCODER && 1076 s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1077 q_data = get_q_data(ctx, s->type); 1078 if (!q_data) 1079 return -EINVAL; 1080 1081 s->r.left = 0; 1082 s->r.top = 0; 1083 s->r.width = clamp(s->r.width, 2U, q_data->width); 1084 s->r.height = clamp(s->r.height, 2U, q_data->height); 1085 1086 if (s->flags & V4L2_SEL_FLAG_LE) { 1087 s->r.width = round_up(s->r.width, 2); 1088 s->r.height = round_up(s->r.height, 2); 1089 } else { 1090 s->r.width = round_down(s->r.width, 2); 1091 s->r.height = round_down(s->r.height, 2); 1092 } 1093 1094 q_data->rect = s->r; 1095 1096 coda_dbg(1, ctx, "Setting crop rectangle: %dx%d\n", 1097 s->r.width, s->r.height); 1098 1099 return 0; 1100 } 1101 fallthrough; 1102 case V4L2_SEL_TGT_NATIVE_SIZE: 1103 case V4L2_SEL_TGT_COMPOSE: 1104 return coda_g_selection(file, fh, s); 1105 default: 1106 /* v4l2-compliance expects this to fail for read-only targets */ 1107 return -EINVAL; 1108 } 1109} 1110 1111static void coda_wake_up_capture_queue(struct coda_ctx *ctx) 1112{ 1113 struct vb2_queue *dst_vq; 1114 1115 coda_dbg(1, ctx, "waking up capture queue\n"); 1116 1117 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1118 dst_vq->last_buffer_dequeued = true; 1119 wake_up(&dst_vq->done_wq); 1120} 1121 1122static int coda_encoder_cmd(struct file *file, void *fh, 1123 struct v4l2_encoder_cmd *ec) 1124{ 1125 struct coda_ctx *ctx = file_to_ctx(file); 1126 struct vb2_v4l2_buffer *buf; 1127 int ret; 1128 1129 ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, ec); 1130 if (ret < 0) 1131 return ret; 1132 1133 mutex_lock(&ctx->wakeup_mutex); 1134 buf = v4l2_m2m_last_src_buf(ctx->fh.m2m_ctx); 1135 if (buf) { 1136 /* 1137 * If the last output buffer is still on the queue, make sure 1138 * that decoder finish_run will see the last flag and report it 1139 * to userspace. 1140 */ 1141 buf->flags |= V4L2_BUF_FLAG_LAST; 1142 } else { 1143 /* Set the stream-end flag on this context */ 1144 ctx->bit_stream_param |= CODA_BIT_STREAM_END_FLAG; 1145 1146 /* 1147 * If the last output buffer has already been taken from the 1148 * queue, wake up the capture queue and signal end of stream 1149 * via the -EPIPE mechanism. 1150 */ 1151 coda_wake_up_capture_queue(ctx); 1152 } 1153 mutex_unlock(&ctx->wakeup_mutex); 1154 1155 return 0; 1156} 1157 1158static bool coda_mark_last_meta(struct coda_ctx *ctx) 1159{ 1160 struct coda_buffer_meta *meta; 1161 1162 coda_dbg(1, ctx, "marking last meta\n"); 1163 1164 spin_lock(&ctx->buffer_meta_lock); 1165 if (list_empty(&ctx->buffer_meta_list)) { 1166 spin_unlock(&ctx->buffer_meta_lock); 1167 return false; 1168 } 1169 1170 meta = list_last_entry(&ctx->buffer_meta_list, struct coda_buffer_meta, 1171 list); 1172 meta->last = true; 1173 1174 spin_unlock(&ctx->buffer_meta_lock); 1175 return true; 1176} 1177 1178static bool coda_mark_last_dst_buf(struct coda_ctx *ctx) 1179{ 1180 struct vb2_v4l2_buffer *buf; 1181 struct vb2_buffer *dst_vb; 1182 struct vb2_queue *dst_vq; 1183 unsigned long flags; 1184 1185 coda_dbg(1, ctx, "marking last capture buffer\n"); 1186 1187 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1188 spin_lock_irqsave(&dst_vq->done_lock, flags); 1189 if (list_empty(&dst_vq->done_list)) { 1190 spin_unlock_irqrestore(&dst_vq->done_lock, flags); 1191 return false; 1192 } 1193 1194 dst_vb = list_last_entry(&dst_vq->done_list, struct vb2_buffer, 1195 done_entry); 1196 buf = to_vb2_v4l2_buffer(dst_vb); 1197 buf->flags |= V4L2_BUF_FLAG_LAST; 1198 1199 spin_unlock_irqrestore(&dst_vq->done_lock, flags); 1200 return true; 1201} 1202 1203static int coda_decoder_cmd(struct file *file, void *fh, 1204 struct v4l2_decoder_cmd *dc) 1205{ 1206 struct coda_ctx *ctx = file_to_ctx(file); 1207 struct coda_dev *dev = ctx->dev; 1208 struct vb2_v4l2_buffer *buf; 1209 struct vb2_queue *dst_vq; 1210 bool stream_end; 1211 bool wakeup; 1212 int ret; 1213 1214 ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, dc); 1215 if (ret < 0) 1216 return ret; 1217 1218 switch (dc->cmd) { 1219 case V4L2_DEC_CMD_START: 1220 mutex_lock(&dev->coda_mutex); 1221 mutex_lock(&ctx->bitstream_mutex); 1222 coda_bitstream_flush(ctx); 1223 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, 1224 V4L2_BUF_TYPE_VIDEO_CAPTURE); 1225 vb2_clear_last_buffer_dequeued(dst_vq); 1226 ctx->bit_stream_param &= ~CODA_BIT_STREAM_END_FLAG; 1227 coda_fill_bitstream(ctx, NULL); 1228 mutex_unlock(&ctx->bitstream_mutex); 1229 mutex_unlock(&dev->coda_mutex); 1230 break; 1231 case V4L2_DEC_CMD_STOP: 1232 stream_end = false; 1233 wakeup = false; 1234 1235 mutex_lock(&ctx->wakeup_mutex); 1236 1237 buf = v4l2_m2m_last_src_buf(ctx->fh.m2m_ctx); 1238 if (buf) { 1239 coda_dbg(1, ctx, "marking last pending buffer\n"); 1240 1241 /* Mark last buffer */ 1242 buf->flags |= V4L2_BUF_FLAG_LAST; 1243 1244 if (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) == 0) { 1245 coda_dbg(1, ctx, "all remaining buffers queued\n"); 1246 stream_end = true; 1247 } 1248 } else { 1249 if (ctx->use_bit) 1250 if (coda_mark_last_meta(ctx)) 1251 stream_end = true; 1252 else 1253 wakeup = true; 1254 else 1255 if (!coda_mark_last_dst_buf(ctx)) 1256 wakeup = true; 1257 } 1258 1259 if (stream_end) { 1260 coda_dbg(1, ctx, "all remaining buffers queued\n"); 1261 1262 /* Set the stream-end flag on this context */ 1263 coda_bit_stream_end_flag(ctx); 1264 ctx->hold = false; 1265 v4l2_m2m_try_schedule(ctx->fh.m2m_ctx); 1266 } 1267 1268 if (wakeup) { 1269 /* If there is no buffer in flight, wake up */ 1270 coda_wake_up_capture_queue(ctx); 1271 } 1272 1273 mutex_unlock(&ctx->wakeup_mutex); 1274 break; 1275 default: 1276 return -EINVAL; 1277 } 1278 1279 return 0; 1280} 1281 1282static int coda_enum_framesizes(struct file *file, void *fh, 1283 struct v4l2_frmsizeenum *fsize) 1284{ 1285 struct coda_ctx *ctx = file_to_ctx(file); 1286 struct coda_q_data *q_data_dst; 1287 const struct coda_codec *codec; 1288 1289 if (fsize->index) 1290 return -EINVAL; 1291 1292 if (coda_format_normalize_yuv(fsize->pixel_format) == 1293 V4L2_PIX_FMT_YUV420) { 1294 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1295 codec = coda_find_codec(ctx->dev, fsize->pixel_format, 1296 q_data_dst->fourcc); 1297 } else { 1298 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420, 1299 fsize->pixel_format); 1300 } 1301 if (!codec) 1302 return -EINVAL; 1303 1304 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS; 1305 fsize->stepwise.min_width = MIN_W; 1306 fsize->stepwise.max_width = codec->max_w; 1307 fsize->stepwise.step_width = 1; 1308 fsize->stepwise.min_height = MIN_H; 1309 fsize->stepwise.max_height = codec->max_h; 1310 fsize->stepwise.step_height = 1; 1311 1312 return 0; 1313} 1314 1315static int coda_enum_frameintervals(struct file *file, void *fh, 1316 struct v4l2_frmivalenum *f) 1317{ 1318 struct coda_ctx *ctx = file_to_ctx(file); 1319 struct coda_q_data *q_data; 1320 const struct coda_codec *codec; 1321 1322 if (f->index) 1323 return -EINVAL; 1324 1325 /* Disallow YUYV if the vdoa is not available */ 1326 if (!ctx->vdoa && f->pixel_format == V4L2_PIX_FMT_YUYV) 1327 return -EINVAL; 1328 1329 if (coda_format_normalize_yuv(f->pixel_format) == V4L2_PIX_FMT_YUV420) { 1330 q_data = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1331 codec = coda_find_codec(ctx->dev, f->pixel_format, 1332 q_data->fourcc); 1333 } else { 1334 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420, 1335 f->pixel_format); 1336 } 1337 if (!codec) 1338 return -EINVAL; 1339 1340 if (f->width < MIN_W || f->width > codec->max_w || 1341 f->height < MIN_H || f->height > codec->max_h) 1342 return -EINVAL; 1343 1344 f->type = V4L2_FRMIVAL_TYPE_CONTINUOUS; 1345 f->stepwise.min.numerator = 1; 1346 f->stepwise.min.denominator = 65535; 1347 f->stepwise.max.numerator = 65536; 1348 f->stepwise.max.denominator = 1; 1349 f->stepwise.step.numerator = 1; 1350 f->stepwise.step.denominator = 1; 1351 1352 return 0; 1353} 1354 1355static int coda_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a) 1356{ 1357 struct coda_ctx *ctx = file_to_ctx(file); 1358 struct v4l2_fract *tpf; 1359 1360 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1361 return -EINVAL; 1362 1363 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 1364 tpf = &a->parm.output.timeperframe; 1365 tpf->denominator = ctx->params.framerate & CODA_FRATE_RES_MASK; 1366 tpf->numerator = 1 + (ctx->params.framerate >> 1367 CODA_FRATE_DIV_OFFSET); 1368 1369 return 0; 1370} 1371 1372/* 1373 * Approximate timeperframe v4l2_fract with values that can be written 1374 * into the 16-bit CODA_FRATE_DIV and CODA_FRATE_RES fields. 1375 */ 1376static void coda_approximate_timeperframe(struct v4l2_fract *timeperframe) 1377{ 1378 struct v4l2_fract s = *timeperframe; 1379 struct v4l2_fract f0; 1380 struct v4l2_fract f1 = { 1, 0 }; 1381 struct v4l2_fract f2 = { 0, 1 }; 1382 unsigned int i, div, s_denominator; 1383 1384 /* Lower bound is 1/65535 */ 1385 if (s.numerator == 0 || s.denominator / s.numerator > 65535) { 1386 timeperframe->numerator = 1; 1387 timeperframe->denominator = 65535; 1388 return; 1389 } 1390 1391 /* Upper bound is 65536/1 */ 1392 if (s.denominator == 0 || s.numerator / s.denominator > 65536) { 1393 timeperframe->numerator = 65536; 1394 timeperframe->denominator = 1; 1395 return; 1396 } 1397 1398 /* Reduce fraction to lowest terms */ 1399 div = gcd(s.numerator, s.denominator); 1400 if (div > 1) { 1401 s.numerator /= div; 1402 s.denominator /= div; 1403 } 1404 1405 if (s.numerator <= 65536 && s.denominator < 65536) { 1406 *timeperframe = s; 1407 return; 1408 } 1409 1410 /* Find successive convergents from continued fraction expansion */ 1411 while (f2.numerator <= 65536 && f2.denominator < 65536) { 1412 f0 = f1; 1413 f1 = f2; 1414 1415 /* Stop when f2 exactly equals timeperframe */ 1416 if (s.numerator == 0) 1417 break; 1418 1419 i = s.denominator / s.numerator; 1420 1421 f2.numerator = f0.numerator + i * f1.numerator; 1422 f2.denominator = f0.denominator + i * f2.denominator; 1423 1424 s_denominator = s.numerator; 1425 s.numerator = s.denominator % s.numerator; 1426 s.denominator = s_denominator; 1427 } 1428 1429 *timeperframe = f1; 1430} 1431 1432static uint32_t coda_timeperframe_to_frate(struct v4l2_fract *timeperframe) 1433{ 1434 return ((timeperframe->numerator - 1) << CODA_FRATE_DIV_OFFSET) | 1435 timeperframe->denominator; 1436} 1437 1438static int coda_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a) 1439{ 1440 struct coda_ctx *ctx = file_to_ctx(file); 1441 struct v4l2_fract *tpf; 1442 1443 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1444 return -EINVAL; 1445 1446 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 1447 tpf = &a->parm.output.timeperframe; 1448 coda_approximate_timeperframe(tpf); 1449 ctx->params.framerate = coda_timeperframe_to_frate(tpf); 1450 ctx->params.framerate_changed = true; 1451 1452 return 0; 1453} 1454 1455static int coda_subscribe_event(struct v4l2_fh *fh, 1456 const struct v4l2_event_subscription *sub) 1457{ 1458 struct coda_ctx *ctx = fh_to_ctx(fh); 1459 1460 switch (sub->type) { 1461 case V4L2_EVENT_EOS: 1462 return v4l2_event_subscribe(fh, sub, 0, NULL); 1463 case V4L2_EVENT_SOURCE_CHANGE: 1464 if (ctx->inst_type == CODA_INST_DECODER) 1465 return v4l2_event_subscribe(fh, sub, 0, NULL); 1466 else 1467 return -EINVAL; 1468 default: 1469 return v4l2_ctrl_subscribe_event(fh, sub); 1470 } 1471} 1472 1473static const struct v4l2_ioctl_ops coda_ioctl_ops = { 1474 .vidioc_querycap = coda_querycap, 1475 1476 .vidioc_enum_fmt_vid_cap = coda_enum_fmt, 1477 .vidioc_g_fmt_vid_cap = coda_g_fmt, 1478 .vidioc_try_fmt_vid_cap = coda_try_fmt_vid_cap, 1479 .vidioc_s_fmt_vid_cap = coda_s_fmt_vid_cap, 1480 1481 .vidioc_enum_fmt_vid_out = coda_enum_fmt, 1482 .vidioc_g_fmt_vid_out = coda_g_fmt, 1483 .vidioc_try_fmt_vid_out = coda_try_fmt_vid_out, 1484 .vidioc_s_fmt_vid_out = coda_s_fmt_vid_out, 1485 1486 .vidioc_reqbufs = coda_reqbufs, 1487 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 1488 1489 .vidioc_qbuf = coda_qbuf, 1490 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 1491 .vidioc_dqbuf = coda_dqbuf, 1492 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 1493 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 1494 1495 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 1496 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 1497 1498 .vidioc_g_selection = coda_g_selection, 1499 .vidioc_s_selection = coda_s_selection, 1500 1501 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 1502 .vidioc_encoder_cmd = coda_encoder_cmd, 1503 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 1504 .vidioc_decoder_cmd = coda_decoder_cmd, 1505 1506 .vidioc_g_parm = coda_g_parm, 1507 .vidioc_s_parm = coda_s_parm, 1508 1509 .vidioc_enum_framesizes = coda_enum_framesizes, 1510 .vidioc_enum_frameintervals = coda_enum_frameintervals, 1511 1512 .vidioc_subscribe_event = coda_subscribe_event, 1513 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1514}; 1515 1516/* 1517 * Mem-to-mem operations. 1518 */ 1519 1520static void coda_device_run(void *m2m_priv) 1521{ 1522 struct coda_ctx *ctx = m2m_priv; 1523 struct coda_dev *dev = ctx->dev; 1524 1525 queue_work(dev->workqueue, &ctx->pic_run_work); 1526} 1527 1528static void coda_pic_run_work(struct work_struct *work) 1529{ 1530 struct coda_ctx *ctx = container_of(work, struct coda_ctx, pic_run_work); 1531 struct coda_dev *dev = ctx->dev; 1532 int ret; 1533 1534 mutex_lock(&ctx->buffer_mutex); 1535 mutex_lock(&dev->coda_mutex); 1536 1537 ret = ctx->ops->prepare_run(ctx); 1538 if (ret < 0 && ctx->inst_type == CODA_INST_DECODER) 1539 goto out; 1540 1541 if (!wait_for_completion_timeout(&ctx->completion, 1542 msecs_to_jiffies(1000))) { 1543 if (ctx->use_bit) { 1544 dev_err(dev->dev, "CODA PIC_RUN timeout\n"); 1545 1546 ctx->hold = true; 1547 1548 coda_hw_reset(ctx); 1549 } 1550 1551 if (ctx->ops->run_timeout) 1552 ctx->ops->run_timeout(ctx); 1553 } else { 1554 ctx->ops->finish_run(ctx); 1555 } 1556 1557 if ((ctx->aborting || (!ctx->streamon_cap && !ctx->streamon_out)) && 1558 ctx->ops->seq_end_work) 1559 queue_work(dev->workqueue, &ctx->seq_end_work); 1560 1561out: 1562 mutex_unlock(&dev->coda_mutex); 1563 mutex_unlock(&ctx->buffer_mutex); 1564 1565 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx); 1566} 1567 1568static int coda_job_ready(void *m2m_priv) 1569{ 1570 struct coda_ctx *ctx = m2m_priv; 1571 int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx); 1572 1573 /* 1574 * For both 'P' and 'key' frame cases 1 picture 1575 * and 1 frame are needed. In the decoder case, 1576 * the compressed frame can be in the bitstream. 1577 */ 1578 if (!src_bufs && ctx->inst_type != CODA_INST_DECODER) { 1579 coda_dbg(1, ctx, "not ready: not enough vid-out buffers.\n"); 1580 return 0; 1581 } 1582 1583 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) { 1584 coda_dbg(1, ctx, "not ready: not enough vid-cap buffers.\n"); 1585 return 0; 1586 } 1587 1588 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) { 1589 bool stream_end = ctx->bit_stream_param & 1590 CODA_BIT_STREAM_END_FLAG; 1591 int num_metas = ctx->num_metas; 1592 struct coda_buffer_meta *meta; 1593 unsigned int count; 1594 1595 count = hweight32(ctx->frm_dis_flg); 1596 if (ctx->use_vdoa && count >= (ctx->num_internal_frames - 1)) { 1597 coda_dbg(1, ctx, 1598 "not ready: all internal buffers in use: %d/%d (0x%x)", 1599 count, ctx->num_internal_frames, 1600 ctx->frm_dis_flg); 1601 return 0; 1602 } 1603 1604 if (ctx->hold && !src_bufs) { 1605 coda_dbg(1, ctx, 1606 "not ready: on hold for more buffers.\n"); 1607 return 0; 1608 } 1609 1610 if (!stream_end && (num_metas + src_bufs) < 2) { 1611 coda_dbg(1, ctx, 1612 "not ready: need 2 buffers available (queue:%d + bitstream:%d)\n", 1613 num_metas, src_bufs); 1614 return 0; 1615 } 1616 1617 meta = list_first_entry(&ctx->buffer_meta_list, 1618 struct coda_buffer_meta, list); 1619 if (!coda_bitstream_can_fetch_past(ctx, meta->end) && 1620 !stream_end) { 1621 coda_dbg(1, ctx, 1622 "not ready: not enough bitstream data to read past %u (%u)\n", 1623 meta->end, ctx->bitstream_fifo.kfifo.in); 1624 return 0; 1625 } 1626 } 1627 1628 if (ctx->aborting) { 1629 coda_dbg(1, ctx, "not ready: aborting\n"); 1630 return 0; 1631 } 1632 1633 coda_dbg(2, ctx, "job ready\n"); 1634 1635 return 1; 1636} 1637 1638static void coda_job_abort(void *priv) 1639{ 1640 struct coda_ctx *ctx = priv; 1641 1642 ctx->aborting = 1; 1643 1644 coda_dbg(1, ctx, "job abort\n"); 1645} 1646 1647static const struct v4l2_m2m_ops coda_m2m_ops = { 1648 .device_run = coda_device_run, 1649 .job_ready = coda_job_ready, 1650 .job_abort = coda_job_abort, 1651}; 1652 1653static void set_default_params(struct coda_ctx *ctx) 1654{ 1655 unsigned int max_w, max_h, usize, csize; 1656 1657 ctx->codec = coda_find_codec(ctx->dev, ctx->cvd->src_formats[0], 1658 ctx->cvd->dst_formats[0]); 1659 max_w = min(ctx->codec->max_w, 1920U); 1660 max_h = min(ctx->codec->max_h, 1088U); 1661 usize = max_w * max_h * 3 / 2; 1662 csize = coda_estimate_sizeimage(ctx, usize, max_w, max_h); 1663 1664 ctx->params.codec_mode = ctx->codec->mode; 1665 if (ctx->cvd->src_formats[0] == V4L2_PIX_FMT_JPEG || 1666 ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG) { 1667 ctx->colorspace = V4L2_COLORSPACE_SRGB; 1668 ctx->xfer_func = V4L2_XFER_FUNC_SRGB; 1669 ctx->ycbcr_enc = V4L2_YCBCR_ENC_601; 1670 ctx->quantization = V4L2_QUANTIZATION_FULL_RANGE; 1671 } else { 1672 ctx->colorspace = V4L2_COLORSPACE_REC709; 1673 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT; 1674 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 1675 ctx->quantization = V4L2_QUANTIZATION_DEFAULT; 1676 } 1677 ctx->params.framerate = 30; 1678 1679 /* Default formats for output and input queues */ 1680 ctx->q_data[V4L2_M2M_SRC].fourcc = ctx->cvd->src_formats[0]; 1681 ctx->q_data[V4L2_M2M_DST].fourcc = ctx->cvd->dst_formats[0]; 1682 ctx->q_data[V4L2_M2M_SRC].width = max_w; 1683 ctx->q_data[V4L2_M2M_SRC].height = max_h; 1684 ctx->q_data[V4L2_M2M_DST].width = max_w; 1685 ctx->q_data[V4L2_M2M_DST].height = max_h; 1686 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_YUV420) { 1687 ctx->q_data[V4L2_M2M_SRC].bytesperline = max_w; 1688 ctx->q_data[V4L2_M2M_SRC].sizeimage = usize; 1689 ctx->q_data[V4L2_M2M_DST].bytesperline = 0; 1690 ctx->q_data[V4L2_M2M_DST].sizeimage = csize; 1691 } else { 1692 ctx->q_data[V4L2_M2M_SRC].bytesperline = 0; 1693 ctx->q_data[V4L2_M2M_SRC].sizeimage = csize; 1694 ctx->q_data[V4L2_M2M_DST].bytesperline = max_w; 1695 ctx->q_data[V4L2_M2M_DST].sizeimage = usize; 1696 } 1697 ctx->q_data[V4L2_M2M_SRC].rect.width = max_w; 1698 ctx->q_data[V4L2_M2M_SRC].rect.height = max_h; 1699 ctx->q_data[V4L2_M2M_DST].rect.width = max_w; 1700 ctx->q_data[V4L2_M2M_DST].rect.height = max_h; 1701 1702 /* 1703 * Since the RBC2AXI logic only supports a single chroma plane, 1704 * macroblock tiling only works for to NV12 pixel format. 1705 */ 1706 ctx->tiled_map_type = GDI_LINEAR_FRAME_MAP; 1707} 1708 1709/* 1710 * Queue operations 1711 */ 1712static int coda_queue_setup(struct vb2_queue *vq, 1713 unsigned int *nbuffers, unsigned int *nplanes, 1714 unsigned int sizes[], struct device *alloc_devs[]) 1715{ 1716 struct coda_ctx *ctx = vb2_get_drv_priv(vq); 1717 struct coda_q_data *q_data; 1718 unsigned int size; 1719 1720 q_data = get_q_data(ctx, vq->type); 1721 size = q_data->sizeimage; 1722 1723 if (*nplanes) 1724 return sizes[0] < size ? -EINVAL : 0; 1725 1726 *nplanes = 1; 1727 sizes[0] = size; 1728 1729 coda_dbg(1, ctx, "get %d buffer(s) of size %d each.\n", *nbuffers, 1730 size); 1731 1732 return 0; 1733} 1734 1735static int coda_buf_prepare(struct vb2_buffer *vb) 1736{ 1737 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1738 struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1739 struct coda_q_data *q_data; 1740 1741 q_data = get_q_data(ctx, vb->vb2_queue->type); 1742 if (V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) { 1743 if (vbuf->field == V4L2_FIELD_ANY) 1744 vbuf->field = V4L2_FIELD_NONE; 1745 if (vbuf->field != V4L2_FIELD_NONE) { 1746 v4l2_warn(&ctx->dev->v4l2_dev, 1747 "%s field isn't supported\n", __func__); 1748 return -EINVAL; 1749 } 1750 } 1751 1752 if (vb2_plane_size(vb, 0) < q_data->sizeimage) { 1753 v4l2_warn(&ctx->dev->v4l2_dev, 1754 "%s data will not fit into plane (%lu < %lu)\n", 1755 __func__, vb2_plane_size(vb, 0), 1756 (long)q_data->sizeimage); 1757 return -EINVAL; 1758 } 1759 1760 return 0; 1761} 1762 1763static void coda_update_menu_ctrl(struct v4l2_ctrl *ctrl, int value) 1764{ 1765 if (!ctrl) 1766 return; 1767 1768 v4l2_ctrl_lock(ctrl); 1769 1770 /* 1771 * Extend the control range if the parsed stream contains a known but 1772 * unsupported value or level. 1773 */ 1774 if (value > ctrl->maximum) { 1775 __v4l2_ctrl_modify_range(ctrl, ctrl->minimum, value, 1776 ctrl->menu_skip_mask & ~(1 << value), 1777 ctrl->default_value); 1778 } else if (value < ctrl->minimum) { 1779 __v4l2_ctrl_modify_range(ctrl, value, ctrl->maximum, 1780 ctrl->menu_skip_mask & ~(1 << value), 1781 ctrl->default_value); 1782 } 1783 1784 __v4l2_ctrl_s_ctrl(ctrl, value); 1785 1786 v4l2_ctrl_unlock(ctrl); 1787} 1788 1789void coda_update_profile_level_ctrls(struct coda_ctx *ctx, u8 profile_idc, 1790 u8 level_idc) 1791{ 1792 const char * const *profile_names; 1793 const char * const *level_names; 1794 struct v4l2_ctrl *profile_ctrl; 1795 struct v4l2_ctrl *level_ctrl; 1796 const char *codec_name; 1797 u32 profile_cid; 1798 u32 level_cid; 1799 int profile; 1800 int level; 1801 1802 switch (ctx->codec->src_fourcc) { 1803 case V4L2_PIX_FMT_H264: 1804 codec_name = "H264"; 1805 profile_cid = V4L2_CID_MPEG_VIDEO_H264_PROFILE; 1806 level_cid = V4L2_CID_MPEG_VIDEO_H264_LEVEL; 1807 profile_ctrl = ctx->h264_profile_ctrl; 1808 level_ctrl = ctx->h264_level_ctrl; 1809 profile = coda_h264_profile(profile_idc); 1810 level = coda_h264_level(level_idc); 1811 break; 1812 case V4L2_PIX_FMT_MPEG2: 1813 codec_name = "MPEG-2"; 1814 profile_cid = V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE; 1815 level_cid = V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL; 1816 profile_ctrl = ctx->mpeg2_profile_ctrl; 1817 level_ctrl = ctx->mpeg2_level_ctrl; 1818 profile = coda_mpeg2_profile(profile_idc); 1819 level = coda_mpeg2_level(level_idc); 1820 break; 1821 case V4L2_PIX_FMT_MPEG4: 1822 codec_name = "MPEG-4"; 1823 profile_cid = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE; 1824 level_cid = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL; 1825 profile_ctrl = ctx->mpeg4_profile_ctrl; 1826 level_ctrl = ctx->mpeg4_level_ctrl; 1827 profile = coda_mpeg4_profile(profile_idc); 1828 level = coda_mpeg4_level(level_idc); 1829 break; 1830 default: 1831 return; 1832 } 1833 1834 profile_names = v4l2_ctrl_get_menu(profile_cid); 1835 level_names = v4l2_ctrl_get_menu(level_cid); 1836 1837 if (profile < 0) { 1838 v4l2_warn(&ctx->dev->v4l2_dev, "Invalid %s profile: %u\n", 1839 codec_name, profile_idc); 1840 } else { 1841 coda_dbg(1, ctx, "Parsed %s profile: %s\n", codec_name, 1842 profile_names[profile]); 1843 coda_update_menu_ctrl(profile_ctrl, profile); 1844 } 1845 1846 if (level < 0) { 1847 v4l2_warn(&ctx->dev->v4l2_dev, "Invalid %s level: %u\n", 1848 codec_name, level_idc); 1849 } else { 1850 coda_dbg(1, ctx, "Parsed %s level: %s\n", codec_name, 1851 level_names[level]); 1852 coda_update_menu_ctrl(level_ctrl, level); 1853 } 1854} 1855 1856static void coda_queue_source_change_event(struct coda_ctx *ctx) 1857{ 1858 static const struct v4l2_event source_change_event = { 1859 .type = V4L2_EVENT_SOURCE_CHANGE, 1860 .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION, 1861 }; 1862 1863 v4l2_event_queue_fh(&ctx->fh, &source_change_event); 1864} 1865 1866static void coda_buf_queue(struct vb2_buffer *vb) 1867{ 1868 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1869 struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1870 struct vb2_queue *vq = vb->vb2_queue; 1871 struct coda_q_data *q_data; 1872 1873 q_data = get_q_data(ctx, vb->vb2_queue->type); 1874 1875 /* 1876 * In the decoder case, immediately try to copy the buffer into the 1877 * bitstream ringbuffer and mark it as ready to be dequeued. 1878 */ 1879 if (ctx->bitstream.size && vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1880 /* 1881 * For backwards compatibility, queuing an empty buffer marks 1882 * the stream end 1883 */ 1884 if (vb2_get_plane_payload(vb, 0) == 0) 1885 coda_bit_stream_end_flag(ctx); 1886 1887 if (q_data->fourcc == V4L2_PIX_FMT_H264) { 1888 /* 1889 * Unless already done, try to obtain profile_idc and 1890 * level_idc from the SPS header. This allows to decide 1891 * whether to enable reordering during sequence 1892 * initialization. 1893 */ 1894 if (!ctx->params.h264_profile_idc) { 1895 coda_sps_parse_profile(ctx, vb); 1896 coda_update_profile_level_ctrls(ctx, 1897 ctx->params.h264_profile_idc, 1898 ctx->params.h264_level_idc); 1899 } 1900 } 1901 1902 mutex_lock(&ctx->bitstream_mutex); 1903 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1904 if (vb2_is_streaming(vb->vb2_queue)) 1905 /* This set buf->sequence = ctx->qsequence++ */ 1906 coda_fill_bitstream(ctx, NULL); 1907 mutex_unlock(&ctx->bitstream_mutex); 1908 1909 if (!ctx->initialized) { 1910 /* 1911 * Run sequence initialization in case the queued 1912 * buffer contained headers. 1913 */ 1914 if (vb2_is_streaming(vb->vb2_queue) && 1915 ctx->ops->seq_init_work) { 1916 queue_work(ctx->dev->workqueue, 1917 &ctx->seq_init_work); 1918 flush_work(&ctx->seq_init_work); 1919 } 1920 1921 if (ctx->initialized) 1922 coda_queue_source_change_event(ctx); 1923 } 1924 } else { 1925 if ((ctx->inst_type == CODA_INST_ENCODER || !ctx->use_bit) && 1926 vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1927 vbuf->sequence = ctx->qsequence++; 1928 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1929 } 1930} 1931 1932int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf, 1933 size_t size, const char *name, struct dentry *parent) 1934{ 1935 buf->vaddr = dma_alloc_coherent(dev->dev, size, &buf->paddr, 1936 GFP_KERNEL); 1937 if (!buf->vaddr) { 1938 v4l2_err(&dev->v4l2_dev, 1939 "Failed to allocate %s buffer of size %zu\n", 1940 name, size); 1941 return -ENOMEM; 1942 } 1943 1944 buf->size = size; 1945 1946 if (name && parent) { 1947 buf->blob.data = buf->vaddr; 1948 buf->blob.size = size; 1949 buf->dentry = debugfs_create_blob(name, 0444, parent, 1950 &buf->blob); 1951 } 1952 1953 return 0; 1954} 1955 1956void coda_free_aux_buf(struct coda_dev *dev, 1957 struct coda_aux_buf *buf) 1958{ 1959 if (buf->vaddr) { 1960 dma_free_coherent(dev->dev, buf->size, buf->vaddr, buf->paddr); 1961 buf->vaddr = NULL; 1962 buf->size = 0; 1963 debugfs_remove(buf->dentry); 1964 buf->dentry = NULL; 1965 } 1966} 1967 1968static int coda_start_streaming(struct vb2_queue *q, unsigned int count) 1969{ 1970 struct coda_ctx *ctx = vb2_get_drv_priv(q); 1971 struct v4l2_device *v4l2_dev = &ctx->dev->v4l2_dev; 1972 struct coda_q_data *q_data_src, *q_data_dst; 1973 struct v4l2_m2m_buffer *m2m_buf, *tmp; 1974 struct vb2_v4l2_buffer *buf; 1975 struct list_head list; 1976 int ret = 0; 1977 1978 if (count < 1) 1979 return -EINVAL; 1980 1981 coda_dbg(1, ctx, "start streaming %s\n", v4l2_type_names[q->type]); 1982 1983 INIT_LIST_HEAD(&list); 1984 1985 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 1986 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1987 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) { 1988 /* copy the buffers that were queued before streamon */ 1989 mutex_lock(&ctx->bitstream_mutex); 1990 coda_fill_bitstream(ctx, &list); 1991 mutex_unlock(&ctx->bitstream_mutex); 1992 1993 if (ctx->dev->devtype->product != CODA_960 && 1994 coda_get_bitstream_payload(ctx) < 512) { 1995 v4l2_err(v4l2_dev, "start payload < 512\n"); 1996 ret = -EINVAL; 1997 goto err; 1998 } 1999 2000 if (!ctx->initialized) { 2001 /* Run sequence initialization */ 2002 if (ctx->ops->seq_init_work) { 2003 queue_work(ctx->dev->workqueue, 2004 &ctx->seq_init_work); 2005 flush_work(&ctx->seq_init_work); 2006 } 2007 } 2008 } 2009 2010 /* 2011 * Check the first input JPEG buffer to determine chroma 2012 * subsampling. 2013 */ 2014 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG) { 2015 buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2016 coda_jpeg_decode_header(ctx, &buf->vb2_buf); 2017 /* 2018 * We have to start streaming even if the first buffer 2019 * does not contain a valid JPEG image. The error will 2020 * be caught during device run and will be signalled 2021 * via the capture buffer error flag. 2022 */ 2023 2024 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 2025 q_data_dst->width = round_up(q_data_src->width, 16); 2026 q_data_dst->height = round_up(q_data_src->height, 16); 2027 q_data_dst->bytesperline = q_data_dst->width; 2028 if (ctx->params.jpeg_chroma_subsampling == 2029 V4L2_JPEG_CHROMA_SUBSAMPLING_420) { 2030 q_data_dst->sizeimage = 2031 q_data_dst->bytesperline * 2032 q_data_dst->height * 3 / 2; 2033 if (q_data_dst->fourcc != V4L2_PIX_FMT_YUV420) 2034 q_data_dst->fourcc = V4L2_PIX_FMT_NV12; 2035 } else { 2036 q_data_dst->sizeimage = 2037 q_data_dst->bytesperline * 2038 q_data_dst->height * 2; 2039 q_data_dst->fourcc = V4L2_PIX_FMT_YUV422P; 2040 } 2041 q_data_dst->rect.left = 0; 2042 q_data_dst->rect.top = 0; 2043 q_data_dst->rect.width = q_data_src->width; 2044 q_data_dst->rect.height = q_data_src->height; 2045 } 2046 ctx->streamon_out = 1; 2047 } else { 2048 ctx->streamon_cap = 1; 2049 } 2050 2051 /* Don't start the coda unless both queues are on */ 2052 if (!(ctx->streamon_out && ctx->streamon_cap)) 2053 goto out; 2054 2055 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 2056 if ((q_data_src->rect.width != q_data_dst->width && 2057 round_up(q_data_src->rect.width, 16) != q_data_dst->width) || 2058 (q_data_src->rect.height != q_data_dst->height && 2059 round_up(q_data_src->rect.height, 16) != q_data_dst->height)) { 2060 v4l2_err(v4l2_dev, "can't convert %dx%d to %dx%d\n", 2061 q_data_src->rect.width, q_data_src->rect.height, 2062 q_data_dst->width, q_data_dst->height); 2063 ret = -EINVAL; 2064 goto err; 2065 } 2066 2067 /* Allow BIT decoder device_run with no new buffers queued */ 2068 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) 2069 v4l2_m2m_set_src_buffered(ctx->fh.m2m_ctx, true); 2070 2071 ctx->gopcounter = ctx->params.gop_size - 1; 2072 2073 if (q_data_dst->fourcc == V4L2_PIX_FMT_JPEG) 2074 ctx->params.gop_size = 1; 2075 ctx->gopcounter = ctx->params.gop_size - 1; 2076 /* Only decoders have this control */ 2077 if (ctx->mb_err_cnt_ctrl) 2078 v4l2_ctrl_s_ctrl(ctx->mb_err_cnt_ctrl, 0); 2079 2080 ret = ctx->ops->start_streaming(ctx); 2081 if (ctx->inst_type == CODA_INST_DECODER) { 2082 if (ret == -EAGAIN) 2083 goto out; 2084 } 2085 if (ret < 0) 2086 goto err; 2087 2088out: 2089 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2090 list_for_each_entry_safe(m2m_buf, tmp, &list, list) { 2091 list_del(&m2m_buf->list); 2092 v4l2_m2m_buf_done(&m2m_buf->vb, VB2_BUF_STATE_DONE); 2093 } 2094 } 2095 return 0; 2096 2097err: 2098 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2099 list_for_each_entry_safe(m2m_buf, tmp, &list, list) { 2100 list_del(&m2m_buf->list); 2101 v4l2_m2m_buf_done(&m2m_buf->vb, VB2_BUF_STATE_QUEUED); 2102 } 2103 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 2104 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED); 2105 } else { 2106 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx))) 2107 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED); 2108 } 2109 return ret; 2110} 2111 2112static void coda_stop_streaming(struct vb2_queue *q) 2113{ 2114 struct coda_ctx *ctx = vb2_get_drv_priv(q); 2115 struct coda_dev *dev = ctx->dev; 2116 struct vb2_v4l2_buffer *buf; 2117 bool stop; 2118 2119 stop = ctx->streamon_out && ctx->streamon_cap; 2120 2121 coda_dbg(1, ctx, "stop streaming %s\n", v4l2_type_names[q->type]); 2122 2123 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2124 ctx->streamon_out = 0; 2125 2126 coda_bit_stream_end_flag(ctx); 2127 2128 ctx->qsequence = 0; 2129 2130 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 2131 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_ERROR); 2132 } else { 2133 ctx->streamon_cap = 0; 2134 2135 ctx->osequence = 0; 2136 ctx->sequence_offset = 0; 2137 2138 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx))) 2139 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_ERROR); 2140 } 2141 2142 if (stop) { 2143 struct coda_buffer_meta *meta; 2144 2145 if (ctx->ops->seq_end_work) { 2146 queue_work(dev->workqueue, &ctx->seq_end_work); 2147 flush_work(&ctx->seq_end_work); 2148 } 2149 spin_lock(&ctx->buffer_meta_lock); 2150 while (!list_empty(&ctx->buffer_meta_list)) { 2151 meta = list_first_entry(&ctx->buffer_meta_list, 2152 struct coda_buffer_meta, list); 2153 list_del(&meta->list); 2154 kfree(meta); 2155 } 2156 ctx->num_metas = 0; 2157 spin_unlock(&ctx->buffer_meta_lock); 2158 kfifo_init(&ctx->bitstream_fifo, 2159 ctx->bitstream.vaddr, ctx->bitstream.size); 2160 ctx->runcounter = 0; 2161 ctx->aborting = 0; 2162 ctx->hold = false; 2163 } 2164 2165 if (!ctx->streamon_out && !ctx->streamon_cap) 2166 ctx->bit_stream_param &= ~CODA_BIT_STREAM_END_FLAG; 2167} 2168 2169static const struct vb2_ops coda_qops = { 2170 .queue_setup = coda_queue_setup, 2171 .buf_prepare = coda_buf_prepare, 2172 .buf_queue = coda_buf_queue, 2173 .start_streaming = coda_start_streaming, 2174 .stop_streaming = coda_stop_streaming, 2175}; 2176 2177static int coda_s_ctrl(struct v4l2_ctrl *ctrl) 2178{ 2179 const char * const *val_names = v4l2_ctrl_get_menu(ctrl->id); 2180 struct coda_ctx *ctx = 2181 container_of(ctrl->handler, struct coda_ctx, ctrls); 2182 2183 if (val_names) 2184 coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d (\"%s\")\n", 2185 ctrl->id, ctrl->name, ctrl->val, val_names[ctrl->val]); 2186 else 2187 coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d\n", 2188 ctrl->id, ctrl->name, ctrl->val); 2189 2190 switch (ctrl->id) { 2191 case V4L2_CID_HFLIP: 2192 if (ctrl->val) 2193 ctx->params.rot_mode |= CODA_MIR_HOR; 2194 else 2195 ctx->params.rot_mode &= ~CODA_MIR_HOR; 2196 break; 2197 case V4L2_CID_VFLIP: 2198 if (ctrl->val) 2199 ctx->params.rot_mode |= CODA_MIR_VER; 2200 else 2201 ctx->params.rot_mode &= ~CODA_MIR_VER; 2202 break; 2203 case V4L2_CID_MPEG_VIDEO_BITRATE: 2204 ctx->params.bitrate = ctrl->val / 1000; 2205 ctx->params.bitrate_changed = true; 2206 break; 2207 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 2208 ctx->params.gop_size = ctrl->val; 2209 break; 2210 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: 2211 ctx->params.h264_intra_qp = ctrl->val; 2212 ctx->params.h264_intra_qp_changed = true; 2213 break; 2214 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: 2215 ctx->params.h264_inter_qp = ctrl->val; 2216 break; 2217 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: 2218 ctx->params.h264_min_qp = ctrl->val; 2219 break; 2220 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: 2221 ctx->params.h264_max_qp = ctrl->val; 2222 break; 2223 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: 2224 ctx->params.h264_slice_alpha_c0_offset_div2 = ctrl->val; 2225 break; 2226 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: 2227 ctx->params.h264_slice_beta_offset_div2 = ctrl->val; 2228 break; 2229 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: 2230 ctx->params.h264_disable_deblocking_filter_idc = ctrl->val; 2231 break; 2232 case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION: 2233 ctx->params.h264_constrained_intra_pred_flag = ctrl->val; 2234 break; 2235 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: 2236 ctx->params.frame_rc_enable = ctrl->val; 2237 break; 2238 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: 2239 ctx->params.mb_rc_enable = ctrl->val; 2240 break; 2241 case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: 2242 ctx->params.h264_chroma_qp_index_offset = ctrl->val; 2243 break; 2244 case V4L2_CID_MPEG_VIDEO_H264_PROFILE: 2245 /* TODO: switch between baseline and constrained baseline */ 2246 if (ctx->inst_type == CODA_INST_ENCODER) 2247 ctx->params.h264_profile_idc = 66; 2248 break; 2249 case V4L2_CID_MPEG_VIDEO_H264_LEVEL: 2250 /* nothing to do, this is set by the encoder */ 2251 break; 2252 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: 2253 ctx->params.mpeg4_intra_qp = ctrl->val; 2254 break; 2255 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: 2256 ctx->params.mpeg4_inter_qp = ctrl->val; 2257 break; 2258 case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: 2259 case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: 2260 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: 2261 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: 2262 /* nothing to do, these are fixed */ 2263 break; 2264 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: 2265 ctx->params.slice_mode = ctrl->val; 2266 ctx->params.slice_mode_changed = true; 2267 break; 2268 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: 2269 ctx->params.slice_max_mb = ctrl->val; 2270 ctx->params.slice_mode_changed = true; 2271 break; 2272 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: 2273 ctx->params.slice_max_bits = ctrl->val * 8; 2274 ctx->params.slice_mode_changed = true; 2275 break; 2276 case V4L2_CID_MPEG_VIDEO_HEADER_MODE: 2277 break; 2278 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: 2279 ctx->params.intra_refresh = ctrl->val; 2280 ctx->params.intra_refresh_changed = true; 2281 break; 2282 case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: 2283 ctx->params.force_ipicture = true; 2284 break; 2285 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 2286 coda_set_jpeg_compression_quality(ctx, ctrl->val); 2287 break; 2288 case V4L2_CID_JPEG_RESTART_INTERVAL: 2289 ctx->params.jpeg_restart_interval = ctrl->val; 2290 break; 2291 case V4L2_CID_MPEG_VIDEO_VBV_DELAY: 2292 ctx->params.vbv_delay = ctrl->val; 2293 break; 2294 case V4L2_CID_MPEG_VIDEO_VBV_SIZE: 2295 ctx->params.vbv_size = min(ctrl->val * 8192, 0x7fffffff); 2296 break; 2297 default: 2298 coda_dbg(1, ctx, "Invalid control, id=%d, val=%d\n", 2299 ctrl->id, ctrl->val); 2300 return -EINVAL; 2301 } 2302 2303 return 0; 2304} 2305 2306static const struct v4l2_ctrl_ops coda_ctrl_ops = { 2307 .s_ctrl = coda_s_ctrl, 2308}; 2309 2310static void coda_encode_ctrls(struct coda_ctx *ctx) 2311{ 2312 int max_gop_size = (ctx->dev->devtype->product == CODA_DX6) ? 60 : 99; 2313 2314 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2315 V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1000, 0); 2316 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2317 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, max_gop_size, 1, 16); 2318 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2319 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 0, 51, 1, 25); 2320 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2321 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 0, 51, 1, 25); 2322 if (ctx->dev->devtype->product != CODA_960) { 2323 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2324 V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 0, 51, 1, 12); 2325 } 2326 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2327 V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 0, 51, 1, 51); 2328 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2329 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0); 2330 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2331 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0); 2332 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2333 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, 2334 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY, 2335 0x0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED); 2336 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2337 V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION, 0, 1, 1, 2338 0); 2339 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2340 V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1); 2341 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2342 V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE, 0, 1, 1, 1); 2343 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2344 V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET, -12, 12, 1, 0); 2345 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2346 V4L2_CID_MPEG_VIDEO_H264_PROFILE, 2347 V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE, 0x0, 2348 V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE); 2349 if (ctx->dev->devtype->product == CODA_HX4 || 2350 ctx->dev->devtype->product == CODA_7541) { 2351 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2352 V4L2_CID_MPEG_VIDEO_H264_LEVEL, 2353 V4L2_MPEG_VIDEO_H264_LEVEL_3_1, 2354 ~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) | 2355 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) | 2356 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1)), 2357 V4L2_MPEG_VIDEO_H264_LEVEL_3_1); 2358 } 2359 if (ctx->dev->devtype->product == CODA_960) { 2360 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2361 V4L2_CID_MPEG_VIDEO_H264_LEVEL, 2362 V4L2_MPEG_VIDEO_H264_LEVEL_4_2, 2363 ~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_0) | 2364 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) | 2365 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) | 2366 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1) | 2367 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_2) | 2368 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_0) | 2369 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_1) | 2370 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_2)), 2371 V4L2_MPEG_VIDEO_H264_LEVEL_4_0); 2372 } 2373 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2374 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP, 1, 31, 1, 2); 2375 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2376 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP, 1, 31, 1, 2); 2377 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2378 V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE, 2379 V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE, 0x0, 2380 V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE); 2381 if (ctx->dev->devtype->product == CODA_HX4 || 2382 ctx->dev->devtype->product == CODA_7541 || 2383 ctx->dev->devtype->product == CODA_960) { 2384 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2385 V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL, 2386 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5, 2387 ~(1 << V4L2_MPEG_VIDEO_MPEG4_LEVEL_5), 2388 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5); 2389 } 2390 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2391 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE, 2392 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES, 0x0, 2393 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE); 2394 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2395 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1, 0x3fffffff, 1, 1); 2396 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2397 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, 1, 0x3fffffff, 1, 2398 500); 2399 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2400 V4L2_CID_MPEG_VIDEO_HEADER_MODE, 2401 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME, 2402 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE), 2403 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME); 2404 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2405 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB, 0, 2406 1920 * 1088 / 256, 1, 0); 2407 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2408 V4L2_CID_MPEG_VIDEO_VBV_DELAY, 0, 0x7fff, 1, 0); 2409 /* 2410 * The maximum VBV size value is 0x7fffffff bits, 2411 * one bit less than 262144 KiB 2412 */ 2413 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2414 V4L2_CID_MPEG_VIDEO_VBV_SIZE, 0, 262144, 1, 0); 2415} 2416 2417static void coda_jpeg_encode_ctrls(struct coda_ctx *ctx) 2418{ 2419 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2420 V4L2_CID_JPEG_COMPRESSION_QUALITY, 5, 100, 1, 50); 2421 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2422 V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, 1, 0); 2423} 2424 2425static void coda_decode_ctrls(struct coda_ctx *ctx) 2426{ 2427 u8 max; 2428 2429 ctx->h264_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2430 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_PROFILE, 2431 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 2432 ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) | 2433 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) | 2434 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)), 2435 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH); 2436 if (ctx->h264_profile_ctrl) 2437 ctx->h264_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2438 2439 if (ctx->dev->devtype->product == CODA_HX4 || 2440 ctx->dev->devtype->product == CODA_7541) 2441 max = V4L2_MPEG_VIDEO_H264_LEVEL_4_0; 2442 else if (ctx->dev->devtype->product == CODA_960) 2443 max = V4L2_MPEG_VIDEO_H264_LEVEL_4_1; 2444 else 2445 return; 2446 ctx->h264_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2447 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_LEVEL, max, 0, max); 2448 if (ctx->h264_level_ctrl) 2449 ctx->h264_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2450 2451 ctx->mpeg2_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2452 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE, 2453 V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH, 0, 2454 V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH); 2455 if (ctx->mpeg2_profile_ctrl) 2456 ctx->mpeg2_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2457 2458 ctx->mpeg2_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2459 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL, 2460 V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH, 0, 2461 V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH); 2462 if (ctx->mpeg2_level_ctrl) 2463 ctx->mpeg2_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2464 2465 ctx->mpeg4_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2466 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE, 2467 V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY, 0, 2468 V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY); 2469 if (ctx->mpeg4_profile_ctrl) 2470 ctx->mpeg4_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2471 2472 ctx->mpeg4_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2473 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL, 2474 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5, 0, 2475 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5); 2476 if (ctx->mpeg4_level_ctrl) 2477 ctx->mpeg4_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2478} 2479 2480static const struct v4l2_ctrl_config coda_mb_err_cnt_ctrl_config = { 2481 .id = V4L2_CID_CODA_MB_ERR_CNT, 2482 .name = "Macroblocks Error Count", 2483 .type = V4L2_CTRL_TYPE_INTEGER, 2484 .min = 0, 2485 .max = 0x7fffffff, 2486 .step = 1, 2487}; 2488 2489static int coda_ctrls_setup(struct coda_ctx *ctx) 2490{ 2491 v4l2_ctrl_handler_init(&ctx->ctrls, 2); 2492 2493 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2494 V4L2_CID_HFLIP, 0, 1, 1, 0); 2495 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2496 V4L2_CID_VFLIP, 0, 1, 1, 0); 2497 if (ctx->inst_type == CODA_INST_ENCODER) { 2498 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2499 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 2500 1, 1, 1, 1); 2501 if (ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG) 2502 coda_jpeg_encode_ctrls(ctx); 2503 else 2504 coda_encode_ctrls(ctx); 2505 } else { 2506 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2507 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 2508 1, 1, 1, 1); 2509 if (ctx->cvd->src_formats[0] == V4L2_PIX_FMT_H264) 2510 coda_decode_ctrls(ctx); 2511 2512 ctx->mb_err_cnt_ctrl = v4l2_ctrl_new_custom(&ctx->ctrls, 2513 &coda_mb_err_cnt_ctrl_config, 2514 NULL); 2515 if (ctx->mb_err_cnt_ctrl) 2516 ctx->mb_err_cnt_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2517 } 2518 2519 if (ctx->ctrls.error) { 2520 v4l2_err(&ctx->dev->v4l2_dev, 2521 "control initialization error (%d)", 2522 ctx->ctrls.error); 2523 return -EINVAL; 2524 } 2525 2526 return v4l2_ctrl_handler_setup(&ctx->ctrls); 2527} 2528 2529static int coda_queue_init(struct coda_ctx *ctx, struct vb2_queue *vq) 2530{ 2531 vq->drv_priv = ctx; 2532 vq->ops = &coda_qops; 2533 vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2534 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2535 vq->lock = &ctx->dev->dev_mutex; 2536 /* One way to indicate end-of-stream for coda is to set the 2537 * bytesused == 0. However by default videobuf2 handles bytesused 2538 * equal to 0 as a special case and changes its value to the size 2539 * of the buffer. Set the allow_zero_bytesused flag, so 2540 * that videobuf2 will keep the value of bytesused intact. 2541 */ 2542 vq->allow_zero_bytesused = 1; 2543 /* 2544 * We might be fine with no buffers on some of the queues, but that 2545 * would need to be reflected in job_ready(). Currently we expect all 2546 * queues to have at least one buffer queued. 2547 */ 2548 vq->min_queued_buffers = 1; 2549 vq->dev = ctx->dev->dev; 2550 2551 return vb2_queue_init(vq); 2552} 2553 2554int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq, 2555 struct vb2_queue *dst_vq) 2556{ 2557 int ret; 2558 2559 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2560 src_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2561 src_vq->mem_ops = &vb2_dma_contig_memops; 2562 2563 ret = coda_queue_init(priv, src_vq); 2564 if (ret) 2565 return ret; 2566 2567 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2568 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2569 dst_vq->mem_ops = &vb2_dma_contig_memops; 2570 2571 return coda_queue_init(priv, dst_vq); 2572} 2573 2574int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq, 2575 struct vb2_queue *dst_vq) 2576{ 2577 int ret; 2578 2579 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2580 src_vq->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR; 2581 src_vq->mem_ops = &vb2_vmalloc_memops; 2582 2583 ret = coda_queue_init(priv, src_vq); 2584 if (ret) 2585 return ret; 2586 2587 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2588 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2589 dst_vq->dma_attrs = DMA_ATTR_NO_KERNEL_MAPPING; 2590 dst_vq->mem_ops = &vb2_dma_contig_memops; 2591 2592 return coda_queue_init(priv, dst_vq); 2593} 2594 2595/* 2596 * File operations 2597 */ 2598 2599static int coda_open(struct file *file) 2600{ 2601 struct video_device *vdev = video_devdata(file); 2602 struct coda_dev *dev = video_get_drvdata(vdev); 2603 struct coda_ctx *ctx; 2604 unsigned int max = ~0; 2605 char *name; 2606 int ret; 2607 int idx; 2608 2609 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 2610 if (!ctx) 2611 return -ENOMEM; 2612 2613 if (dev->devtype->product == CODA_DX6) 2614 max = CODADX6_MAX_INSTANCES - 1; 2615 idx = ida_alloc_max(&dev->ida, max, GFP_KERNEL); 2616 if (idx < 0) { 2617 ret = idx; 2618 goto err_coda_max; 2619 } 2620 2621 name = kasprintf(GFP_KERNEL, "context%d", idx); 2622 if (!name) { 2623 ret = -ENOMEM; 2624 goto err_coda_name_init; 2625 } 2626 2627 ctx->debugfs_entry = debugfs_create_dir(name, dev->debugfs_root); 2628 kfree(name); 2629 2630 ctx->cvd = to_coda_video_device(vdev); 2631 ctx->inst_type = ctx->cvd->type; 2632 ctx->ops = ctx->cvd->ops; 2633 ctx->use_bit = !ctx->cvd->direct; 2634 init_completion(&ctx->completion); 2635 INIT_WORK(&ctx->pic_run_work, coda_pic_run_work); 2636 if (ctx->ops->seq_init_work) 2637 INIT_WORK(&ctx->seq_init_work, ctx->ops->seq_init_work); 2638 if (ctx->ops->seq_end_work) 2639 INIT_WORK(&ctx->seq_end_work, ctx->ops->seq_end_work); 2640 v4l2_fh_init(&ctx->fh, video_devdata(file)); 2641 v4l2_fh_add(&ctx->fh, file); 2642 ctx->dev = dev; 2643 ctx->idx = idx; 2644 2645 coda_dbg(1, ctx, "open instance (%p)\n", ctx); 2646 2647 switch (dev->devtype->product) { 2648 case CODA_960: 2649 /* 2650 * Enabling the BWB when decoding can hang the firmware with 2651 * certain streams. The issue was tracked as ENGR00293425 by 2652 * Freescale. As a workaround, disable BWB for all decoders. 2653 * The enable_bwb module parameter allows to override this. 2654 */ 2655 if (enable_bwb || ctx->inst_type == CODA_INST_ENCODER) 2656 ctx->frame_mem_ctrl = CODA9_FRAME_ENABLE_BWB; 2657 fallthrough; 2658 case CODA_HX4: 2659 case CODA_7541: 2660 ctx->reg_idx = 0; 2661 break; 2662 default: 2663 ctx->reg_idx = idx; 2664 } 2665 if (ctx->dev->vdoa && !disable_vdoa) { 2666 ctx->vdoa = vdoa_context_create(dev->vdoa); 2667 if (!ctx->vdoa) 2668 v4l2_warn(&dev->v4l2_dev, 2669 "Failed to create vdoa context: not using vdoa"); 2670 } 2671 ctx->use_vdoa = false; 2672 2673 /* Power up and upload firmware if necessary */ 2674 ret = pm_runtime_resume_and_get(dev->dev); 2675 if (ret < 0) { 2676 v4l2_err(&dev->v4l2_dev, "failed to power up: %d\n", ret); 2677 goto err_pm_get; 2678 } 2679 2680 ret = clk_prepare_enable(dev->clk_per); 2681 if (ret) 2682 goto err_clk_enable; 2683 2684 ret = clk_prepare_enable(dev->clk_ahb); 2685 if (ret) 2686 goto err_clk_ahb; 2687 2688 set_default_params(ctx); 2689 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, 2690 ctx->ops->queue_init); 2691 if (IS_ERR(ctx->fh.m2m_ctx)) { 2692 ret = PTR_ERR(ctx->fh.m2m_ctx); 2693 2694 v4l2_err(&dev->v4l2_dev, "%s return error (%d)\n", 2695 __func__, ret); 2696 goto err_ctx_init; 2697 } 2698 2699 ret = coda_ctrls_setup(ctx); 2700 if (ret) { 2701 v4l2_err(&dev->v4l2_dev, "failed to setup coda controls\n"); 2702 goto err_ctrls_setup; 2703 } 2704 2705 ctx->fh.ctrl_handler = &ctx->ctrls; 2706 2707 mutex_init(&ctx->bitstream_mutex); 2708 mutex_init(&ctx->buffer_mutex); 2709 mutex_init(&ctx->wakeup_mutex); 2710 INIT_LIST_HEAD(&ctx->buffer_meta_list); 2711 spin_lock_init(&ctx->buffer_meta_lock); 2712 2713 return 0; 2714 2715err_ctrls_setup: 2716 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 2717err_ctx_init: 2718 clk_disable_unprepare(dev->clk_ahb); 2719err_clk_ahb: 2720 clk_disable_unprepare(dev->clk_per); 2721err_clk_enable: 2722 pm_runtime_put_sync(dev->dev); 2723err_pm_get: 2724 v4l2_fh_del(&ctx->fh, file); 2725 v4l2_fh_exit(&ctx->fh); 2726err_coda_name_init: 2727 ida_free(&dev->ida, ctx->idx); 2728err_coda_max: 2729 kfree(ctx); 2730 return ret; 2731} 2732 2733static int coda_release(struct file *file) 2734{ 2735 struct coda_dev *dev = video_drvdata(file); 2736 struct coda_ctx *ctx = file_to_ctx(file); 2737 2738 coda_dbg(1, ctx, "release instance (%p)\n", ctx); 2739 2740 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) 2741 coda_bit_stream_end_flag(ctx); 2742 2743 /* If this instance is running, call .job_abort and wait for it to end */ 2744 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 2745 2746 if (ctx->vdoa) 2747 vdoa_context_destroy(ctx->vdoa); 2748 2749 /* In case the instance was not running, we still need to call SEQ_END */ 2750 if (ctx->ops->seq_end_work) { 2751 queue_work(dev->workqueue, &ctx->seq_end_work); 2752 flush_work(&ctx->seq_end_work); 2753 } 2754 2755 if (ctx->dev->devtype->product == CODA_DX6) 2756 coda_free_aux_buf(dev, &ctx->workbuf); 2757 2758 v4l2_ctrl_handler_free(&ctx->ctrls); 2759 clk_disable_unprepare(dev->clk_ahb); 2760 clk_disable_unprepare(dev->clk_per); 2761 pm_runtime_put_sync(dev->dev); 2762 v4l2_fh_del(&ctx->fh, file); 2763 v4l2_fh_exit(&ctx->fh); 2764 ida_free(&dev->ida, ctx->idx); 2765 if (ctx->ops->release) 2766 ctx->ops->release(ctx); 2767 debugfs_remove_recursive(ctx->debugfs_entry); 2768 kfree(ctx); 2769 2770 return 0; 2771} 2772 2773static const struct v4l2_file_operations coda_fops = { 2774 .owner = THIS_MODULE, 2775 .open = coda_open, 2776 .release = coda_release, 2777 .poll = v4l2_m2m_fop_poll, 2778 .unlocked_ioctl = video_ioctl2, 2779 .mmap = v4l2_m2m_fop_mmap, 2780}; 2781 2782static int coda_hw_init(struct coda_dev *dev) 2783{ 2784 u32 data; 2785 u16 *p; 2786 int i, ret; 2787 2788 ret = clk_prepare_enable(dev->clk_per); 2789 if (ret) 2790 goto err_clk_per; 2791 2792 ret = clk_prepare_enable(dev->clk_ahb); 2793 if (ret) 2794 goto err_clk_ahb; 2795 2796 reset_control_reset(dev->rstc); 2797 2798 /* 2799 * Copy the first CODA_ISRAM_SIZE in the internal SRAM. 2800 * The 16-bit chars in the code buffer are in memory access 2801 * order, re-sort them to CODA order for register download. 2802 * Data in this SRAM survives a reboot. 2803 */ 2804 p = (u16 *)dev->codebuf.vaddr; 2805 if (dev->devtype->product == CODA_DX6) { 2806 for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++) { 2807 data = CODA_DOWN_ADDRESS_SET(i) | 2808 CODA_DOWN_DATA_SET(p[i ^ 1]); 2809 coda_write(dev, data, CODA_REG_BIT_CODE_DOWN); 2810 } 2811 } else { 2812 for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++) { 2813 data = CODA_DOWN_ADDRESS_SET(i) | 2814 CODA_DOWN_DATA_SET(p[round_down(i, 4) + 2815 3 - (i % 4)]); 2816 coda_write(dev, data, CODA_REG_BIT_CODE_DOWN); 2817 } 2818 } 2819 2820 /* Clear registers */ 2821 for (i = 0; i < 64; i++) 2822 coda_write(dev, 0, CODA_REG_BIT_CODE_BUF_ADDR + i * 4); 2823 2824 /* Tell the BIT where to find everything it needs */ 2825 if (dev->devtype->product == CODA_960 || 2826 dev->devtype->product == CODA_7541 || 2827 dev->devtype->product == CODA_HX4) { 2828 coda_write(dev, dev->tempbuf.paddr, 2829 CODA_REG_BIT_TEMP_BUF_ADDR); 2830 coda_write(dev, 0, CODA_REG_BIT_BIT_STREAM_PARAM); 2831 } else { 2832 coda_write(dev, dev->workbuf.paddr, 2833 CODA_REG_BIT_WORK_BUF_ADDR); 2834 } 2835 coda_write(dev, dev->codebuf.paddr, 2836 CODA_REG_BIT_CODE_BUF_ADDR); 2837 coda_write(dev, 0, CODA_REG_BIT_CODE_RUN); 2838 2839 /* Set default values */ 2840 switch (dev->devtype->product) { 2841 case CODA_DX6: 2842 coda_write(dev, CODADX6_STREAM_BUF_PIC_FLUSH, 2843 CODA_REG_BIT_STREAM_CTRL); 2844 break; 2845 default: 2846 coda_write(dev, CODA7_STREAM_BUF_PIC_FLUSH, 2847 CODA_REG_BIT_STREAM_CTRL); 2848 } 2849 if (dev->devtype->product == CODA_960) 2850 coda_write(dev, CODA9_FRAME_ENABLE_BWB, 2851 CODA_REG_BIT_FRAME_MEM_CTRL); 2852 else 2853 coda_write(dev, 0, CODA_REG_BIT_FRAME_MEM_CTRL); 2854 2855 if (dev->devtype->product != CODA_DX6) 2856 coda_write(dev, 0, CODA7_REG_BIT_AXI_SRAM_USE); 2857 2858 coda_write(dev, CODA_INT_INTERRUPT_ENABLE, 2859 CODA_REG_BIT_INT_ENABLE); 2860 2861 /* Reset VPU and start processor */ 2862 data = coda_read(dev, CODA_REG_BIT_CODE_RESET); 2863 data |= CODA_REG_RESET_ENABLE; 2864 coda_write(dev, data, CODA_REG_BIT_CODE_RESET); 2865 udelay(10); 2866 data &= ~CODA_REG_RESET_ENABLE; 2867 coda_write(dev, data, CODA_REG_BIT_CODE_RESET); 2868 coda_write(dev, CODA_REG_RUN_ENABLE, CODA_REG_BIT_CODE_RUN); 2869 2870 clk_disable_unprepare(dev->clk_ahb); 2871 clk_disable_unprepare(dev->clk_per); 2872 2873 return 0; 2874 2875err_clk_ahb: 2876 clk_disable_unprepare(dev->clk_per); 2877err_clk_per: 2878 return ret; 2879} 2880 2881static int coda_register_device(struct coda_dev *dev, int i) 2882{ 2883 struct video_device *vfd = &dev->vfd[i]; 2884 const char *name; 2885 int ret; 2886 2887 if (i >= dev->devtype->num_vdevs) 2888 return -EINVAL; 2889 name = dev->devtype->vdevs[i]->name; 2890 2891 strscpy(vfd->name, dev->devtype->vdevs[i]->name, sizeof(vfd->name)); 2892 vfd->fops = &coda_fops; 2893 vfd->ioctl_ops = &coda_ioctl_ops; 2894 vfd->release = video_device_release_empty; 2895 vfd->lock = &dev->dev_mutex; 2896 vfd->v4l2_dev = &dev->v4l2_dev; 2897 vfd->vfl_dir = VFL_DIR_M2M; 2898 vfd->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING; 2899 video_set_drvdata(vfd, dev); 2900 2901 /* Not applicable, use the selection API instead */ 2902 v4l2_disable_ioctl(vfd, VIDIOC_CROPCAP); 2903 v4l2_disable_ioctl(vfd, VIDIOC_G_CROP); 2904 v4l2_disable_ioctl(vfd, VIDIOC_S_CROP); 2905 2906 if (dev->devtype->vdevs[i]->type == CODA_INST_ENCODER) { 2907 v4l2_disable_ioctl(vfd, VIDIOC_DECODER_CMD); 2908 v4l2_disable_ioctl(vfd, VIDIOC_TRY_DECODER_CMD); 2909 if (dev->devtype->vdevs[i]->dst_formats[0] == V4L2_PIX_FMT_JPEG) { 2910 v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMEINTERVALS); 2911 v4l2_disable_ioctl(vfd, VIDIOC_G_PARM); 2912 v4l2_disable_ioctl(vfd, VIDIOC_S_PARM); 2913 } 2914 } else { 2915 v4l2_disable_ioctl(vfd, VIDIOC_ENCODER_CMD); 2916 v4l2_disable_ioctl(vfd, VIDIOC_TRY_ENCODER_CMD); 2917 v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMESIZES); 2918 v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMEINTERVALS); 2919 v4l2_disable_ioctl(vfd, VIDIOC_G_PARM); 2920 v4l2_disable_ioctl(vfd, VIDIOC_S_PARM); 2921 } 2922 2923 ret = video_register_device(vfd, VFL_TYPE_VIDEO, 0); 2924 if (!ret) 2925 v4l2_info(&dev->v4l2_dev, "%s registered as %s\n", 2926 name, video_device_node_name(vfd)); 2927 return ret; 2928} 2929 2930static void coda_copy_firmware(struct coda_dev *dev, const u8 * const buf, 2931 size_t size) 2932{ 2933 u32 *src = (u32 *)buf; 2934 2935 /* Check if the firmware has a 16-byte Freescale header, skip it */ 2936 if (buf[0] == 'M' && buf[1] == 'X') 2937 src += 4; 2938 /* 2939 * Check whether the firmware is in native order or pre-reordered for 2940 * memory access. The first instruction opcode always is 0xe40e. 2941 */ 2942 if (__le16_to_cpup((__le16 *)src) == 0xe40e) { 2943 u32 *dst = dev->codebuf.vaddr; 2944 int i; 2945 2946 /* Firmware in native order, reorder while copying */ 2947 if (dev->devtype->product == CODA_DX6) { 2948 for (i = 0; i < (size - 16) / 4; i++) 2949 dst[i] = (src[i] << 16) | (src[i] >> 16); 2950 } else { 2951 for (i = 0; i < (size - 16) / 4; i += 2) { 2952 dst[i] = (src[i + 1] << 16) | (src[i + 1] >> 16); 2953 dst[i + 1] = (src[i] << 16) | (src[i] >> 16); 2954 } 2955 } 2956 } else { 2957 /* Copy the already reordered firmware image */ 2958 memcpy(dev->codebuf.vaddr, src, size); 2959 } 2960} 2961 2962static void coda_fw_callback(const struct firmware *fw, void *context); 2963 2964static int coda_firmware_request(struct coda_dev *dev) 2965{ 2966 char *fw; 2967 2968 if (dev->firmware >= ARRAY_SIZE(dev->devtype->firmware)) 2969 return -EINVAL; 2970 2971 fw = dev->devtype->firmware[dev->firmware]; 2972 2973 dev_dbg(dev->dev, "requesting firmware '%s' for %s\n", fw, 2974 coda_product_name(dev->devtype->product)); 2975 2976 return request_firmware_nowait(THIS_MODULE, true, fw, dev->dev, 2977 GFP_KERNEL, dev, coda_fw_callback); 2978} 2979 2980static void coda_fw_callback(const struct firmware *fw, void *context) 2981{ 2982 struct coda_dev *dev = context; 2983 int i, ret; 2984 2985 if (!fw) { 2986 dev->firmware++; 2987 ret = coda_firmware_request(dev); 2988 if (ret < 0) { 2989 v4l2_err(&dev->v4l2_dev, "firmware request failed\n"); 2990 goto put_pm; 2991 } 2992 return; 2993 } 2994 if (dev->firmware > 0) { 2995 /* 2996 * Since we can't suppress warnings for failed asynchronous 2997 * firmware requests, report that the fallback firmware was 2998 * found. 2999 */ 3000 dev_info(dev->dev, "Using fallback firmware %s\n", 3001 dev->devtype->firmware[dev->firmware]); 3002 } 3003 3004 /* allocate auxiliary per-device code buffer for the BIT processor */ 3005 ret = coda_alloc_aux_buf(dev, &dev->codebuf, fw->size, "codebuf", 3006 dev->debugfs_root); 3007 if (ret < 0) 3008 goto put_pm; 3009 3010 coda_copy_firmware(dev, fw->data, fw->size); 3011 release_firmware(fw); 3012 3013 ret = coda_hw_init(dev); 3014 if (ret < 0) { 3015 v4l2_err(&dev->v4l2_dev, "HW initialization failed\n"); 3016 goto put_pm; 3017 } 3018 3019 ret = coda_check_firmware(dev); 3020 if (ret < 0) 3021 goto put_pm; 3022 3023 dev->m2m_dev = v4l2_m2m_init(&coda_m2m_ops); 3024 if (IS_ERR(dev->m2m_dev)) { 3025 v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n"); 3026 goto put_pm; 3027 } 3028 3029 for (i = 0; i < dev->devtype->num_vdevs; i++) { 3030 ret = coda_register_device(dev, i); 3031 if (ret) { 3032 v4l2_err(&dev->v4l2_dev, 3033 "Failed to register %s video device: %d\n", 3034 dev->devtype->vdevs[i]->name, ret); 3035 goto rel_vfd; 3036 } 3037 } 3038 3039 pm_runtime_put_sync(dev->dev); 3040 return; 3041 3042rel_vfd: 3043 while (--i >= 0) 3044 video_unregister_device(&dev->vfd[i]); 3045 v4l2_m2m_release(dev->m2m_dev); 3046put_pm: 3047 pm_runtime_put_sync(dev->dev); 3048} 3049 3050enum coda_platform { 3051 CODA_IMX27, 3052 CODA_IMX51, 3053 CODA_IMX53, 3054 CODA_IMX6Q, 3055 CODA_IMX6DL, 3056}; 3057 3058static const struct coda_devtype coda_devdata[] = { 3059 [CODA_IMX27] = { 3060 .firmware = { 3061 "vpu_fw_imx27_TO2.bin", 3062 "vpu/vpu_fw_imx27_TO2.bin", 3063 "v4l-codadx6-imx27.bin" 3064 }, 3065 .product = CODA_DX6, 3066 .codecs = codadx6_codecs, 3067 .num_codecs = ARRAY_SIZE(codadx6_codecs), 3068 .vdevs = codadx6_video_devices, 3069 .num_vdevs = ARRAY_SIZE(codadx6_video_devices), 3070 .workbuf_size = 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE * 8 * 1024, 3071 .iram_size = 0xb000, 3072 }, 3073 [CODA_IMX51] = { 3074 .firmware = { 3075 "vpu_fw_imx51.bin", 3076 "vpu/vpu_fw_imx51.bin", 3077 "v4l-codahx4-imx51.bin" 3078 }, 3079 .product = CODA_HX4, 3080 .codecs = codahx4_codecs, 3081 .num_codecs = ARRAY_SIZE(codahx4_codecs), 3082 .vdevs = codahx4_video_devices, 3083 .num_vdevs = ARRAY_SIZE(codahx4_video_devices), 3084 .workbuf_size = 128 * 1024, 3085 .tempbuf_size = 304 * 1024, 3086 .iram_size = 0x14000, 3087 }, 3088 [CODA_IMX53] = { 3089 .firmware = { 3090 "vpu_fw_imx53.bin", 3091 "vpu/vpu_fw_imx53.bin", 3092 "v4l-coda7541-imx53.bin" 3093 }, 3094 .product = CODA_7541, 3095 .codecs = coda7_codecs, 3096 .num_codecs = ARRAY_SIZE(coda7_codecs), 3097 .vdevs = coda7_video_devices, 3098 .num_vdevs = ARRAY_SIZE(coda7_video_devices), 3099 .workbuf_size = 128 * 1024, 3100 .tempbuf_size = 304 * 1024, 3101 .iram_size = 0x14000, 3102 }, 3103 [CODA_IMX6Q] = { 3104 .firmware = { 3105 "vpu_fw_imx6q.bin", 3106 "vpu/vpu_fw_imx6q.bin", 3107 "v4l-coda960-imx6q.bin" 3108 }, 3109 .product = CODA_960, 3110 .codecs = coda9_codecs, 3111 .num_codecs = ARRAY_SIZE(coda9_codecs), 3112 .vdevs = coda9_video_devices, 3113 .num_vdevs = ARRAY_SIZE(coda9_video_devices), 3114 .workbuf_size = 80 * 1024, 3115 .tempbuf_size = 204 * 1024, 3116 .iram_size = 0x21000, 3117 }, 3118 [CODA_IMX6DL] = { 3119 .firmware = { 3120 "vpu_fw_imx6d.bin", 3121 "vpu/vpu_fw_imx6d.bin", 3122 "v4l-coda960-imx6dl.bin" 3123 }, 3124 .product = CODA_960, 3125 .codecs = coda9_codecs, 3126 .num_codecs = ARRAY_SIZE(coda9_codecs), 3127 .vdevs = coda9_video_devices, 3128 .num_vdevs = ARRAY_SIZE(coda9_video_devices), 3129 .workbuf_size = 80 * 1024, 3130 .tempbuf_size = 204 * 1024, 3131 .iram_size = 0x1f000, /* leave 4k for suspend code */ 3132 }, 3133}; 3134 3135static const struct of_device_id coda_dt_ids[] = { 3136 { .compatible = "fsl,imx27-vpu", .data = &coda_devdata[CODA_IMX27] }, 3137 { .compatible = "fsl,imx51-vpu", .data = &coda_devdata[CODA_IMX51] }, 3138 { .compatible = "fsl,imx53-vpu", .data = &coda_devdata[CODA_IMX53] }, 3139 { .compatible = "fsl,imx6q-vpu", .data = &coda_devdata[CODA_IMX6Q] }, 3140 { .compatible = "fsl,imx6dl-vpu", .data = &coda_devdata[CODA_IMX6DL] }, 3141 { /* sentinel */ } 3142}; 3143MODULE_DEVICE_TABLE(of, coda_dt_ids); 3144 3145static int coda_probe(struct platform_device *pdev) 3146{ 3147 struct device_node *np = pdev->dev.of_node; 3148 struct gen_pool *pool; 3149 struct coda_dev *dev; 3150 int ret, irq; 3151 3152 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL); 3153 if (!dev) 3154 return -ENOMEM; 3155 3156 dev->devtype = of_device_get_match_data(&pdev->dev); 3157 3158 dev->dev = &pdev->dev; 3159 dev->clk_per = devm_clk_get(&pdev->dev, "per"); 3160 if (IS_ERR(dev->clk_per)) { 3161 dev_err(&pdev->dev, "Could not get per clock\n"); 3162 return PTR_ERR(dev->clk_per); 3163 } 3164 3165 dev->clk_ahb = devm_clk_get(&pdev->dev, "ahb"); 3166 if (IS_ERR(dev->clk_ahb)) { 3167 dev_err(&pdev->dev, "Could not get ahb clock\n"); 3168 return PTR_ERR(dev->clk_ahb); 3169 } 3170 3171 /* Get memory for physical registers */ 3172 dev->regs_base = devm_platform_ioremap_resource(pdev, 0); 3173 if (IS_ERR(dev->regs_base)) 3174 return PTR_ERR(dev->regs_base); 3175 3176 /* IRQ */ 3177 irq = platform_get_irq_byname(pdev, "bit"); 3178 if (irq < 0) 3179 irq = platform_get_irq(pdev, 0); 3180 if (irq < 0) 3181 return irq; 3182 3183 ret = devm_request_irq(&pdev->dev, irq, coda_irq_handler, 0, 3184 CODA_NAME "-video", dev); 3185 if (ret < 0) { 3186 dev_err(&pdev->dev, "failed to request irq: %d\n", ret); 3187 return ret; 3188 } 3189 3190 /* JPEG IRQ */ 3191 if (dev->devtype->product == CODA_960) { 3192 irq = platform_get_irq_byname(pdev, "jpeg"); 3193 if (irq < 0) 3194 return irq; 3195 3196 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 3197 coda9_jpeg_irq_handler, 3198 IRQF_ONESHOT, CODA_NAME "-jpeg", 3199 dev); 3200 if (ret < 0) { 3201 dev_err(&pdev->dev, "failed to request jpeg irq\n"); 3202 return ret; 3203 } 3204 } 3205 3206 dev->rstc = devm_reset_control_get_optional_exclusive(&pdev->dev, 3207 NULL); 3208 if (IS_ERR(dev->rstc)) { 3209 ret = PTR_ERR(dev->rstc); 3210 dev_err(&pdev->dev, "failed get reset control: %d\n", ret); 3211 return ret; 3212 } 3213 3214 /* Get IRAM pool from device tree */ 3215 pool = of_gen_pool_get(np, "iram", 0); 3216 if (!pool) { 3217 dev_err(&pdev->dev, "iram pool not available\n"); 3218 return -ENOMEM; 3219 } 3220 dev->iram_pool = pool; 3221 3222 /* Get vdoa_data if supported by the platform */ 3223 dev->vdoa = coda_get_vdoa_data(); 3224 if (PTR_ERR(dev->vdoa) == -EPROBE_DEFER) 3225 return -EPROBE_DEFER; 3226 3227 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev); 3228 if (ret) 3229 return ret; 3230 3231 ratelimit_default_init(&dev->mb_err_rs); 3232 mutex_init(&dev->dev_mutex); 3233 mutex_init(&dev->coda_mutex); 3234 ida_init(&dev->ida); 3235 3236 dev->debugfs_root = debugfs_create_dir("coda", NULL); 3237 3238 /* allocate auxiliary per-device buffers for the BIT processor */ 3239 if (dev->devtype->product == CODA_DX6) { 3240 ret = coda_alloc_aux_buf(dev, &dev->workbuf, 3241 dev->devtype->workbuf_size, "workbuf", 3242 dev->debugfs_root); 3243 if (ret < 0) 3244 goto err_v4l2_register; 3245 } 3246 3247 if (dev->devtype->tempbuf_size) { 3248 ret = coda_alloc_aux_buf(dev, &dev->tempbuf, 3249 dev->devtype->tempbuf_size, "tempbuf", 3250 dev->debugfs_root); 3251 if (ret < 0) 3252 goto err_v4l2_register; 3253 } 3254 3255 dev->iram.size = dev->devtype->iram_size; 3256 dev->iram.vaddr = gen_pool_dma_alloc(dev->iram_pool, dev->iram.size, 3257 &dev->iram.paddr); 3258 if (!dev->iram.vaddr) { 3259 dev_warn(&pdev->dev, "unable to alloc iram\n"); 3260 } else { 3261 memset(dev->iram.vaddr, 0, dev->iram.size); 3262 dev->iram.blob.data = dev->iram.vaddr; 3263 dev->iram.blob.size = dev->iram.size; 3264 dev->iram.dentry = debugfs_create_blob("iram", 0444, 3265 dev->debugfs_root, 3266 &dev->iram.blob); 3267 } 3268 3269 dev->workqueue = alloc_ordered_workqueue("coda", WQ_MEM_RECLAIM); 3270 if (!dev->workqueue) { 3271 dev_err(&pdev->dev, "unable to alloc workqueue\n"); 3272 ret = -ENOMEM; 3273 goto err_v4l2_register; 3274 } 3275 3276 platform_set_drvdata(pdev, dev); 3277 3278 /* 3279 * Start activated so we can directly call coda_hw_init in 3280 * coda_fw_callback regardless of whether CONFIG_PM is 3281 * enabled or whether the device is associated with a PM domain. 3282 */ 3283 pm_runtime_get_noresume(&pdev->dev); 3284 pm_runtime_set_active(&pdev->dev); 3285 pm_runtime_enable(&pdev->dev); 3286 3287 ret = coda_firmware_request(dev); 3288 if (ret) 3289 goto err_alloc_workqueue; 3290 return 0; 3291 3292err_alloc_workqueue: 3293 pm_runtime_disable(&pdev->dev); 3294 pm_runtime_put_noidle(&pdev->dev); 3295 destroy_workqueue(dev->workqueue); 3296err_v4l2_register: 3297 v4l2_device_unregister(&dev->v4l2_dev); 3298 return ret; 3299} 3300 3301static void coda_remove(struct platform_device *pdev) 3302{ 3303 struct coda_dev *dev = platform_get_drvdata(pdev); 3304 int i; 3305 3306 for (i = 0; i < ARRAY_SIZE(dev->vfd); i++) { 3307 if (video_get_drvdata(&dev->vfd[i])) 3308 video_unregister_device(&dev->vfd[i]); 3309 } 3310 if (dev->m2m_dev) 3311 v4l2_m2m_release(dev->m2m_dev); 3312 pm_runtime_disable(&pdev->dev); 3313 v4l2_device_unregister(&dev->v4l2_dev); 3314 destroy_workqueue(dev->workqueue); 3315 if (dev->iram.vaddr) 3316 gen_pool_free(dev->iram_pool, (unsigned long)dev->iram.vaddr, 3317 dev->iram.size); 3318 coda_free_aux_buf(dev, &dev->codebuf); 3319 coda_free_aux_buf(dev, &dev->tempbuf); 3320 coda_free_aux_buf(dev, &dev->workbuf); 3321 debugfs_remove_recursive(dev->debugfs_root); 3322 ida_destroy(&dev->ida); 3323} 3324 3325#ifdef CONFIG_PM 3326static int coda_runtime_resume(struct device *dev) 3327{ 3328 struct coda_dev *cdev = dev_get_drvdata(dev); 3329 int ret = 0; 3330 3331 if (dev->pm_domain && cdev->codebuf.vaddr) { 3332 ret = coda_hw_init(cdev); 3333 if (ret) 3334 v4l2_err(&cdev->v4l2_dev, "HW initialization failed\n"); 3335 } 3336 3337 return ret; 3338} 3339#endif 3340 3341static const struct dev_pm_ops coda_pm_ops = { 3342 SET_RUNTIME_PM_OPS(NULL, coda_runtime_resume, NULL) 3343 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) 3344}; 3345 3346static struct platform_driver coda_driver = { 3347 .probe = coda_probe, 3348 .remove = coda_remove, 3349 .driver = { 3350 .name = CODA_NAME, 3351 .of_match_table = coda_dt_ids, 3352 .pm = &coda_pm_ops, 3353 }, 3354}; 3355 3356module_platform_driver(coda_driver); 3357 3358MODULE_LICENSE("GPL"); 3359MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>"); 3360MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");
~/
Read-only file preview.