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 59 int coda_debug; 60 module_param(coda_debug, int, 0644); 61 MODULE_PARM_DESC(coda_debug, "Debug level (0-2)"); 62 63 static int disable_tiling; 64 module_param(disable_tiling, int, 0644); 65 MODULE_PARM_DESC(disable_tiling, "Disable tiled frame buffers"); 66 67 static int disable_vdoa; 68 module_param(disable_vdoa, int, 0644); 69 MODULE_PARM_DESC(disable_vdoa, "Disable Video Data Order Adapter tiled to raster-scan conversion"); 70 71 static int enable_bwb = 0; 72 module_param(enable_bwb, int, 0644); 73 MODULE_PARM_DESC(enable_bwb, "Enable BWB unit for decoding, may crash on certain streams"); 74 75 void coda_write(struct coda_dev *dev, u32 data, u32 reg) 76 { 77 v4l2_dbg(3, coda_debug, &dev->v4l2_dev, 78 "%s: data=0x%x, reg=0x%x\n", __func__, data, reg); 79 writel(data, dev->regs_base + reg); 80 } 81 82 unsigned int coda_read(struct coda_dev *dev, u32 reg) 83 { 84 u32 data; 85 86 data = readl(dev->regs_base + reg); 87 v4l2_dbg(3, coda_debug, &dev->v4l2_dev, 88 "%s: data=0x%x, reg=0x%x\n", __func__, data, reg); 89 return data; 90 } 91 92 void coda_write_base(struct coda_ctx *ctx, struct coda_q_data *q_data, 93 struct vb2_v4l2_buffer *buf, unsigned int reg_y) 94 { 95 u32 base_y = vb2_dma_contig_plane_dma_addr(&buf->vb2_buf, 0); 96 u32 base_cb, base_cr; 97 98 switch (q_data->fourcc) { 99 case V4L2_PIX_FMT_YUYV: 100 /* Fallthrough: IN -H264-> CODA -NV12 MB-> VDOA -YUYV-> OUT */ 101 case V4L2_PIX_FMT_NV12: 102 case V4L2_PIX_FMT_YUV420: 103 default: 104 base_cb = base_y + q_data->bytesperline * q_data->height; 105 base_cr = base_cb + q_data->bytesperline * q_data->height / 4; 106 break; 107 case V4L2_PIX_FMT_YVU420: 108 /* Switch Cb and Cr for YVU420 format */ 109 base_cr = base_y + q_data->bytesperline * q_data->height; 110 base_cb = base_cr + q_data->bytesperline * q_data->height / 4; 111 break; 112 case V4L2_PIX_FMT_YUV422P: 113 base_cb = base_y + q_data->bytesperline * q_data->height; 114 base_cr = base_cb + q_data->bytesperline * q_data->height / 2; 115 } 116 117 coda_write(ctx->dev, base_y, reg_y); 118 coda_write(ctx->dev, base_cb, reg_y + 4); 119 coda_write(ctx->dev, base_cr, reg_y + 8); 120 } 121 122 #define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \ 123 { mode, src_fourcc, dst_fourcc, max_w, max_h } 124 125 /* 126 * Arrays of codecs supported by each given version of Coda: 127 * i.MX27 -> codadx6 128 * i.MX51 -> codahx4 129 * i.MX53 -> coda7 130 * i.MX6 -> coda960 131 * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants 132 */ 133 static const struct coda_codec codadx6_codecs[] = { 134 CODA_CODEC(CODADX6_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 720, 576), 135 CODA_CODEC(CODADX6_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 720, 576), 136 }; 137 138 static const struct coda_codec codahx4_codecs[] = { 139 CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 720, 576), 140 CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 141 CODA_CODEC(CODA7_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 142 CODA_CODEC(CODA7_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1280, 720), 143 }; 144 145 static const struct coda_codec coda7_codecs[] = { 146 CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 1280, 720), 147 CODA_CODEC(CODA7_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 1280, 720), 148 CODA_CODEC(CODA7_MODE_ENCODE_MJPG, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_JPEG, 8192, 8192), 149 CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 150 CODA_CODEC(CODA7_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 151 CODA_CODEC(CODA7_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1920, 1088), 152 CODA_CODEC(CODA7_MODE_DECODE_MJPG, V4L2_PIX_FMT_JPEG, V4L2_PIX_FMT_YUV420, 8192, 8192), 153 }; 154 155 static const struct coda_codec coda9_codecs[] = { 156 CODA_CODEC(CODA9_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264, 1920, 1088), 157 CODA_CODEC(CODA9_MODE_ENCODE_MP4, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 1920, 1088), 158 CODA_CODEC(CODA9_MODE_ENCODE_MJPG, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_JPEG, 8192, 8192), 159 CODA_CODEC(CODA9_MODE_DECODE_H264, V4L2_PIX_FMT_H264, V4L2_PIX_FMT_YUV420, 1920, 1088), 160 CODA_CODEC(CODA9_MODE_DECODE_MP2, V4L2_PIX_FMT_MPEG2, V4L2_PIX_FMT_YUV420, 1920, 1088), 161 CODA_CODEC(CODA9_MODE_DECODE_MP4, V4L2_PIX_FMT_MPEG4, V4L2_PIX_FMT_YUV420, 1920, 1088), 162 CODA_CODEC(CODA9_MODE_DECODE_MJPG, V4L2_PIX_FMT_JPEG, V4L2_PIX_FMT_YUV420, 8192, 8192), 163 }; 164 165 struct coda_video_device { 166 const char *name; 167 enum coda_inst_type type; 168 const struct coda_context_ops *ops; 169 bool direct; 170 u32 src_formats[CODA_MAX_FORMATS]; 171 u32 dst_formats[CODA_MAX_FORMATS]; 172 }; 173 174 static const struct coda_video_device coda_bit_encoder = { 175 .name = "coda-video-encoder", 176 .type = CODA_INST_ENCODER, 177 .ops = &coda_bit_encode_ops, 178 .src_formats = { 179 V4L2_PIX_FMT_NV12, 180 V4L2_PIX_FMT_YUV420, 181 V4L2_PIX_FMT_YVU420, 182 }, 183 .dst_formats = { 184 V4L2_PIX_FMT_H264, 185 V4L2_PIX_FMT_MPEG4, 186 }, 187 }; 188 189 static const struct coda_video_device coda_bit_jpeg_encoder = { 190 .name = "coda-jpeg-encoder", 191 .type = CODA_INST_ENCODER, 192 .ops = &coda_bit_encode_ops, 193 .src_formats = { 194 V4L2_PIX_FMT_NV12, 195 V4L2_PIX_FMT_YUV420, 196 V4L2_PIX_FMT_YVU420, 197 V4L2_PIX_FMT_YUV422P, 198 }, 199 .dst_formats = { 200 V4L2_PIX_FMT_JPEG, 201 }, 202 }; 203 204 static const struct coda_video_device coda_bit_decoder = { 205 .name = "coda-video-decoder", 206 .type = CODA_INST_DECODER, 207 .ops = &coda_bit_decode_ops, 208 .src_formats = { 209 V4L2_PIX_FMT_H264, 210 V4L2_PIX_FMT_MPEG2, 211 V4L2_PIX_FMT_MPEG4, 212 }, 213 .dst_formats = { 214 V4L2_PIX_FMT_NV12, 215 V4L2_PIX_FMT_YUV420, 216 V4L2_PIX_FMT_YVU420, 217 /* 218 * If V4L2_PIX_FMT_YUYV should be default, 219 * set_default_params() must be adjusted. 220 */ 221 V4L2_PIX_FMT_YUYV, 222 }, 223 }; 224 225 static const struct coda_video_device coda_bit_jpeg_decoder = { 226 .name = "coda-jpeg-decoder", 227 .type = CODA_INST_DECODER, 228 .ops = &coda_bit_decode_ops, 229 .src_formats = { 230 V4L2_PIX_FMT_JPEG, 231 }, 232 .dst_formats = { 233 V4L2_PIX_FMT_NV12, 234 V4L2_PIX_FMT_YUV420, 235 V4L2_PIX_FMT_YVU420, 236 V4L2_PIX_FMT_YUV422P, 237 }, 238 }; 239 240 static const struct coda_video_device coda9_jpeg_encoder = { 241 .name = "coda-jpeg-encoder", 242 .type = CODA_INST_ENCODER, 243 .ops = &coda9_jpeg_encode_ops, 244 .direct = true, 245 .src_formats = { 246 V4L2_PIX_FMT_NV12, 247 V4L2_PIX_FMT_YUV420, 248 V4L2_PIX_FMT_YVU420, 249 V4L2_PIX_FMT_YUV422P, 250 V4L2_PIX_FMT_GREY, 251 }, 252 .dst_formats = { 253 V4L2_PIX_FMT_JPEG, 254 }, 255 }; 256 257 static const struct coda_video_device coda9_jpeg_decoder = { 258 .name = "coda-jpeg-decoder", 259 .type = CODA_INST_DECODER, 260 .ops = &coda9_jpeg_decode_ops, 261 .direct = true, 262 .src_formats = { 263 V4L2_PIX_FMT_JPEG, 264 }, 265 .dst_formats = { 266 V4L2_PIX_FMT_NV12, 267 V4L2_PIX_FMT_YUV420, 268 V4L2_PIX_FMT_YVU420, 269 V4L2_PIX_FMT_YUV422P, 270 }, 271 }; 272 273 static const struct coda_video_device *codadx6_video_devices[] = { 274 &coda_bit_encoder, 275 }; 276 277 static const struct coda_video_device *codahx4_video_devices[] = { 278 &coda_bit_encoder, 279 &coda_bit_decoder, 280 }; 281 282 static const struct coda_video_device *coda7_video_devices[] = { 283 &coda_bit_jpeg_encoder, 284 &coda_bit_jpeg_decoder, 285 &coda_bit_encoder, 286 &coda_bit_decoder, 287 }; 288 289 static const struct coda_video_device *coda9_video_devices[] = { 290 &coda9_jpeg_encoder, 291 &coda9_jpeg_decoder, 292 &coda_bit_encoder, 293 &coda_bit_decoder, 294 }; 295 296 /* 297 * Normalize all supported YUV 4:2:0 formats to the value used in the codec 298 * tables. 299 */ 300 static u32 coda_format_normalize_yuv(u32 fourcc) 301 { 302 switch (fourcc) { 303 case V4L2_PIX_FMT_NV12: 304 case V4L2_PIX_FMT_YUV420: 305 case V4L2_PIX_FMT_YVU420: 306 case V4L2_PIX_FMT_YUV422P: 307 case V4L2_PIX_FMT_YUYV: 308 return V4L2_PIX_FMT_YUV420; 309 default: 310 return fourcc; 311 } 312 } 313 314 static const struct coda_codec *coda_find_codec(struct coda_dev *dev, 315 int src_fourcc, int dst_fourcc) 316 { 317 const struct coda_codec *codecs = dev->devtype->codecs; 318 int num_codecs = dev->devtype->num_codecs; 319 int k; 320 321 src_fourcc = coda_format_normalize_yuv(src_fourcc); 322 dst_fourcc = coda_format_normalize_yuv(dst_fourcc); 323 if (src_fourcc == dst_fourcc) 324 return NULL; 325 326 for (k = 0; k < num_codecs; k++) { 327 if (codecs[k].src_fourcc == src_fourcc && 328 codecs[k].dst_fourcc == dst_fourcc) 329 break; 330 } 331 332 if (k == num_codecs) 333 return NULL; 334 335 return &codecs[k]; 336 } 337 338 static void coda_get_max_dimensions(struct coda_dev *dev, 339 const struct coda_codec *codec, 340 int *max_w, int *max_h) 341 { 342 const struct coda_codec *codecs = dev->devtype->codecs; 343 int num_codecs = dev->devtype->num_codecs; 344 unsigned int w, h; 345 int k; 346 347 if (codec) { 348 w = codec->max_w; 349 h = codec->max_h; 350 } else { 351 for (k = 0, w = 0, h = 0; k < num_codecs; k++) { 352 w = max(w, codecs[k].max_w); 353 h = max(h, codecs[k].max_h); 354 } 355 } 356 357 if (max_w) 358 *max_w = w; 359 if (max_h) 360 *max_h = h; 361 } 362 363 static const struct coda_video_device *to_coda_video_device(struct video_device 364 *vdev) 365 { 366 struct coda_dev *dev = video_get_drvdata(vdev); 367 unsigned int i = vdev - dev->vfd; 368 369 if (i >= dev->devtype->num_vdevs) 370 return NULL; 371 372 return dev->devtype->vdevs[i]; 373 } 374 375 const char *coda_product_name(int product) 376 { 377 static char buf[9]; 378 379 switch (product) { 380 case CODA_DX6: 381 return "CodaDx6"; 382 case CODA_HX4: 383 return "CodaHx4"; 384 case CODA_7541: 385 return "CODA7541"; 386 case CODA_960: 387 return "CODA960"; 388 default: 389 snprintf(buf, sizeof(buf), "(0x%04x)", product); 390 return buf; 391 } 392 } 393 394 static struct vdoa_data *coda_get_vdoa_data(void) 395 { 396 struct device_node *vdoa_node; 397 struct platform_device *vdoa_pdev; 398 struct vdoa_data *vdoa_data = NULL; 399 400 vdoa_node = of_find_compatible_node(NULL, NULL, "fsl,imx6q-vdoa"); 401 if (!vdoa_node) 402 return NULL; 403 404 vdoa_pdev = of_find_device_by_node(vdoa_node); 405 if (!vdoa_pdev) 406 goto out; 407 408 vdoa_data = platform_get_drvdata(vdoa_pdev); 409 if (!vdoa_data) 410 vdoa_data = ERR_PTR(-EPROBE_DEFER); 411 412 put_device(&vdoa_pdev->dev); 413 out: 414 of_node_put(vdoa_node); 415 416 return vdoa_data; 417 } 418 419 /* 420 * V4L2 ioctl() operations. 421 */ 422 static int coda_querycap(struct file *file, void *priv, 423 struct v4l2_capability *cap) 424 { 425 struct coda_ctx *ctx = fh_to_ctx(priv); 426 427 strscpy(cap->driver, CODA_NAME, sizeof(cap->driver)); 428 strscpy(cap->card, coda_product_name(ctx->dev->devtype->product), 429 sizeof(cap->card)); 430 strscpy(cap->bus_info, "platform:" CODA_NAME, sizeof(cap->bus_info)); 431 return 0; 432 } 433 434 static const u32 coda_formats_420[CODA_MAX_FORMATS] = { 435 V4L2_PIX_FMT_NV12, 436 V4L2_PIX_FMT_YUV420, 437 V4L2_PIX_FMT_YVU420, 438 }; 439 440 static int coda_enum_fmt(struct file *file, void *priv, 441 struct v4l2_fmtdesc *f) 442 { 443 struct video_device *vdev = video_devdata(file); 444 const struct coda_video_device *cvd = to_coda_video_device(vdev); 445 struct coda_ctx *ctx = fh_to_ctx(priv); 446 const u32 *formats; 447 448 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 449 formats = cvd->src_formats; 450 else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 451 struct coda_q_data *q_data_src; 452 struct vb2_queue *src_vq; 453 454 formats = cvd->dst_formats; 455 456 /* 457 * If the source format is already fixed, only allow the same 458 * chroma subsampling. 459 */ 460 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 461 src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, 462 V4L2_BUF_TYPE_VIDEO_OUTPUT); 463 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 464 vb2_is_streaming(src_vq)) { 465 if (ctx->params.jpeg_chroma_subsampling == 466 V4L2_JPEG_CHROMA_SUBSAMPLING_420) { 467 formats = coda_formats_420; 468 } else if (ctx->params.jpeg_chroma_subsampling == 469 V4L2_JPEG_CHROMA_SUBSAMPLING_422) { 470 f->pixelformat = V4L2_PIX_FMT_YUV422P; 471 return f->index ? -EINVAL : 0; 472 } 473 } 474 } else { 475 return -EINVAL; 476 } 477 478 if (f->index >= CODA_MAX_FORMATS || formats[f->index] == 0) 479 return -EINVAL; 480 481 /* Skip YUYV if the vdoa is not available */ 482 if (!ctx->vdoa && f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 483 formats[f->index] == V4L2_PIX_FMT_YUYV) 484 return -EINVAL; 485 486 f->pixelformat = formats[f->index]; 487 488 return 0; 489 } 490 491 static int coda_g_fmt(struct file *file, void *priv, 492 struct v4l2_format *f) 493 { 494 struct coda_q_data *q_data; 495 struct coda_ctx *ctx = fh_to_ctx(priv); 496 497 q_data = get_q_data(ctx, f->type); 498 if (!q_data) 499 return -EINVAL; 500 501 f->fmt.pix.field = V4L2_FIELD_NONE; 502 f->fmt.pix.pixelformat = q_data->fourcc; 503 f->fmt.pix.width = q_data->width; 504 f->fmt.pix.height = q_data->height; 505 f->fmt.pix.bytesperline = q_data->bytesperline; 506 507 f->fmt.pix.sizeimage = q_data->sizeimage; 508 f->fmt.pix.colorspace = ctx->colorspace; 509 f->fmt.pix.xfer_func = ctx->xfer_func; 510 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc; 511 f->fmt.pix.quantization = ctx->quantization; 512 513 return 0; 514 } 515 516 static int coda_try_pixelformat(struct coda_ctx *ctx, struct v4l2_format *f) 517 { 518 struct coda_q_data *q_data; 519 const u32 *formats; 520 int i; 521 522 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 523 formats = ctx->cvd->src_formats; 524 else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 525 formats = ctx->cvd->dst_formats; 526 else 527 return -EINVAL; 528 529 for (i = 0; i < CODA_MAX_FORMATS; i++) { 530 /* Skip YUYV if the vdoa is not available */ 531 if (!ctx->vdoa && f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 532 formats[i] == V4L2_PIX_FMT_YUYV) 533 continue; 534 535 if (formats[i] == f->fmt.pix.pixelformat) { 536 f->fmt.pix.pixelformat = formats[i]; 537 return 0; 538 } 539 } 540 541 /* Fall back to currently set pixelformat */ 542 q_data = get_q_data(ctx, f->type); 543 f->fmt.pix.pixelformat = q_data->fourcc; 544 545 return 0; 546 } 547 548 static int coda_try_fmt_vdoa(struct coda_ctx *ctx, struct v4l2_format *f, 549 bool *use_vdoa) 550 { 551 int err; 552 553 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 554 return -EINVAL; 555 556 if (!use_vdoa) 557 return -EINVAL; 558 559 if (!ctx->vdoa) { 560 *use_vdoa = false; 561 return 0; 562 } 563 564 err = vdoa_context_configure(NULL, round_up(f->fmt.pix.width, 16), 565 f->fmt.pix.height, f->fmt.pix.pixelformat); 566 if (err) { 567 *use_vdoa = false; 568 return 0; 569 } 570 571 *use_vdoa = true; 572 return 0; 573 } 574 575 static unsigned int coda_estimate_sizeimage(struct coda_ctx *ctx, u32 sizeimage, 576 u32 width, u32 height) 577 { 578 /* 579 * This is a rough estimate for sensible compressed buffer 580 * sizes (between 1 and 16 bits per pixel). This could be 581 * improved by better format specific worst case estimates. 582 */ 583 return round_up(clamp(sizeimage, width * height / 8, 584 width * height * 2), PAGE_SIZE); 585 } 586 587 static int coda_try_fmt(struct coda_ctx *ctx, const struct coda_codec *codec, 588 struct v4l2_format *f) 589 { 590 struct coda_dev *dev = ctx->dev; 591 unsigned int max_w, max_h; 592 enum v4l2_field field; 593 594 field = f->fmt.pix.field; 595 if (field == V4L2_FIELD_ANY) 596 field = V4L2_FIELD_NONE; 597 else if (V4L2_FIELD_NONE != field) 598 return -EINVAL; 599 600 /* V4L2 specification suggests the driver corrects the format struct 601 * if any of the dimensions is unsupported */ 602 f->fmt.pix.field = field; 603 604 coda_get_max_dimensions(dev, codec, &max_w, &max_h); 605 v4l_bound_align_image(&f->fmt.pix.width, MIN_W, max_w, W_ALIGN, 606 &f->fmt.pix.height, MIN_H, max_h, H_ALIGN, 607 S_ALIGN); 608 609 switch (f->fmt.pix.pixelformat) { 610 case V4L2_PIX_FMT_NV12: 611 case V4L2_PIX_FMT_YUV420: 612 case V4L2_PIX_FMT_YVU420: 613 /* 614 * Frame stride must be at least multiple of 8, 615 * but multiple of 16 for h.264 or JPEG 4:2:x 616 */ 617 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 618 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 619 f->fmt.pix.height * 3 / 2; 620 break; 621 case V4L2_PIX_FMT_YUYV: 622 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16) * 2; 623 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 624 f->fmt.pix.height; 625 break; 626 case V4L2_PIX_FMT_YUV422P: 627 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 628 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 629 f->fmt.pix.height * 2; 630 break; 631 case V4L2_PIX_FMT_GREY: 632 /* keep 16 pixel alignment of 8-bit pixel data */ 633 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16); 634 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height; 635 break; 636 case V4L2_PIX_FMT_JPEG: 637 case V4L2_PIX_FMT_H264: 638 case V4L2_PIX_FMT_MPEG4: 639 case V4L2_PIX_FMT_MPEG2: 640 f->fmt.pix.bytesperline = 0; 641 f->fmt.pix.sizeimage = coda_estimate_sizeimage(ctx, 642 f->fmt.pix.sizeimage, 643 f->fmt.pix.width, 644 f->fmt.pix.height); 645 break; 646 default: 647 BUG(); 648 } 649 650 return 0; 651 } 652 653 static int coda_try_fmt_vid_cap(struct file *file, void *priv, 654 struct v4l2_format *f) 655 { 656 struct coda_ctx *ctx = fh_to_ctx(priv); 657 const struct coda_q_data *q_data_src; 658 const struct coda_codec *codec; 659 struct vb2_queue *src_vq; 660 int hscale = 0; 661 int vscale = 0; 662 int ret; 663 bool use_vdoa; 664 665 ret = coda_try_pixelformat(ctx, f); 666 if (ret < 0) 667 return ret; 668 669 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 670 671 /* 672 * If the source format is already fixed, only allow the same output 673 * resolution. When decoding JPEG images, we also have to make sure to 674 * use the same chroma subsampling. 675 */ 676 src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 677 if (vb2_is_streaming(src_vq)) { 678 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 679 ctx->dev->devtype->product == CODA_960) { 680 hscale = coda_jpeg_scale(q_data_src->width, f->fmt.pix.width); 681 vscale = coda_jpeg_scale(q_data_src->height, f->fmt.pix.height); 682 } 683 f->fmt.pix.width = q_data_src->width >> hscale; 684 f->fmt.pix.height = q_data_src->height >> vscale; 685 686 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG) { 687 if (ctx->params.jpeg_chroma_subsampling == 688 V4L2_JPEG_CHROMA_SUBSAMPLING_420 && 689 f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) 690 f->fmt.pix.pixelformat = V4L2_PIX_FMT_NV12; 691 else if (ctx->params.jpeg_chroma_subsampling == 692 V4L2_JPEG_CHROMA_SUBSAMPLING_422) 693 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; 694 } 695 } 696 697 f->fmt.pix.colorspace = ctx->colorspace; 698 f->fmt.pix.xfer_func = ctx->xfer_func; 699 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc; 700 f->fmt.pix.quantization = ctx->quantization; 701 702 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 703 codec = coda_find_codec(ctx->dev, q_data_src->fourcc, 704 f->fmt.pix.pixelformat); 705 if (!codec) 706 return -EINVAL; 707 708 ret = coda_try_fmt(ctx, codec, f); 709 if (ret < 0) 710 return ret; 711 712 /* The decoders always write complete macroblocks or MCUs */ 713 if (ctx->inst_type == CODA_INST_DECODER) { 714 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16 >> hscale); 715 f->fmt.pix.height = round_up(f->fmt.pix.height, 16 >> vscale); 716 if (codec->src_fourcc == V4L2_PIX_FMT_JPEG && 717 f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { 718 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 719 f->fmt.pix.height * 2; 720 } else { 721 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 722 f->fmt.pix.height * 3 / 2; 723 } 724 725 ret = coda_try_fmt_vdoa(ctx, f, &use_vdoa); 726 if (ret < 0) 727 return ret; 728 729 if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) { 730 if (!use_vdoa) 731 return -EINVAL; 732 733 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16) * 2; 734 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * 735 f->fmt.pix.height; 736 } 737 } 738 739 return 0; 740 } 741 742 static void coda_set_default_colorspace(struct v4l2_pix_format *fmt) 743 { 744 enum v4l2_colorspace colorspace; 745 746 if (fmt->pixelformat == V4L2_PIX_FMT_JPEG) 747 colorspace = V4L2_COLORSPACE_JPEG; 748 else if (fmt->width <= 720 && fmt->height <= 576) 749 colorspace = V4L2_COLORSPACE_SMPTE170M; 750 else 751 colorspace = V4L2_COLORSPACE_REC709; 752 753 fmt->colorspace = colorspace; 754 fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT; 755 fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 756 fmt->quantization = V4L2_QUANTIZATION_DEFAULT; 757 } 758 759 static int coda_try_fmt_vid_out(struct file *file, void *priv, 760 struct v4l2_format *f) 761 { 762 struct coda_ctx *ctx = fh_to_ctx(priv); 763 struct coda_dev *dev = ctx->dev; 764 const struct coda_q_data *q_data_dst; 765 const struct coda_codec *codec; 766 int ret; 767 768 ret = coda_try_pixelformat(ctx, f); 769 if (ret < 0) 770 return ret; 771 772 if (f->fmt.pix.colorspace == V4L2_COLORSPACE_DEFAULT) 773 coda_set_default_colorspace(&f->fmt.pix); 774 775 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 776 codec = coda_find_codec(dev, f->fmt.pix.pixelformat, q_data_dst->fourcc); 777 778 return coda_try_fmt(ctx, codec, f); 779 } 780 781 static int coda_s_fmt(struct coda_ctx *ctx, struct v4l2_format *f, 782 struct v4l2_rect *r) 783 { 784 struct coda_q_data *q_data; 785 struct vb2_queue *vq; 786 787 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); 788 if (!vq) 789 return -EINVAL; 790 791 q_data = get_q_data(ctx, f->type); 792 if (!q_data) 793 return -EINVAL; 794 795 if (vb2_is_busy(vq)) { 796 v4l2_err(&ctx->dev->v4l2_dev, "%s: %s queue busy: %d\n", 797 __func__, v4l2_type_names[f->type], vb2_get_num_buffers(vq)); 798 return -EBUSY; 799 } 800 801 q_data->fourcc = f->fmt.pix.pixelformat; 802 q_data->width = f->fmt.pix.width; 803 q_data->height = f->fmt.pix.height; 804 q_data->bytesperline = f->fmt.pix.bytesperline; 805 q_data->sizeimage = f->fmt.pix.sizeimage; 806 if (r) { 807 q_data->rect = *r; 808 } else { 809 q_data->rect.left = 0; 810 q_data->rect.top = 0; 811 q_data->rect.width = f->fmt.pix.width; 812 q_data->rect.height = f->fmt.pix.height; 813 } 814 815 switch (f->fmt.pix.pixelformat) { 816 case V4L2_PIX_FMT_YUYV: 817 ctx->tiled_map_type = GDI_TILED_FRAME_MB_RASTER_MAP; 818 break; 819 case V4L2_PIX_FMT_NV12: 820 if (!disable_tiling && ctx->use_bit && 821 ctx->dev->devtype->product == CODA_960) { 822 ctx->tiled_map_type = GDI_TILED_FRAME_MB_RASTER_MAP; 823 break; 824 } 825 fallthrough; 826 case V4L2_PIX_FMT_YUV420: 827 case V4L2_PIX_FMT_YVU420: 828 case V4L2_PIX_FMT_YUV422P: 829 ctx->tiled_map_type = GDI_LINEAR_FRAME_MAP; 830 break; 831 default: 832 break; 833 } 834 835 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP && 836 !coda_try_fmt_vdoa(ctx, f, &ctx->use_vdoa) && 837 ctx->use_vdoa) 838 vdoa_context_configure(ctx->vdoa, 839 round_up(f->fmt.pix.width, 16), 840 f->fmt.pix.height, 841 f->fmt.pix.pixelformat); 842 else 843 ctx->use_vdoa = false; 844 845 coda_dbg(1, ctx, "Setting %s format, wxh: %dx%d, fmt: %4.4s %c\n", 846 v4l2_type_names[f->type], q_data->width, q_data->height, 847 (char *)&q_data->fourcc, 848 (ctx->tiled_map_type == GDI_LINEAR_FRAME_MAP) ? 'L' : 'T'); 849 850 return 0; 851 } 852 853 static int coda_s_fmt_vid_cap(struct file *file, void *priv, 854 struct v4l2_format *f) 855 { 856 struct coda_ctx *ctx = fh_to_ctx(priv); 857 struct coda_q_data *q_data_src; 858 const struct coda_codec *codec; 859 struct v4l2_rect r; 860 int hscale = 0; 861 int vscale = 0; 862 int ret; 863 864 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 865 866 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG && 867 ctx->dev->devtype->product == CODA_960) { 868 hscale = coda_jpeg_scale(q_data_src->width, f->fmt.pix.width); 869 vscale = coda_jpeg_scale(q_data_src->height, f->fmt.pix.height); 870 } 871 872 ret = coda_try_fmt_vid_cap(file, priv, f); 873 if (ret) 874 return ret; 875 876 r.left = 0; 877 r.top = 0; 878 r.width = q_data_src->width >> hscale; 879 r.height = q_data_src->height >> vscale; 880 881 ret = coda_s_fmt(ctx, f, &r); 882 if (ret) 883 return ret; 884 885 if (ctx->inst_type != CODA_INST_ENCODER) 886 return 0; 887 888 /* Setting the coded format determines the selected codec */ 889 codec = coda_find_codec(ctx->dev, q_data_src->fourcc, 890 f->fmt.pix.pixelformat); 891 if (!codec) { 892 v4l2_err(&ctx->dev->v4l2_dev, "failed to determine codec\n"); 893 return -EINVAL; 894 } 895 ctx->codec = codec; 896 897 ctx->colorspace = f->fmt.pix.colorspace; 898 ctx->xfer_func = f->fmt.pix.xfer_func; 899 ctx->ycbcr_enc = f->fmt.pix.ycbcr_enc; 900 ctx->quantization = f->fmt.pix.quantization; 901 902 return 0; 903 } 904 905 static int coda_s_fmt_vid_out(struct file *file, void *priv, 906 struct v4l2_format *f) 907 { 908 struct coda_ctx *ctx = fh_to_ctx(priv); 909 const struct coda_codec *codec; 910 struct v4l2_format f_cap; 911 struct vb2_queue *dst_vq; 912 int ret; 913 914 ret = coda_try_fmt_vid_out(file, priv, f); 915 if (ret) 916 return ret; 917 918 ret = coda_s_fmt(ctx, f, NULL); 919 if (ret) 920 return ret; 921 922 ctx->colorspace = f->fmt.pix.colorspace; 923 ctx->xfer_func = f->fmt.pix.xfer_func; 924 ctx->ycbcr_enc = f->fmt.pix.ycbcr_enc; 925 ctx->quantization = f->fmt.pix.quantization; 926 927 if (ctx->inst_type != CODA_INST_DECODER) 928 return 0; 929 930 /* Setting the coded format determines the selected codec */ 931 codec = coda_find_codec(ctx->dev, f->fmt.pix.pixelformat, 932 V4L2_PIX_FMT_YUV420); 933 if (!codec) { 934 v4l2_err(&ctx->dev->v4l2_dev, "failed to determine codec\n"); 935 return -EINVAL; 936 } 937 ctx->codec = codec; 938 939 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 940 if (!dst_vq) 941 return -EINVAL; 942 943 /* 944 * Setting the capture queue format is not possible while the capture 945 * queue is still busy. This is not an error, but the user will have to 946 * make sure themselves that the capture format is set correctly before 947 * starting the output queue again. 948 */ 949 if (vb2_is_busy(dst_vq)) 950 return 0; 951 952 memset(&f_cap, 0, sizeof(f_cap)); 953 f_cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 954 coda_g_fmt(file, priv, &f_cap); 955 f_cap.fmt.pix.width = f->fmt.pix.width; 956 f_cap.fmt.pix.height = f->fmt.pix.height; 957 958 return coda_s_fmt_vid_cap(file, priv, &f_cap); 959 } 960 961 static int coda_reqbufs(struct file *file, void *priv, 962 struct v4l2_requestbuffers *rb) 963 { 964 struct coda_ctx *ctx = fh_to_ctx(priv); 965 int ret; 966 967 ret = v4l2_m2m_reqbufs(file, ctx->fh.m2m_ctx, rb); 968 if (ret) 969 return ret; 970 971 /* 972 * Allow to allocate instance specific per-context buffers, such as 973 * bitstream ringbuffer, slice buffer, work buffer, etc. if needed. 974 */ 975 if (rb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT && ctx->ops->reqbufs) 976 return ctx->ops->reqbufs(ctx, rb); 977 978 return 0; 979 } 980 981 static int coda_qbuf(struct file *file, void *priv, 982 struct v4l2_buffer *buf) 983 { 984 struct coda_ctx *ctx = fh_to_ctx(priv); 985 986 if (ctx->inst_type == CODA_INST_DECODER && 987 buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 988 buf->flags &= ~V4L2_BUF_FLAG_LAST; 989 990 return v4l2_m2m_qbuf(file, ctx->fh.m2m_ctx, buf); 991 } 992 993 static int coda_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf) 994 { 995 struct coda_ctx *ctx = fh_to_ctx(priv); 996 int ret; 997 998 ret = v4l2_m2m_dqbuf(file, ctx->fh.m2m_ctx, buf); 999 1000 if (ctx->inst_type == CODA_INST_DECODER && 1001 buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1002 buf->flags &= ~V4L2_BUF_FLAG_LAST; 1003 1004 return ret; 1005 } 1006 1007 void coda_m2m_buf_done(struct coda_ctx *ctx, struct vb2_v4l2_buffer *buf, 1008 enum vb2_buffer_state state) 1009 { 1010 const struct v4l2_event eos_event = { 1011 .type = V4L2_EVENT_EOS 1012 }; 1013 1014 if (buf->flags & V4L2_BUF_FLAG_LAST) 1015 v4l2_event_queue_fh(&ctx->fh, &eos_event); 1016 1017 v4l2_m2m_buf_done(buf, state); 1018 } 1019 1020 static int coda_g_selection(struct file *file, void *fh, 1021 struct v4l2_selection *s) 1022 { 1023 struct coda_ctx *ctx = fh_to_ctx(fh); 1024 struct coda_q_data *q_data; 1025 struct v4l2_rect r, *rsel; 1026 1027 q_data = get_q_data(ctx, s->type); 1028 if (!q_data) 1029 return -EINVAL; 1030 1031 r.left = 0; 1032 r.top = 0; 1033 r.width = q_data->width; 1034 r.height = q_data->height; 1035 rsel = &q_data->rect; 1036 1037 switch (s->target) { 1038 case V4L2_SEL_TGT_CROP_DEFAULT: 1039 case V4L2_SEL_TGT_CROP_BOUNDS: 1040 rsel = &r; 1041 fallthrough; 1042 case V4L2_SEL_TGT_CROP: 1043 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT || 1044 ctx->inst_type == CODA_INST_DECODER) 1045 return -EINVAL; 1046 break; 1047 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 1048 case V4L2_SEL_TGT_COMPOSE_PADDED: 1049 rsel = &r; 1050 fallthrough; 1051 case V4L2_SEL_TGT_COMPOSE: 1052 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 1053 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1054 ctx->inst_type == CODA_INST_ENCODER) 1055 return -EINVAL; 1056 break; 1057 default: 1058 return -EINVAL; 1059 } 1060 1061 s->r = *rsel; 1062 1063 return 0; 1064 } 1065 1066 static int coda_s_selection(struct file *file, void *fh, 1067 struct v4l2_selection *s) 1068 { 1069 struct coda_ctx *ctx = fh_to_ctx(fh); 1070 struct coda_q_data *q_data; 1071 1072 switch (s->target) { 1073 case V4L2_SEL_TGT_CROP: 1074 if (ctx->inst_type == CODA_INST_ENCODER && 1075 s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1076 q_data = get_q_data(ctx, s->type); 1077 if (!q_data) 1078 return -EINVAL; 1079 1080 s->r.left = 0; 1081 s->r.top = 0; 1082 s->r.width = clamp(s->r.width, 2U, q_data->width); 1083 s->r.height = clamp(s->r.height, 2U, q_data->height); 1084 1085 if (s->flags & V4L2_SEL_FLAG_LE) { 1086 s->r.width = round_up(s->r.width, 2); 1087 s->r.height = round_up(s->r.height, 2); 1088 } else { 1089 s->r.width = round_down(s->r.width, 2); 1090 s->r.height = round_down(s->r.height, 2); 1091 } 1092 1093 q_data->rect = s->r; 1094 1095 coda_dbg(1, ctx, "Setting crop rectangle: %dx%d\n", 1096 s->r.width, s->r.height); 1097 1098 return 0; 1099 } 1100 fallthrough; 1101 case V4L2_SEL_TGT_NATIVE_SIZE: 1102 case V4L2_SEL_TGT_COMPOSE: 1103 return coda_g_selection(file, fh, s); 1104 default: 1105 /* v4l2-compliance expects this to fail for read-only targets */ 1106 return -EINVAL; 1107 } 1108 } 1109 1110 static void coda_wake_up_capture_queue(struct coda_ctx *ctx) 1111 { 1112 struct vb2_queue *dst_vq; 1113 1114 coda_dbg(1, ctx, "waking up capture queue\n"); 1115 1116 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1117 dst_vq->last_buffer_dequeued = true; 1118 wake_up(&dst_vq->done_wq); 1119 } 1120 1121 static int coda_encoder_cmd(struct file *file, void *fh, 1122 struct v4l2_encoder_cmd *ec) 1123 { 1124 struct coda_ctx *ctx = fh_to_ctx(fh); 1125 struct vb2_v4l2_buffer *buf; 1126 int ret; 1127 1128 ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, ec); 1129 if (ret < 0) 1130 return ret; 1131 1132 mutex_lock(&ctx->wakeup_mutex); 1133 buf = v4l2_m2m_last_src_buf(ctx->fh.m2m_ctx); 1134 if (buf) { 1135 /* 1136 * If the last output buffer is still on the queue, make sure 1137 * that decoder finish_run will see the last flag and report it 1138 * to userspace. 1139 */ 1140 buf->flags |= V4L2_BUF_FLAG_LAST; 1141 } else { 1142 /* Set the stream-end flag on this context */ 1143 ctx->bit_stream_param |= CODA_BIT_STREAM_END_FLAG; 1144 1145 /* 1146 * If the last output buffer has already been taken from the 1147 * queue, wake up the capture queue and signal end of stream 1148 * via the -EPIPE mechanism. 1149 */ 1150 coda_wake_up_capture_queue(ctx); 1151 } 1152 mutex_unlock(&ctx->wakeup_mutex); 1153 1154 return 0; 1155 } 1156 1157 static bool coda_mark_last_meta(struct coda_ctx *ctx) 1158 { 1159 struct coda_buffer_meta *meta; 1160 1161 coda_dbg(1, ctx, "marking last meta\n"); 1162 1163 spin_lock(&ctx->buffer_meta_lock); 1164 if (list_empty(&ctx->buffer_meta_list)) { 1165 spin_unlock(&ctx->buffer_meta_lock); 1166 return false; 1167 } 1168 1169 meta = list_last_entry(&ctx->buffer_meta_list, struct coda_buffer_meta, 1170 list); 1171 meta->last = true; 1172 1173 spin_unlock(&ctx->buffer_meta_lock); 1174 return true; 1175 } 1176 1177 static bool coda_mark_last_dst_buf(struct coda_ctx *ctx) 1178 { 1179 struct vb2_v4l2_buffer *buf; 1180 struct vb2_buffer *dst_vb; 1181 struct vb2_queue *dst_vq; 1182 unsigned long flags; 1183 1184 coda_dbg(1, ctx, "marking last capture buffer\n"); 1185 1186 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1187 spin_lock_irqsave(&dst_vq->done_lock, flags); 1188 if (list_empty(&dst_vq->done_list)) { 1189 spin_unlock_irqrestore(&dst_vq->done_lock, flags); 1190 return false; 1191 } 1192 1193 dst_vb = list_last_entry(&dst_vq->done_list, struct vb2_buffer, 1194 done_entry); 1195 buf = to_vb2_v4l2_buffer(dst_vb); 1196 buf->flags |= V4L2_BUF_FLAG_LAST; 1197 1198 spin_unlock_irqrestore(&dst_vq->done_lock, flags); 1199 return true; 1200 } 1201 1202 static int coda_decoder_cmd(struct file *file, void *fh, 1203 struct v4l2_decoder_cmd *dc) 1204 { 1205 struct coda_ctx *ctx = fh_to_ctx(fh); 1206 struct coda_dev *dev = ctx->dev; 1207 struct vb2_v4l2_buffer *buf; 1208 struct vb2_queue *dst_vq; 1209 bool stream_end; 1210 bool wakeup; 1211 int ret; 1212 1213 ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, dc); 1214 if (ret < 0) 1215 return ret; 1216 1217 switch (dc->cmd) { 1218 case V4L2_DEC_CMD_START: 1219 mutex_lock(&dev->coda_mutex); 1220 mutex_lock(&ctx->bitstream_mutex); 1221 coda_bitstream_flush(ctx); 1222 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, 1223 V4L2_BUF_TYPE_VIDEO_CAPTURE); 1224 vb2_clear_last_buffer_dequeued(dst_vq); 1225 ctx->bit_stream_param &= ~CODA_BIT_STREAM_END_FLAG; 1226 coda_fill_bitstream(ctx, NULL); 1227 mutex_unlock(&ctx->bitstream_mutex); 1228 mutex_unlock(&dev->coda_mutex); 1229 break; 1230 case V4L2_DEC_CMD_STOP: 1231 stream_end = false; 1232 wakeup = false; 1233 1234 mutex_lock(&ctx->wakeup_mutex); 1235 1236 buf = v4l2_m2m_last_src_buf(ctx->fh.m2m_ctx); 1237 if (buf) { 1238 coda_dbg(1, ctx, "marking last pending buffer\n"); 1239 1240 /* Mark last buffer */ 1241 buf->flags |= V4L2_BUF_FLAG_LAST; 1242 1243 if (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) == 0) { 1244 coda_dbg(1, ctx, "all remaining buffers queued\n"); 1245 stream_end = true; 1246 } 1247 } else { 1248 if (ctx->use_bit) 1249 if (coda_mark_last_meta(ctx)) 1250 stream_end = true; 1251 else 1252 wakeup = true; 1253 else 1254 if (!coda_mark_last_dst_buf(ctx)) 1255 wakeup = true; 1256 } 1257 1258 if (stream_end) { 1259 coda_dbg(1, ctx, "all remaining buffers queued\n"); 1260 1261 /* Set the stream-end flag on this context */ 1262 coda_bit_stream_end_flag(ctx); 1263 ctx->hold = false; 1264 v4l2_m2m_try_schedule(ctx->fh.m2m_ctx); 1265 } 1266 1267 if (wakeup) { 1268 /* If there is no buffer in flight, wake up */ 1269 coda_wake_up_capture_queue(ctx); 1270 } 1271 1272 mutex_unlock(&ctx->wakeup_mutex); 1273 break; 1274 default: 1275 return -EINVAL; 1276 } 1277 1278 return 0; 1279 } 1280 1281 static int coda_enum_framesizes(struct file *file, void *fh, 1282 struct v4l2_frmsizeenum *fsize) 1283 { 1284 struct coda_ctx *ctx = fh_to_ctx(fh); 1285 struct coda_q_data *q_data_dst; 1286 const struct coda_codec *codec; 1287 1288 if (fsize->index) 1289 return -EINVAL; 1290 1291 if (coda_format_normalize_yuv(fsize->pixel_format) == 1292 V4L2_PIX_FMT_YUV420) { 1293 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1294 codec = coda_find_codec(ctx->dev, fsize->pixel_format, 1295 q_data_dst->fourcc); 1296 } else { 1297 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420, 1298 fsize->pixel_format); 1299 } 1300 if (!codec) 1301 return -EINVAL; 1302 1303 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS; 1304 fsize->stepwise.min_width = MIN_W; 1305 fsize->stepwise.max_width = codec->max_w; 1306 fsize->stepwise.step_width = 1; 1307 fsize->stepwise.min_height = MIN_H; 1308 fsize->stepwise.max_height = codec->max_h; 1309 fsize->stepwise.step_height = 1; 1310 1311 return 0; 1312 } 1313 1314 static int coda_enum_frameintervals(struct file *file, void *fh, 1315 struct v4l2_frmivalenum *f) 1316 { 1317 struct coda_ctx *ctx = fh_to_ctx(fh); 1318 struct coda_q_data *q_data; 1319 const struct coda_codec *codec; 1320 1321 if (f->index) 1322 return -EINVAL; 1323 1324 /* Disallow YUYV if the vdoa is not available */ 1325 if (!ctx->vdoa && f->pixel_format == V4L2_PIX_FMT_YUYV) 1326 return -EINVAL; 1327 1328 if (coda_format_normalize_yuv(f->pixel_format) == V4L2_PIX_FMT_YUV420) { 1329 q_data = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1330 codec = coda_find_codec(ctx->dev, f->pixel_format, 1331 q_data->fourcc); 1332 } else { 1333 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420, 1334 f->pixel_format); 1335 } 1336 if (!codec) 1337 return -EINVAL; 1338 1339 if (f->width < MIN_W || f->width > codec->max_w || 1340 f->height < MIN_H || f->height > codec->max_h) 1341 return -EINVAL; 1342 1343 f->type = V4L2_FRMIVAL_TYPE_CONTINUOUS; 1344 f->stepwise.min.numerator = 1; 1345 f->stepwise.min.denominator = 65535; 1346 f->stepwise.max.numerator = 65536; 1347 f->stepwise.max.denominator = 1; 1348 f->stepwise.step.numerator = 1; 1349 f->stepwise.step.denominator = 1; 1350 1351 return 0; 1352 } 1353 1354 static int coda_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a) 1355 { 1356 struct coda_ctx *ctx = fh_to_ctx(fh); 1357 struct v4l2_fract *tpf; 1358 1359 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1360 return -EINVAL; 1361 1362 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 1363 tpf = &a->parm.output.timeperframe; 1364 tpf->denominator = ctx->params.framerate & CODA_FRATE_RES_MASK; 1365 tpf->numerator = 1 + (ctx->params.framerate >> 1366 CODA_FRATE_DIV_OFFSET); 1367 1368 return 0; 1369 } 1370 1371 /* 1372 * Approximate timeperframe v4l2_fract with values that can be written 1373 * into the 16-bit CODA_FRATE_DIV and CODA_FRATE_RES fields. 1374 */ 1375 static void coda_approximate_timeperframe(struct v4l2_fract *timeperframe) 1376 { 1377 struct v4l2_fract s = *timeperframe; 1378 struct v4l2_fract f0; 1379 struct v4l2_fract f1 = { 1, 0 }; 1380 struct v4l2_fract f2 = { 0, 1 }; 1381 unsigned int i, div, s_denominator; 1382 1383 /* Lower bound is 1/65535 */ 1384 if (s.numerator == 0 || s.denominator / s.numerator > 65535) { 1385 timeperframe->numerator = 1; 1386 timeperframe->denominator = 65535; 1387 return; 1388 } 1389 1390 /* Upper bound is 65536/1 */ 1391 if (s.denominator == 0 || s.numerator / s.denominator > 65536) { 1392 timeperframe->numerator = 65536; 1393 timeperframe->denominator = 1; 1394 return; 1395 } 1396 1397 /* Reduce fraction to lowest terms */ 1398 div = gcd(s.numerator, s.denominator); 1399 if (div > 1) { 1400 s.numerator /= div; 1401 s.denominator /= div; 1402 } 1403 1404 if (s.numerator <= 65536 && s.denominator < 65536) { 1405 *timeperframe = s; 1406 return; 1407 } 1408 1409 /* Find successive convergents from continued fraction expansion */ 1410 while (f2.numerator <= 65536 && f2.denominator < 65536) { 1411 f0 = f1; 1412 f1 = f2; 1413 1414 /* Stop when f2 exactly equals timeperframe */ 1415 if (s.numerator == 0) 1416 break; 1417 1418 i = s.denominator / s.numerator; 1419 1420 f2.numerator = f0.numerator + i * f1.numerator; 1421 f2.denominator = f0.denominator + i * f2.denominator; 1422 1423 s_denominator = s.numerator; 1424 s.numerator = s.denominator % s.numerator; 1425 s.denominator = s_denominator; 1426 } 1427 1428 *timeperframe = f1; 1429 } 1430 1431 static uint32_t coda_timeperframe_to_frate(struct v4l2_fract *timeperframe) 1432 { 1433 return ((timeperframe->numerator - 1) << CODA_FRATE_DIV_OFFSET) | 1434 timeperframe->denominator; 1435 } 1436 1437 static int coda_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a) 1438 { 1439 struct coda_ctx *ctx = fh_to_ctx(fh); 1440 struct v4l2_fract *tpf; 1441 1442 if (a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 1443 return -EINVAL; 1444 1445 a->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 1446 tpf = &a->parm.output.timeperframe; 1447 coda_approximate_timeperframe(tpf); 1448 ctx->params.framerate = coda_timeperframe_to_frate(tpf); 1449 ctx->params.framerate_changed = true; 1450 1451 return 0; 1452 } 1453 1454 static int coda_subscribe_event(struct v4l2_fh *fh, 1455 const struct v4l2_event_subscription *sub) 1456 { 1457 struct coda_ctx *ctx = fh_to_ctx(fh); 1458 1459 switch (sub->type) { 1460 case V4L2_EVENT_EOS: 1461 return v4l2_event_subscribe(fh, sub, 0, NULL); 1462 case V4L2_EVENT_SOURCE_CHANGE: 1463 if (ctx->inst_type == CODA_INST_DECODER) 1464 return v4l2_event_subscribe(fh, sub, 0, NULL); 1465 else 1466 return -EINVAL; 1467 default: 1468 return v4l2_ctrl_subscribe_event(fh, sub); 1469 } 1470 } 1471 1472 static const struct v4l2_ioctl_ops coda_ioctl_ops = { 1473 .vidioc_querycap = coda_querycap, 1474 1475 .vidioc_enum_fmt_vid_cap = coda_enum_fmt, 1476 .vidioc_g_fmt_vid_cap = coda_g_fmt, 1477 .vidioc_try_fmt_vid_cap = coda_try_fmt_vid_cap, 1478 .vidioc_s_fmt_vid_cap = coda_s_fmt_vid_cap, 1479 1480 .vidioc_enum_fmt_vid_out = coda_enum_fmt, 1481 .vidioc_g_fmt_vid_out = coda_g_fmt, 1482 .vidioc_try_fmt_vid_out = coda_try_fmt_vid_out, 1483 .vidioc_s_fmt_vid_out = coda_s_fmt_vid_out, 1484 1485 .vidioc_reqbufs = coda_reqbufs, 1486 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 1487 1488 .vidioc_qbuf = coda_qbuf, 1489 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 1490 .vidioc_dqbuf = coda_dqbuf, 1491 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 1492 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 1493 1494 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 1495 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 1496 1497 .vidioc_g_selection = coda_g_selection, 1498 .vidioc_s_selection = coda_s_selection, 1499 1500 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 1501 .vidioc_encoder_cmd = coda_encoder_cmd, 1502 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 1503 .vidioc_decoder_cmd = coda_decoder_cmd, 1504 1505 .vidioc_g_parm = coda_g_parm, 1506 .vidioc_s_parm = coda_s_parm, 1507 1508 .vidioc_enum_framesizes = coda_enum_framesizes, 1509 .vidioc_enum_frameintervals = coda_enum_frameintervals, 1510 1511 .vidioc_subscribe_event = coda_subscribe_event, 1512 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1513 }; 1514 1515 /* 1516 * Mem-to-mem operations. 1517 */ 1518 1519 static void coda_device_run(void *m2m_priv) 1520 { 1521 struct coda_ctx *ctx = m2m_priv; 1522 struct coda_dev *dev = ctx->dev; 1523 1524 queue_work(dev->workqueue, &ctx->pic_run_work); 1525 } 1526 1527 static void coda_pic_run_work(struct work_struct *work) 1528 { 1529 struct coda_ctx *ctx = container_of(work, struct coda_ctx, pic_run_work); 1530 struct coda_dev *dev = ctx->dev; 1531 int ret; 1532 1533 mutex_lock(&ctx->buffer_mutex); 1534 mutex_lock(&dev->coda_mutex); 1535 1536 ret = ctx->ops->prepare_run(ctx); 1537 if (ret < 0 && ctx->inst_type == CODA_INST_DECODER) 1538 goto out; 1539 1540 if (!wait_for_completion_timeout(&ctx->completion, 1541 msecs_to_jiffies(1000))) { 1542 if (ctx->use_bit) { 1543 dev_err(dev->dev, "CODA PIC_RUN timeout\n"); 1544 1545 ctx->hold = true; 1546 1547 coda_hw_reset(ctx); 1548 } 1549 1550 if (ctx->ops->run_timeout) 1551 ctx->ops->run_timeout(ctx); 1552 } else { 1553 ctx->ops->finish_run(ctx); 1554 } 1555 1556 if ((ctx->aborting || (!ctx->streamon_cap && !ctx->streamon_out)) && 1557 ctx->ops->seq_end_work) 1558 queue_work(dev->workqueue, &ctx->seq_end_work); 1559 1560 out: 1561 mutex_unlock(&dev->coda_mutex); 1562 mutex_unlock(&ctx->buffer_mutex); 1563 1564 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx); 1565 } 1566 1567 static int coda_job_ready(void *m2m_priv) 1568 { 1569 struct coda_ctx *ctx = m2m_priv; 1570 int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx); 1571 1572 /* 1573 * For both 'P' and 'key' frame cases 1 picture 1574 * and 1 frame are needed. In the decoder case, 1575 * the compressed frame can be in the bitstream. 1576 */ 1577 if (!src_bufs && ctx->inst_type != CODA_INST_DECODER) { 1578 coda_dbg(1, ctx, "not ready: not enough vid-out buffers.\n"); 1579 return 0; 1580 } 1581 1582 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) { 1583 coda_dbg(1, ctx, "not ready: not enough vid-cap buffers.\n"); 1584 return 0; 1585 } 1586 1587 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) { 1588 bool stream_end = ctx->bit_stream_param & 1589 CODA_BIT_STREAM_END_FLAG; 1590 int num_metas = ctx->num_metas; 1591 struct coda_buffer_meta *meta; 1592 unsigned int count; 1593 1594 count = hweight32(ctx->frm_dis_flg); 1595 if (ctx->use_vdoa && count >= (ctx->num_internal_frames - 1)) { 1596 coda_dbg(1, ctx, 1597 "not ready: all internal buffers in use: %d/%d (0x%x)", 1598 count, ctx->num_internal_frames, 1599 ctx->frm_dis_flg); 1600 return 0; 1601 } 1602 1603 if (ctx->hold && !src_bufs) { 1604 coda_dbg(1, ctx, 1605 "not ready: on hold for more buffers.\n"); 1606 return 0; 1607 } 1608 1609 if (!stream_end && (num_metas + src_bufs) < 2) { 1610 coda_dbg(1, ctx, 1611 "not ready: need 2 buffers available (queue:%d + bitstream:%d)\n", 1612 num_metas, src_bufs); 1613 return 0; 1614 } 1615 1616 meta = list_first_entry(&ctx->buffer_meta_list, 1617 struct coda_buffer_meta, list); 1618 if (!coda_bitstream_can_fetch_past(ctx, meta->end) && 1619 !stream_end) { 1620 coda_dbg(1, ctx, 1621 "not ready: not enough bitstream data to read past %u (%u)\n", 1622 meta->end, ctx->bitstream_fifo.kfifo.in); 1623 return 0; 1624 } 1625 } 1626 1627 if (ctx->aborting) { 1628 coda_dbg(1, ctx, "not ready: aborting\n"); 1629 return 0; 1630 } 1631 1632 coda_dbg(2, ctx, "job ready\n"); 1633 1634 return 1; 1635 } 1636 1637 static void coda_job_abort(void *priv) 1638 { 1639 struct coda_ctx *ctx = priv; 1640 1641 ctx->aborting = 1; 1642 1643 coda_dbg(1, ctx, "job abort\n"); 1644 } 1645 1646 static const struct v4l2_m2m_ops coda_m2m_ops = { 1647 .device_run = coda_device_run, 1648 .job_ready = coda_job_ready, 1649 .job_abort = coda_job_abort, 1650 }; 1651 1652 static void set_default_params(struct coda_ctx *ctx) 1653 { 1654 unsigned int max_w, max_h, usize, csize; 1655 1656 ctx->codec = coda_find_codec(ctx->dev, ctx->cvd->src_formats[0], 1657 ctx->cvd->dst_formats[0]); 1658 max_w = min(ctx->codec->max_w, 1920U); 1659 max_h = min(ctx->codec->max_h, 1088U); 1660 usize = max_w * max_h * 3 / 2; 1661 csize = coda_estimate_sizeimage(ctx, usize, max_w, max_h); 1662 1663 ctx->params.codec_mode = ctx->codec->mode; 1664 if (ctx->cvd->src_formats[0] == V4L2_PIX_FMT_JPEG || 1665 ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG) { 1666 ctx->colorspace = V4L2_COLORSPACE_SRGB; 1667 ctx->xfer_func = V4L2_XFER_FUNC_SRGB; 1668 ctx->ycbcr_enc = V4L2_YCBCR_ENC_601; 1669 ctx->quantization = V4L2_QUANTIZATION_FULL_RANGE; 1670 } else { 1671 ctx->colorspace = V4L2_COLORSPACE_REC709; 1672 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT; 1673 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 1674 ctx->quantization = V4L2_QUANTIZATION_DEFAULT; 1675 } 1676 ctx->params.framerate = 30; 1677 1678 /* Default formats for output and input queues */ 1679 ctx->q_data[V4L2_M2M_SRC].fourcc = ctx->cvd->src_formats[0]; 1680 ctx->q_data[V4L2_M2M_DST].fourcc = ctx->cvd->dst_formats[0]; 1681 ctx->q_data[V4L2_M2M_SRC].width = max_w; 1682 ctx->q_data[V4L2_M2M_SRC].height = max_h; 1683 ctx->q_data[V4L2_M2M_DST].width = max_w; 1684 ctx->q_data[V4L2_M2M_DST].height = max_h; 1685 if (ctx->codec->src_fourcc == V4L2_PIX_FMT_YUV420) { 1686 ctx->q_data[V4L2_M2M_SRC].bytesperline = max_w; 1687 ctx->q_data[V4L2_M2M_SRC].sizeimage = usize; 1688 ctx->q_data[V4L2_M2M_DST].bytesperline = 0; 1689 ctx->q_data[V4L2_M2M_DST].sizeimage = csize; 1690 } else { 1691 ctx->q_data[V4L2_M2M_SRC].bytesperline = 0; 1692 ctx->q_data[V4L2_M2M_SRC].sizeimage = csize; 1693 ctx->q_data[V4L2_M2M_DST].bytesperline = max_w; 1694 ctx->q_data[V4L2_M2M_DST].sizeimage = usize; 1695 } 1696 ctx->q_data[V4L2_M2M_SRC].rect.width = max_w; 1697 ctx->q_data[V4L2_M2M_SRC].rect.height = max_h; 1698 ctx->q_data[V4L2_M2M_DST].rect.width = max_w; 1699 ctx->q_data[V4L2_M2M_DST].rect.height = max_h; 1700 1701 /* 1702 * Since the RBC2AXI logic only supports a single chroma plane, 1703 * macroblock tiling only works for to NV12 pixel format. 1704 */ 1705 ctx->tiled_map_type = GDI_LINEAR_FRAME_MAP; 1706 } 1707 1708 /* 1709 * Queue operations 1710 */ 1711 static int coda_queue_setup(struct vb2_queue *vq, 1712 unsigned int *nbuffers, unsigned int *nplanes, 1713 unsigned int sizes[], struct device *alloc_devs[]) 1714 { 1715 struct coda_ctx *ctx = vb2_get_drv_priv(vq); 1716 struct coda_q_data *q_data; 1717 unsigned int size; 1718 1719 q_data = get_q_data(ctx, vq->type); 1720 size = q_data->sizeimage; 1721 1722 if (*nplanes) 1723 return sizes[0] < size ? -EINVAL : 0; 1724 1725 *nplanes = 1; 1726 sizes[0] = size; 1727 1728 coda_dbg(1, ctx, "get %d buffer(s) of size %d each.\n", *nbuffers, 1729 size); 1730 1731 return 0; 1732 } 1733 1734 static int coda_buf_prepare(struct vb2_buffer *vb) 1735 { 1736 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1737 struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1738 struct coda_q_data *q_data; 1739 1740 q_data = get_q_data(ctx, vb->vb2_queue->type); 1741 if (V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) { 1742 if (vbuf->field == V4L2_FIELD_ANY) 1743 vbuf->field = V4L2_FIELD_NONE; 1744 if (vbuf->field != V4L2_FIELD_NONE) { 1745 v4l2_warn(&ctx->dev->v4l2_dev, 1746 "%s field isn't supported\n", __func__); 1747 return -EINVAL; 1748 } 1749 } 1750 1751 if (vb2_plane_size(vb, 0) < q_data->sizeimage) { 1752 v4l2_warn(&ctx->dev->v4l2_dev, 1753 "%s data will not fit into plane (%lu < %lu)\n", 1754 __func__, vb2_plane_size(vb, 0), 1755 (long)q_data->sizeimage); 1756 return -EINVAL; 1757 } 1758 1759 return 0; 1760 } 1761 1762 static void coda_update_menu_ctrl(struct v4l2_ctrl *ctrl, int value) 1763 { 1764 if (!ctrl) 1765 return; 1766 1767 v4l2_ctrl_lock(ctrl); 1768 1769 /* 1770 * Extend the control range if the parsed stream contains a known but 1771 * unsupported value or level. 1772 */ 1773 if (value > ctrl->maximum) { 1774 __v4l2_ctrl_modify_range(ctrl, ctrl->minimum, value, 1775 ctrl->menu_skip_mask & ~(1 << value), 1776 ctrl->default_value); 1777 } else if (value < ctrl->minimum) { 1778 __v4l2_ctrl_modify_range(ctrl, value, ctrl->maximum, 1779 ctrl->menu_skip_mask & ~(1 << value), 1780 ctrl->default_value); 1781 } 1782 1783 __v4l2_ctrl_s_ctrl(ctrl, value); 1784 1785 v4l2_ctrl_unlock(ctrl); 1786 } 1787 1788 void coda_update_profile_level_ctrls(struct coda_ctx *ctx, u8 profile_idc, 1789 u8 level_idc) 1790 { 1791 const char * const *profile_names; 1792 const char * const *level_names; 1793 struct v4l2_ctrl *profile_ctrl; 1794 struct v4l2_ctrl *level_ctrl; 1795 const char *codec_name; 1796 u32 profile_cid; 1797 u32 level_cid; 1798 int profile; 1799 int level; 1800 1801 switch (ctx->codec->src_fourcc) { 1802 case V4L2_PIX_FMT_H264: 1803 codec_name = "H264"; 1804 profile_cid = V4L2_CID_MPEG_VIDEO_H264_PROFILE; 1805 level_cid = V4L2_CID_MPEG_VIDEO_H264_LEVEL; 1806 profile_ctrl = ctx->h264_profile_ctrl; 1807 level_ctrl = ctx->h264_level_ctrl; 1808 profile = coda_h264_profile(profile_idc); 1809 level = coda_h264_level(level_idc); 1810 break; 1811 case V4L2_PIX_FMT_MPEG2: 1812 codec_name = "MPEG-2"; 1813 profile_cid = V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE; 1814 level_cid = V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL; 1815 profile_ctrl = ctx->mpeg2_profile_ctrl; 1816 level_ctrl = ctx->mpeg2_level_ctrl; 1817 profile = coda_mpeg2_profile(profile_idc); 1818 level = coda_mpeg2_level(level_idc); 1819 break; 1820 case V4L2_PIX_FMT_MPEG4: 1821 codec_name = "MPEG-4"; 1822 profile_cid = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE; 1823 level_cid = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL; 1824 profile_ctrl = ctx->mpeg4_profile_ctrl; 1825 level_ctrl = ctx->mpeg4_level_ctrl; 1826 profile = coda_mpeg4_profile(profile_idc); 1827 level = coda_mpeg4_level(level_idc); 1828 break; 1829 default: 1830 return; 1831 } 1832 1833 profile_names = v4l2_ctrl_get_menu(profile_cid); 1834 level_names = v4l2_ctrl_get_menu(level_cid); 1835 1836 if (profile < 0) { 1837 v4l2_warn(&ctx->dev->v4l2_dev, "Invalid %s profile: %u\n", 1838 codec_name, profile_idc); 1839 } else { 1840 coda_dbg(1, ctx, "Parsed %s profile: %s\n", codec_name, 1841 profile_names[profile]); 1842 coda_update_menu_ctrl(profile_ctrl, profile); 1843 } 1844 1845 if (level < 0) { 1846 v4l2_warn(&ctx->dev->v4l2_dev, "Invalid %s level: %u\n", 1847 codec_name, level_idc); 1848 } else { 1849 coda_dbg(1, ctx, "Parsed %s level: %s\n", codec_name, 1850 level_names[level]); 1851 coda_update_menu_ctrl(level_ctrl, level); 1852 } 1853 } 1854 1855 static void coda_queue_source_change_event(struct coda_ctx *ctx) 1856 { 1857 static const struct v4l2_event source_change_event = { 1858 .type = V4L2_EVENT_SOURCE_CHANGE, 1859 .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION, 1860 }; 1861 1862 v4l2_event_queue_fh(&ctx->fh, &source_change_event); 1863 } 1864 1865 static void coda_buf_queue(struct vb2_buffer *vb) 1866 { 1867 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1868 struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1869 struct vb2_queue *vq = vb->vb2_queue; 1870 struct coda_q_data *q_data; 1871 1872 q_data = get_q_data(ctx, vb->vb2_queue->type); 1873 1874 /* 1875 * In the decoder case, immediately try to copy the buffer into the 1876 * bitstream ringbuffer and mark it as ready to be dequeued. 1877 */ 1878 if (ctx->bitstream.size && vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1879 /* 1880 * For backwards compatibility, queuing an empty buffer marks 1881 * the stream end 1882 */ 1883 if (vb2_get_plane_payload(vb, 0) == 0) 1884 coda_bit_stream_end_flag(ctx); 1885 1886 if (q_data->fourcc == V4L2_PIX_FMT_H264) { 1887 /* 1888 * Unless already done, try to obtain profile_idc and 1889 * level_idc from the SPS header. This allows to decide 1890 * whether to enable reordering during sequence 1891 * initialization. 1892 */ 1893 if (!ctx->params.h264_profile_idc) { 1894 coda_sps_parse_profile(ctx, vb); 1895 coda_update_profile_level_ctrls(ctx, 1896 ctx->params.h264_profile_idc, 1897 ctx->params.h264_level_idc); 1898 } 1899 } 1900 1901 mutex_lock(&ctx->bitstream_mutex); 1902 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1903 if (vb2_is_streaming(vb->vb2_queue)) 1904 /* This set buf->sequence = ctx->qsequence++ */ 1905 coda_fill_bitstream(ctx, NULL); 1906 mutex_unlock(&ctx->bitstream_mutex); 1907 1908 if (!ctx->initialized) { 1909 /* 1910 * Run sequence initialization in case the queued 1911 * buffer contained headers. 1912 */ 1913 if (vb2_is_streaming(vb->vb2_queue) && 1914 ctx->ops->seq_init_work) { 1915 queue_work(ctx->dev->workqueue, 1916 &ctx->seq_init_work); 1917 flush_work(&ctx->seq_init_work); 1918 } 1919 1920 if (ctx->initialized) 1921 coda_queue_source_change_event(ctx); 1922 } 1923 } else { 1924 if ((ctx->inst_type == CODA_INST_ENCODER || !ctx->use_bit) && 1925 vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1926 vbuf->sequence = ctx->qsequence++; 1927 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1928 } 1929 } 1930 1931 int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf, 1932 size_t size, const char *name, struct dentry *parent) 1933 { 1934 buf->vaddr = dma_alloc_coherent(dev->dev, size, &buf->paddr, 1935 GFP_KERNEL); 1936 if (!buf->vaddr) { 1937 v4l2_err(&dev->v4l2_dev, 1938 "Failed to allocate %s buffer of size %zu\n", 1939 name, size); 1940 return -ENOMEM; 1941 } 1942 1943 buf->size = size; 1944 1945 if (name && parent) { 1946 buf->blob.data = buf->vaddr; 1947 buf->blob.size = size; 1948 buf->dentry = debugfs_create_blob(name, 0444, parent, 1949 &buf->blob); 1950 } 1951 1952 return 0; 1953 } 1954 1955 void coda_free_aux_buf(struct coda_dev *dev, 1956 struct coda_aux_buf *buf) 1957 { 1958 if (buf->vaddr) { 1959 dma_free_coherent(dev->dev, buf->size, buf->vaddr, buf->paddr); 1960 buf->vaddr = NULL; 1961 buf->size = 0; 1962 debugfs_remove(buf->dentry); 1963 buf->dentry = NULL; 1964 } 1965 } 1966 1967 static int coda_start_streaming(struct vb2_queue *q, unsigned int count) 1968 { 1969 struct coda_ctx *ctx = vb2_get_drv_priv(q); 1970 struct v4l2_device *v4l2_dev = &ctx->dev->v4l2_dev; 1971 struct coda_q_data *q_data_src, *q_data_dst; 1972 struct v4l2_m2m_buffer *m2m_buf, *tmp; 1973 struct vb2_v4l2_buffer *buf; 1974 struct list_head list; 1975 int ret = 0; 1976 1977 if (count < 1) 1978 return -EINVAL; 1979 1980 coda_dbg(1, ctx, "start streaming %s\n", v4l2_type_names[q->type]); 1981 1982 INIT_LIST_HEAD(&list); 1983 1984 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 1985 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1986 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) { 1987 /* copy the buffers that were queued before streamon */ 1988 mutex_lock(&ctx->bitstream_mutex); 1989 coda_fill_bitstream(ctx, &list); 1990 mutex_unlock(&ctx->bitstream_mutex); 1991 1992 if (ctx->dev->devtype->product != CODA_960 && 1993 coda_get_bitstream_payload(ctx) < 512) { 1994 v4l2_err(v4l2_dev, "start payload < 512\n"); 1995 ret = -EINVAL; 1996 goto err; 1997 } 1998 1999 if (!ctx->initialized) { 2000 /* Run sequence initialization */ 2001 if (ctx->ops->seq_init_work) { 2002 queue_work(ctx->dev->workqueue, 2003 &ctx->seq_init_work); 2004 flush_work(&ctx->seq_init_work); 2005 } 2006 } 2007 } 2008 2009 /* 2010 * Check the first input JPEG buffer to determine chroma 2011 * subsampling. 2012 */ 2013 if (q_data_src->fourcc == V4L2_PIX_FMT_JPEG) { 2014 buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2015 coda_jpeg_decode_header(ctx, &buf->vb2_buf); 2016 /* 2017 * We have to start streaming even if the first buffer 2018 * does not contain a valid JPEG image. The error will 2019 * be caught during device run and will be signalled 2020 * via the capture buffer error flag. 2021 */ 2022 2023 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 2024 q_data_dst->width = round_up(q_data_src->width, 16); 2025 q_data_dst->height = round_up(q_data_src->height, 16); 2026 q_data_dst->bytesperline = q_data_dst->width; 2027 if (ctx->params.jpeg_chroma_subsampling == 2028 V4L2_JPEG_CHROMA_SUBSAMPLING_420) { 2029 q_data_dst->sizeimage = 2030 q_data_dst->bytesperline * 2031 q_data_dst->height * 3 / 2; 2032 if (q_data_dst->fourcc != V4L2_PIX_FMT_YUV420) 2033 q_data_dst->fourcc = V4L2_PIX_FMT_NV12; 2034 } else { 2035 q_data_dst->sizeimage = 2036 q_data_dst->bytesperline * 2037 q_data_dst->height * 2; 2038 q_data_dst->fourcc = V4L2_PIX_FMT_YUV422P; 2039 } 2040 q_data_dst->rect.left = 0; 2041 q_data_dst->rect.top = 0; 2042 q_data_dst->rect.width = q_data_src->width; 2043 q_data_dst->rect.height = q_data_src->height; 2044 } 2045 ctx->streamon_out = 1; 2046 } else { 2047 ctx->streamon_cap = 1; 2048 } 2049 2050 /* Don't start the coda unless both queues are on */ 2051 if (!(ctx->streamon_out && ctx->streamon_cap)) 2052 goto out; 2053 2054 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 2055 if ((q_data_src->rect.width != q_data_dst->width && 2056 round_up(q_data_src->rect.width, 16) != q_data_dst->width) || 2057 (q_data_src->rect.height != q_data_dst->height && 2058 round_up(q_data_src->rect.height, 16) != q_data_dst->height)) { 2059 v4l2_err(v4l2_dev, "can't convert %dx%d to %dx%d\n", 2060 q_data_src->rect.width, q_data_src->rect.height, 2061 q_data_dst->width, q_data_dst->height); 2062 ret = -EINVAL; 2063 goto err; 2064 } 2065 2066 /* Allow BIT decoder device_run with no new buffers queued */ 2067 if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit) 2068 v4l2_m2m_set_src_buffered(ctx->fh.m2m_ctx, true); 2069 2070 ctx->gopcounter = ctx->params.gop_size - 1; 2071 2072 if (q_data_dst->fourcc == V4L2_PIX_FMT_JPEG) 2073 ctx->params.gop_size = 1; 2074 ctx->gopcounter = ctx->params.gop_size - 1; 2075 /* Only decoders have this control */ 2076 if (ctx->mb_err_cnt_ctrl) 2077 v4l2_ctrl_s_ctrl(ctx->mb_err_cnt_ctrl, 0); 2078 2079 ret = ctx->ops->start_streaming(ctx); 2080 if (ctx->inst_type == CODA_INST_DECODER) { 2081 if (ret == -EAGAIN) 2082 goto out; 2083 } 2084 if (ret < 0) 2085 goto err; 2086 2087 out: 2088 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2089 list_for_each_entry_safe(m2m_buf, tmp, &list, list) { 2090 list_del(&m2m_buf->list); 2091 v4l2_m2m_buf_done(&m2m_buf->vb, VB2_BUF_STATE_DONE); 2092 } 2093 } 2094 return 0; 2095 2096 err: 2097 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2098 list_for_each_entry_safe(m2m_buf, tmp, &list, list) { 2099 list_del(&m2m_buf->list); 2100 v4l2_m2m_buf_done(&m2m_buf->vb, VB2_BUF_STATE_QUEUED); 2101 } 2102 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 2103 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED); 2104 } else { 2105 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx))) 2106 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_QUEUED); 2107 } 2108 return ret; 2109 } 2110 2111 static void coda_stop_streaming(struct vb2_queue *q) 2112 { 2113 struct coda_ctx *ctx = vb2_get_drv_priv(q); 2114 struct coda_dev *dev = ctx->dev; 2115 struct vb2_v4l2_buffer *buf; 2116 bool stop; 2117 2118 stop = ctx->streamon_out && ctx->streamon_cap; 2119 2120 coda_dbg(1, ctx, "stop streaming %s\n", v4l2_type_names[q->type]); 2121 2122 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2123 ctx->streamon_out = 0; 2124 2125 coda_bit_stream_end_flag(ctx); 2126 2127 ctx->qsequence = 0; 2128 2129 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx))) 2130 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_ERROR); 2131 } else { 2132 ctx->streamon_cap = 0; 2133 2134 ctx->osequence = 0; 2135 ctx->sequence_offset = 0; 2136 2137 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx))) 2138 v4l2_m2m_buf_done(buf, VB2_BUF_STATE_ERROR); 2139 } 2140 2141 if (stop) { 2142 struct coda_buffer_meta *meta; 2143 2144 if (ctx->ops->seq_end_work) { 2145 queue_work(dev->workqueue, &ctx->seq_end_work); 2146 flush_work(&ctx->seq_end_work); 2147 } 2148 spin_lock(&ctx->buffer_meta_lock); 2149 while (!list_empty(&ctx->buffer_meta_list)) { 2150 meta = list_first_entry(&ctx->buffer_meta_list, 2151 struct coda_buffer_meta, list); 2152 list_del(&meta->list); 2153 kfree(meta); 2154 } 2155 ctx->num_metas = 0; 2156 spin_unlock(&ctx->buffer_meta_lock); 2157 kfifo_init(&ctx->bitstream_fifo, 2158 ctx->bitstream.vaddr, ctx->bitstream.size); 2159 ctx->runcounter = 0; 2160 ctx->aborting = 0; 2161 ctx->hold = false; 2162 } 2163 2164 if (!ctx->streamon_out && !ctx->streamon_cap) 2165 ctx->bit_stream_param &= ~CODA_BIT_STREAM_END_FLAG; 2166 } 2167 2168 static const struct vb2_ops coda_qops = { 2169 .queue_setup = coda_queue_setup, 2170 .buf_prepare = coda_buf_prepare, 2171 .buf_queue = coda_buf_queue, 2172 .start_streaming = coda_start_streaming, 2173 .stop_streaming = coda_stop_streaming, 2174 }; 2175 2176 static int coda_s_ctrl(struct v4l2_ctrl *ctrl) 2177 { 2178 const char * const *val_names = v4l2_ctrl_get_menu(ctrl->id); 2179 struct coda_ctx *ctx = 2180 container_of(ctrl->handler, struct coda_ctx, ctrls); 2181 2182 if (val_names) 2183 coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d (\"%s\")\n", 2184 ctrl->id, ctrl->name, ctrl->val, val_names[ctrl->val]); 2185 else 2186 coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d\n", 2187 ctrl->id, ctrl->name, ctrl->val); 2188 2189 switch (ctrl->id) { 2190 case V4L2_CID_HFLIP: 2191 if (ctrl->val) 2192 ctx->params.rot_mode |= CODA_MIR_HOR; 2193 else 2194 ctx->params.rot_mode &= ~CODA_MIR_HOR; 2195 break; 2196 case V4L2_CID_VFLIP: 2197 if (ctrl->val) 2198 ctx->params.rot_mode |= CODA_MIR_VER; 2199 else 2200 ctx->params.rot_mode &= ~CODA_MIR_VER; 2201 break; 2202 case V4L2_CID_MPEG_VIDEO_BITRATE: 2203 ctx->params.bitrate = ctrl->val / 1000; 2204 ctx->params.bitrate_changed = true; 2205 break; 2206 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: 2207 ctx->params.gop_size = ctrl->val; 2208 break; 2209 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: 2210 ctx->params.h264_intra_qp = ctrl->val; 2211 ctx->params.h264_intra_qp_changed = true; 2212 break; 2213 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: 2214 ctx->params.h264_inter_qp = ctrl->val; 2215 break; 2216 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: 2217 ctx->params.h264_min_qp = ctrl->val; 2218 break; 2219 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: 2220 ctx->params.h264_max_qp = ctrl->val; 2221 break; 2222 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: 2223 ctx->params.h264_slice_alpha_c0_offset_div2 = ctrl->val; 2224 break; 2225 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: 2226 ctx->params.h264_slice_beta_offset_div2 = ctrl->val; 2227 break; 2228 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: 2229 ctx->params.h264_disable_deblocking_filter_idc = ctrl->val; 2230 break; 2231 case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION: 2232 ctx->params.h264_constrained_intra_pred_flag = ctrl->val; 2233 break; 2234 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: 2235 ctx->params.frame_rc_enable = ctrl->val; 2236 break; 2237 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: 2238 ctx->params.mb_rc_enable = ctrl->val; 2239 break; 2240 case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: 2241 ctx->params.h264_chroma_qp_index_offset = ctrl->val; 2242 break; 2243 case V4L2_CID_MPEG_VIDEO_H264_PROFILE: 2244 /* TODO: switch between baseline and constrained baseline */ 2245 if (ctx->inst_type == CODA_INST_ENCODER) 2246 ctx->params.h264_profile_idc = 66; 2247 break; 2248 case V4L2_CID_MPEG_VIDEO_H264_LEVEL: 2249 /* nothing to do, this is set by the encoder */ 2250 break; 2251 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: 2252 ctx->params.mpeg4_intra_qp = ctrl->val; 2253 break; 2254 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: 2255 ctx->params.mpeg4_inter_qp = ctrl->val; 2256 break; 2257 case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: 2258 case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: 2259 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: 2260 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: 2261 /* nothing to do, these are fixed */ 2262 break; 2263 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: 2264 ctx->params.slice_mode = ctrl->val; 2265 ctx->params.slice_mode_changed = true; 2266 break; 2267 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: 2268 ctx->params.slice_max_mb = ctrl->val; 2269 ctx->params.slice_mode_changed = true; 2270 break; 2271 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: 2272 ctx->params.slice_max_bits = ctrl->val * 8; 2273 ctx->params.slice_mode_changed = true; 2274 break; 2275 case V4L2_CID_MPEG_VIDEO_HEADER_MODE: 2276 break; 2277 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: 2278 ctx->params.intra_refresh = ctrl->val; 2279 ctx->params.intra_refresh_changed = true; 2280 break; 2281 case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: 2282 ctx->params.force_ipicture = true; 2283 break; 2284 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 2285 coda_set_jpeg_compression_quality(ctx, ctrl->val); 2286 break; 2287 case V4L2_CID_JPEG_RESTART_INTERVAL: 2288 ctx->params.jpeg_restart_interval = ctrl->val; 2289 break; 2290 case V4L2_CID_MPEG_VIDEO_VBV_DELAY: 2291 ctx->params.vbv_delay = ctrl->val; 2292 break; 2293 case V4L2_CID_MPEG_VIDEO_VBV_SIZE: 2294 ctx->params.vbv_size = min(ctrl->val * 8192, 0x7fffffff); 2295 break; 2296 default: 2297 coda_dbg(1, ctx, "Invalid control, id=%d, val=%d\n", 2298 ctrl->id, ctrl->val); 2299 return -EINVAL; 2300 } 2301 2302 return 0; 2303 } 2304 2305 static const struct v4l2_ctrl_ops coda_ctrl_ops = { 2306 .s_ctrl = coda_s_ctrl, 2307 }; 2308 2309 static void coda_encode_ctrls(struct coda_ctx *ctx) 2310 { 2311 int max_gop_size = (ctx->dev->devtype->product == CODA_DX6) ? 60 : 99; 2312 2313 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2314 V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1000, 0); 2315 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2316 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, max_gop_size, 1, 16); 2317 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2318 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 0, 51, 1, 25); 2319 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2320 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 0, 51, 1, 25); 2321 if (ctx->dev->devtype->product != CODA_960) { 2322 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2323 V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 0, 51, 1, 12); 2324 } 2325 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2326 V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 0, 51, 1, 51); 2327 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2328 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0); 2329 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2330 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0); 2331 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2332 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, 2333 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY, 2334 0x0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED); 2335 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2336 V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION, 0, 1, 1, 2337 0); 2338 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2339 V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1); 2340 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2341 V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE, 0, 1, 1, 1); 2342 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2343 V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET, -12, 12, 1, 0); 2344 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2345 V4L2_CID_MPEG_VIDEO_H264_PROFILE, 2346 V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE, 0x0, 2347 V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE); 2348 if (ctx->dev->devtype->product == CODA_HX4 || 2349 ctx->dev->devtype->product == CODA_7541) { 2350 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2351 V4L2_CID_MPEG_VIDEO_H264_LEVEL, 2352 V4L2_MPEG_VIDEO_H264_LEVEL_3_1, 2353 ~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) | 2354 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) | 2355 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1)), 2356 V4L2_MPEG_VIDEO_H264_LEVEL_3_1); 2357 } 2358 if (ctx->dev->devtype->product == CODA_960) { 2359 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2360 V4L2_CID_MPEG_VIDEO_H264_LEVEL, 2361 V4L2_MPEG_VIDEO_H264_LEVEL_4_2, 2362 ~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_0) | 2363 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) | 2364 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) | 2365 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1) | 2366 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_2) | 2367 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_0) | 2368 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_1) | 2369 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_2)), 2370 V4L2_MPEG_VIDEO_H264_LEVEL_4_0); 2371 } 2372 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2373 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP, 1, 31, 1, 2); 2374 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2375 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP, 1, 31, 1, 2); 2376 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2377 V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE, 2378 V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE, 0x0, 2379 V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE); 2380 if (ctx->dev->devtype->product == CODA_HX4 || 2381 ctx->dev->devtype->product == CODA_7541 || 2382 ctx->dev->devtype->product == CODA_960) { 2383 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2384 V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL, 2385 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5, 2386 ~(1 << V4L2_MPEG_VIDEO_MPEG4_LEVEL_5), 2387 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5); 2388 } 2389 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2390 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE, 2391 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES, 0x0, 2392 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE); 2393 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2394 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1, 0x3fffffff, 1, 1); 2395 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2396 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, 1, 0x3fffffff, 1, 2397 500); 2398 v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops, 2399 V4L2_CID_MPEG_VIDEO_HEADER_MODE, 2400 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME, 2401 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE), 2402 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME); 2403 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2404 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB, 0, 2405 1920 * 1088 / 256, 1, 0); 2406 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2407 V4L2_CID_MPEG_VIDEO_VBV_DELAY, 0, 0x7fff, 1, 0); 2408 /* 2409 * The maximum VBV size value is 0x7fffffff bits, 2410 * one bit less than 262144 KiB 2411 */ 2412 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2413 V4L2_CID_MPEG_VIDEO_VBV_SIZE, 0, 262144, 1, 0); 2414 } 2415 2416 static void coda_jpeg_encode_ctrls(struct coda_ctx *ctx) 2417 { 2418 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2419 V4L2_CID_JPEG_COMPRESSION_QUALITY, 5, 100, 1, 50); 2420 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2421 V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, 1, 0); 2422 } 2423 2424 static void coda_decode_ctrls(struct coda_ctx *ctx) 2425 { 2426 u8 max; 2427 2428 ctx->h264_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2429 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_PROFILE, 2430 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 2431 ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) | 2432 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) | 2433 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)), 2434 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH); 2435 if (ctx->h264_profile_ctrl) 2436 ctx->h264_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2437 2438 if (ctx->dev->devtype->product == CODA_HX4 || 2439 ctx->dev->devtype->product == CODA_7541) 2440 max = V4L2_MPEG_VIDEO_H264_LEVEL_4_0; 2441 else if (ctx->dev->devtype->product == CODA_960) 2442 max = V4L2_MPEG_VIDEO_H264_LEVEL_4_1; 2443 else 2444 return; 2445 ctx->h264_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2446 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_LEVEL, max, 0, max); 2447 if (ctx->h264_level_ctrl) 2448 ctx->h264_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2449 2450 ctx->mpeg2_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2451 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE, 2452 V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH, 0, 2453 V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH); 2454 if (ctx->mpeg2_profile_ctrl) 2455 ctx->mpeg2_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2456 2457 ctx->mpeg2_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2458 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL, 2459 V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH, 0, 2460 V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH); 2461 if (ctx->mpeg2_level_ctrl) 2462 ctx->mpeg2_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2463 2464 ctx->mpeg4_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2465 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE, 2466 V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY, 0, 2467 V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY); 2468 if (ctx->mpeg4_profile_ctrl) 2469 ctx->mpeg4_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2470 2471 ctx->mpeg4_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls, 2472 &coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL, 2473 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5, 0, 2474 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5); 2475 if (ctx->mpeg4_level_ctrl) 2476 ctx->mpeg4_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2477 } 2478 2479 static const struct v4l2_ctrl_config coda_mb_err_cnt_ctrl_config = { 2480 .id = V4L2_CID_CODA_MB_ERR_CNT, 2481 .name = "Macroblocks Error Count", 2482 .type = V4L2_CTRL_TYPE_INTEGER, 2483 .min = 0, 2484 .max = 0x7fffffff, 2485 .step = 1, 2486 }; 2487 2488 static int coda_ctrls_setup(struct coda_ctx *ctx) 2489 { 2490 v4l2_ctrl_handler_init(&ctx->ctrls, 2); 2491 2492 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2493 V4L2_CID_HFLIP, 0, 1, 1, 0); 2494 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2495 V4L2_CID_VFLIP, 0, 1, 1, 0); 2496 if (ctx->inst_type == CODA_INST_ENCODER) { 2497 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2498 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 2499 1, 1, 1, 1); 2500 if (ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG) 2501 coda_jpeg_encode_ctrls(ctx); 2502 else 2503 coda_encode_ctrls(ctx); 2504 } else { 2505 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops, 2506 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 2507 1, 1, 1, 1); 2508 if (ctx->cvd->src_formats[0] == V4L2_PIX_FMT_H264) 2509 coda_decode_ctrls(ctx); 2510 2511 ctx->mb_err_cnt_ctrl = v4l2_ctrl_new_custom(&ctx->ctrls, 2512 &coda_mb_err_cnt_ctrl_config, 2513 NULL); 2514 if (ctx->mb_err_cnt_ctrl) 2515 ctx->mb_err_cnt_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 2516 } 2517 2518 if (ctx->ctrls.error) { 2519 v4l2_err(&ctx->dev->v4l2_dev, 2520 "control initialization error (%d)", 2521 ctx->ctrls.error); 2522 return -EINVAL; 2523 } 2524 2525 return v4l2_ctrl_handler_setup(&ctx->ctrls); 2526 } 2527 2528 static int coda_queue_init(struct coda_ctx *ctx, struct vb2_queue *vq) 2529 { 2530 vq->drv_priv = ctx; 2531 vq->ops = &coda_qops; 2532 vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2533 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2534 vq->lock = &ctx->dev->dev_mutex; 2535 /* One way to indicate end-of-stream for coda is to set the 2536 * bytesused == 0. However by default videobuf2 handles bytesused 2537 * equal to 0 as a special case and changes its value to the size 2538 * of the buffer. Set the allow_zero_bytesused flag, so 2539 * that videobuf2 will keep the value of bytesused intact. 2540 */ 2541 vq->allow_zero_bytesused = 1; 2542 /* 2543 * We might be fine with no buffers on some of the queues, but that 2544 * would need to be reflected in job_ready(). Currently we expect all 2545 * queues to have at least one buffer queued. 2546 */ 2547 vq->min_queued_buffers = 1; 2548 vq->dev = ctx->dev->dev; 2549 2550 return vb2_queue_init(vq); 2551 } 2552 2553 int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq, 2554 struct vb2_queue *dst_vq) 2555 { 2556 int ret; 2557 2558 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2559 src_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2560 src_vq->mem_ops = &vb2_dma_contig_memops; 2561 2562 ret = coda_queue_init(priv, src_vq); 2563 if (ret) 2564 return ret; 2565 2566 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2567 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2568 dst_vq->mem_ops = &vb2_dma_contig_memops; 2569 2570 return coda_queue_init(priv, dst_vq); 2571 } 2572 2573 int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq, 2574 struct vb2_queue *dst_vq) 2575 { 2576 int ret; 2577 2578 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2579 src_vq->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR; 2580 src_vq->mem_ops = &vb2_vmalloc_memops; 2581 2582 ret = coda_queue_init(priv, src_vq); 2583 if (ret) 2584 return ret; 2585 2586 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2587 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; 2588 dst_vq->dma_attrs = DMA_ATTR_NO_KERNEL_MAPPING; 2589 dst_vq->mem_ops = &vb2_dma_contig_memops; 2590 2591 return coda_queue_init(priv, dst_vq); 2592 } 2593 2594 /* 2595 * File operations 2596 */ 2597 2598 static int coda_open(struct file *file) 2599 { 2600 struct video_device *vdev = video_devdata(file); 2601 struct coda_dev *dev = video_get_drvdata(vdev); 2602 struct coda_ctx *ctx; 2603 unsigned int max = ~0; 2604 char *name; 2605 int ret; 2606 int idx; 2607 2608 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 2609 if (!ctx) 2610 return -ENOMEM; 2611 2612 if (dev->devtype->product == CODA_DX6) 2613 max = CODADX6_MAX_INSTANCES - 1; 2614 idx = ida_alloc_max(&dev->ida, max, GFP_KERNEL); 2615 if (idx < 0) { 2616 ret = idx; 2617 goto err_coda_max; 2618 } 2619 2620 name = kasprintf(GFP_KERNEL, "context%d", idx); 2621 if (!name) { 2622 ret = -ENOMEM; 2623 goto err_coda_name_init; 2624 } 2625 2626 ctx->debugfs_entry = debugfs_create_dir(name, dev->debugfs_root); 2627 kfree(name); 2628 2629 ctx->cvd = to_coda_video_device(vdev); 2630 ctx->inst_type = ctx->cvd->type; 2631 ctx->ops = ctx->cvd->ops; 2632 ctx->use_bit = !ctx->cvd->direct; 2633 init_completion(&ctx->completion); 2634 INIT_WORK(&ctx->pic_run_work, coda_pic_run_work); 2635 if (ctx->ops->seq_init_work) 2636 INIT_WORK(&ctx->seq_init_work, ctx->ops->seq_init_work); 2637 if (ctx->ops->seq_end_work) 2638 INIT_WORK(&ctx->seq_end_work, ctx->ops->seq_end_work); 2639 v4l2_fh_init(&ctx->fh, video_devdata(file)); 2640 file->private_data = &ctx->fh; 2641 v4l2_fh_add(&ctx->fh); 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 2715 err_ctrls_setup: 2716 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 2717 err_ctx_init: 2718 clk_disable_unprepare(dev->clk_ahb); 2719 err_clk_ahb: 2720 clk_disable_unprepare(dev->clk_per); 2721 err_clk_enable: 2722 pm_runtime_put_sync(dev->dev); 2723 err_pm_get: 2724 v4l2_fh_del(&ctx->fh); 2725 v4l2_fh_exit(&ctx->fh); 2726 err_coda_name_init: 2727 ida_free(&dev->ida, ctx->idx); 2728 err_coda_max: 2729 kfree(ctx); 2730 return ret; 2731 } 2732 2733 static int coda_release(struct file *file) 2734 { 2735 struct coda_dev *dev = video_drvdata(file); 2736 struct coda_ctx *ctx = fh_to_ctx(file->private_data); 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); 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 2773 static 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 2782 static 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 2875 err_clk_ahb: 2876 clk_disable_unprepare(dev->clk_per); 2877 err_clk_per: 2878 return ret; 2879 } 2880 2881 static 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 2930 static 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 2962 static void coda_fw_callback(const struct firmware *fw, void *context); 2963 2964 static 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 2980 static 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 3042 rel_vfd: 3043 while (--i >= 0) 3044 video_unregister_device(&dev->vfd[i]); 3045 v4l2_m2m_release(dev->m2m_dev); 3046 put_pm: 3047 pm_runtime_put_sync(dev->dev); 3048 } 3049 3050 enum coda_platform { 3051 CODA_IMX27, 3052 CODA_IMX51, 3053 CODA_IMX53, 3054 CODA_IMX6Q, 3055 CODA_IMX6DL, 3056 }; 3057 3058 static 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 3135 static 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 }; 3143 MODULE_DEVICE_TABLE(of, coda_dt_ids); 3144 3145 static 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 3292 err_alloc_workqueue: 3293 pm_runtime_disable(&pdev->dev); 3294 pm_runtime_put_noidle(&pdev->dev); 3295 destroy_workqueue(dev->workqueue); 3296 err_v4l2_register: 3297 v4l2_device_unregister(&dev->v4l2_dev); 3298 return ret; 3299 } 3300 3301 static 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 3326 static 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 3341 static const struct dev_pm_ops coda_pm_ops = { 3342 SET_RUNTIME_PM_OPS(NULL, coda_runtime_resume, NULL) 3343 }; 3344 3345 static struct platform_driver coda_driver = { 3346 .probe = coda_probe, 3347 .remove = coda_remove, 3348 .driver = { 3349 .name = CODA_NAME, 3350 .of_match_table = coda_dt_ids, 3351 .pm = &coda_pm_ops, 3352 }, 3353 }; 3354 3355 module_platform_driver(coda_driver); 3356 3357 MODULE_LICENSE("GPL"); 3358 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>"); 3359 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver"); 3360