brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Coda multi-standard codec IP4 *5 * Copyright (C) 2012 Vista Silicon S.L.6 *    Javier Martin, <javier.martin@vista-silicon.com>7 *    Xavier Duret8 */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	446#define CODA_MAX_FORMATS	547 48#define CODA_ISRAM_SIZE	(2048 * 2)49 50#define MIN_W 4851#define MIN_H 1652 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 59int coda_debug;60module_param(coda_debug, int, 0644);61MODULE_PARM_DESC(coda_debug, "Debug level (0-2)");62 63static int disable_tiling;64module_param(disable_tiling, int, 0644);65MODULE_PARM_DESC(disable_tiling, "Disable tiled frame buffers");66 67static int disable_vdoa;68module_param(disable_vdoa, int, 0644);69MODULE_PARM_DESC(disable_vdoa, "Disable Video Data Order Adapter tiled to raster-scan conversion");70 71static int enable_bwb = 0;72module_param(enable_bwb, int, 0644);73MODULE_PARM_DESC(enable_bwb, "Enable BWB unit for decoding, may crash on certain streams");74 75void 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 82unsigned 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 92void 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 -> codadx6128 *  i.MX51 -> codahx4129 *  i.MX53 -> coda7130 *  i.MX6  -> coda960131 * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants132 */133static 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 138static 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 145static 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 155static 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 165struct 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 174static 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 189static 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 204static 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 225static 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 240static 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 257static 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 273static const struct coda_video_device *codadx6_video_devices[] = {274	&coda_bit_encoder,275};276 277static const struct coda_video_device *codahx4_video_devices[] = {278	&coda_bit_encoder,279	&coda_bit_decoder,280};281 282static 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 289static 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 codec298 * tables.299 */300static 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 314static 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 338static 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 363static const struct coda_video_device *to_coda_video_device(struct video_device364							    *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 375const 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 394static 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);413out:414	of_node_put(vdoa_node);415 416	return vdoa_data;417}418 419/*420 * V4L2 ioctl() operations.421 */422static 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 434static 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 440static 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 same458		 * 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 491static 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 516static 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	else527		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 548static 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 575static 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 buffer580	 * sizes (between 1 and 16 bits per pixel). This could be581	 * 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 587static 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 struct601	 * 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:x616		 */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 653static 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 output673	 * resolution. When decoding JPEG images, we also have to make sure to674	 * 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 742static 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	else751		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 759static 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 781static 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	else843		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 853static 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 905static 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 capture945	 * queue is still busy. This is not an error, but the user will have to946	 * make sure themselves that the capture format is set correctly before947	 * 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 961static 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 as973	 * 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 981static 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 993static 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 1007void 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_EOS1012	};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 1020static 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 1066static 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 1110static 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 1121static 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 sure1137		 * that decoder finish_run will see the last flag and report it1138		 * 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 the1147		 * queue, wake up the capture queue and signal end of stream1148		 * 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 1157static 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 1177static 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 1202static 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				else1252					wakeup = true;1253			else1254				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 1281static 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 1314static 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 1354static 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 written1373 * into the 16-bit CODA_FRATE_DIV and CODA_FRATE_RES fields.1374 */1375static 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 1431static 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 1437static 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 1454static 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		else1466			return -EINVAL;1467	default:1468		return v4l2_ctrl_subscribe_event(fh, sub);1469	}1470}1471 1472static 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 1519static 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 1527static 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 1560out: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 1567static 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 picture1574	 * 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 1637static 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 1646static 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 1652static 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 operations1710 */1711static 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 1734static 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 1762static 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 but1771	 * 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 1788void 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 1855static 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 1865static 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 the1876	 * 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 marks1881		 * the stream end1882		 */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 and1889			 * level_idc from the SPS header. This allows to decide1890			 * whether to enable reordering during sequence1891			 * 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 queued1911			 * 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 1931int 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 1955void 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 1967static 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 chroma2011		 * 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 buffer2018			 * does not contain a valid JPEG image. The error will2019			 * be caught during device run and will be signalled2020			 * 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 2087out: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 2096err: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 2111static 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 2168static 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	.wait_prepare		= vb2_ops_wait_prepare,2175	.wait_finish		= vb2_ops_wait_finish,2176};2177 2178static int coda_s_ctrl(struct v4l2_ctrl *ctrl)2179{2180	const char * const *val_names = v4l2_ctrl_get_menu(ctrl->id);2181	struct coda_ctx *ctx =2182			container_of(ctrl->handler, struct coda_ctx, ctrls);2183 2184	if (val_names)2185		coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d (\"%s\")\n",2186			 ctrl->id, ctrl->name, ctrl->val, val_names[ctrl->val]);2187	else2188		coda_dbg(2, ctx, "s_ctrl: id = 0x%x, name = \"%s\", val = %d\n",2189			 ctrl->id, ctrl->name, ctrl->val);2190 2191	switch (ctrl->id) {2192	case V4L2_CID_HFLIP:2193		if (ctrl->val)2194			ctx->params.rot_mode |= CODA_MIR_HOR;2195		else2196			ctx->params.rot_mode &= ~CODA_MIR_HOR;2197		break;2198	case V4L2_CID_VFLIP:2199		if (ctrl->val)2200			ctx->params.rot_mode |= CODA_MIR_VER;2201		else2202			ctx->params.rot_mode &= ~CODA_MIR_VER;2203		break;2204	case V4L2_CID_MPEG_VIDEO_BITRATE:2205		ctx->params.bitrate = ctrl->val / 1000;2206		ctx->params.bitrate_changed = true;2207		break;2208	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:2209		ctx->params.gop_size = ctrl->val;2210		break;2211	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:2212		ctx->params.h264_intra_qp = ctrl->val;2213		ctx->params.h264_intra_qp_changed = true;2214		break;2215	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:2216		ctx->params.h264_inter_qp = ctrl->val;2217		break;2218	case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:2219		ctx->params.h264_min_qp = ctrl->val;2220		break;2221	case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:2222		ctx->params.h264_max_qp = ctrl->val;2223		break;2224	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:2225		ctx->params.h264_slice_alpha_c0_offset_div2 = ctrl->val;2226		break;2227	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:2228		ctx->params.h264_slice_beta_offset_div2 = ctrl->val;2229		break;2230	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:2231		ctx->params.h264_disable_deblocking_filter_idc = ctrl->val;2232		break;2233	case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION:2234		ctx->params.h264_constrained_intra_pred_flag = ctrl->val;2235		break;2236	case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:2237		ctx->params.frame_rc_enable = ctrl->val;2238		break;2239	case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:2240		ctx->params.mb_rc_enable = ctrl->val;2241		break;2242	case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET:2243		ctx->params.h264_chroma_qp_index_offset = ctrl->val;2244		break;2245	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:2246		/* TODO: switch between baseline and constrained baseline */2247		if (ctx->inst_type == CODA_INST_ENCODER)2248			ctx->params.h264_profile_idc = 66;2249		break;2250	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:2251		/* nothing to do, this is set by the encoder */2252		break;2253	case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:2254		ctx->params.mpeg4_intra_qp = ctrl->val;2255		break;2256	case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:2257		ctx->params.mpeg4_inter_qp = ctrl->val;2258		break;2259	case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:2260	case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:2261	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:2262	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:2263		/* nothing to do, these are fixed */2264		break;2265	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:2266		ctx->params.slice_mode = ctrl->val;2267		ctx->params.slice_mode_changed = true;2268		break;2269	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:2270		ctx->params.slice_max_mb = ctrl->val;2271		ctx->params.slice_mode_changed = true;2272		break;2273	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:2274		ctx->params.slice_max_bits = ctrl->val * 8;2275		ctx->params.slice_mode_changed = true;2276		break;2277	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:2278		break;2279	case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:2280		ctx->params.intra_refresh = ctrl->val;2281		ctx->params.intra_refresh_changed = true;2282		break;2283	case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:2284		ctx->params.force_ipicture = true;2285		break;2286	case V4L2_CID_JPEG_COMPRESSION_QUALITY:2287		coda_set_jpeg_compression_quality(ctx, ctrl->val);2288		break;2289	case V4L2_CID_JPEG_RESTART_INTERVAL:2290		ctx->params.jpeg_restart_interval = ctrl->val;2291		break;2292	case V4L2_CID_MPEG_VIDEO_VBV_DELAY:2293		ctx->params.vbv_delay = ctrl->val;2294		break;2295	case V4L2_CID_MPEG_VIDEO_VBV_SIZE:2296		ctx->params.vbv_size = min(ctrl->val * 8192, 0x7fffffff);2297		break;2298	default:2299		coda_dbg(1, ctx, "Invalid control, id=%d, val=%d\n",2300			 ctrl->id, ctrl->val);2301		return -EINVAL;2302	}2303 2304	return 0;2305}2306 2307static const struct v4l2_ctrl_ops coda_ctrl_ops = {2308	.s_ctrl = coda_s_ctrl,2309};2310 2311static void coda_encode_ctrls(struct coda_ctx *ctx)2312{2313	int max_gop_size = (ctx->dev->devtype->product == CODA_DX6) ? 60 : 99;2314 2315	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2316		V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1000, 0);2317	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2318		V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, max_gop_size, 1, 16);2319	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2320		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 0, 51, 1, 25);2321	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2322		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 0, 51, 1, 25);2323	if (ctx->dev->devtype->product != CODA_960) {2324		v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2325			V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 0, 51, 1, 12);2326	}2327	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2328		V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 0, 51, 1, 51);2329	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2330		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0);2331	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2332		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0);2333	v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2334		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,2335		V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY,2336		0x0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED);2337	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2338		V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION, 0, 1, 1,2339		0);2340	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2341		V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);2342	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2343		V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE, 0, 1, 1, 1);2344	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2345		V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET, -12, 12, 1, 0);2346	v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2347		V4L2_CID_MPEG_VIDEO_H264_PROFILE,2348		V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE, 0x0,2349		V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE);2350	if (ctx->dev->devtype->product == CODA_HX4 ||2351	    ctx->dev->devtype->product == CODA_7541) {2352		v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2353			V4L2_CID_MPEG_VIDEO_H264_LEVEL,2354			V4L2_MPEG_VIDEO_H264_LEVEL_3_1,2355			~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |2356			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |2357			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1)),2358			V4L2_MPEG_VIDEO_H264_LEVEL_3_1);2359	}2360	if (ctx->dev->devtype->product == CODA_960) {2361		v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2362			V4L2_CID_MPEG_VIDEO_H264_LEVEL,2363			V4L2_MPEG_VIDEO_H264_LEVEL_4_2,2364			~((1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |2365			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |2366			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |2367			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1) |2368			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_2) |2369			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_0) |2370			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_1) |2371			  (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_2)),2372			V4L2_MPEG_VIDEO_H264_LEVEL_4_0);2373	}2374	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2375		V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP, 1, 31, 1, 2);2376	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2377		V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP, 1, 31, 1, 2);2378	v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2379		V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,2380		V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE, 0x0,2381		V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE);2382	if (ctx->dev->devtype->product == CODA_HX4 ||2383	    ctx->dev->devtype->product == CODA_7541 ||2384	    ctx->dev->devtype->product == CODA_960) {2385		v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2386			V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,2387			V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,2388			~(1 << V4L2_MPEG_VIDEO_MPEG4_LEVEL_5),2389			V4L2_MPEG_VIDEO_MPEG4_LEVEL_5);2390	}2391	v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2392		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,2393		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES, 0x0,2394		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);2395	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2396		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1, 0x3fffffff, 1, 1);2397	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2398		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, 1, 0x3fffffff, 1,2399		500);2400	v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,2401		V4L2_CID_MPEG_VIDEO_HEADER_MODE,2402		V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,2403		(1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE),2404		V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);2405	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2406		V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB, 0,2407		1920 * 1088 / 256, 1, 0);2408	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2409		V4L2_CID_MPEG_VIDEO_VBV_DELAY, 0, 0x7fff, 1, 0);2410	/*2411	 * The maximum VBV size value is 0x7fffffff bits,2412	 * one bit less than 262144 KiB2413	 */2414	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2415		V4L2_CID_MPEG_VIDEO_VBV_SIZE, 0, 262144, 1, 0);2416}2417 2418static void coda_jpeg_encode_ctrls(struct coda_ctx *ctx)2419{2420	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2421		V4L2_CID_JPEG_COMPRESSION_QUALITY, 5, 100, 1, 50);2422	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2423		V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, 1, 0);2424}2425 2426static void coda_decode_ctrls(struct coda_ctx *ctx)2427{2428	u8 max;2429 2430	ctx->h264_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2431		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_PROFILE,2432		V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,2433		~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |2434		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |2435		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),2436		V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);2437	if (ctx->h264_profile_ctrl)2438		ctx->h264_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2439 2440	if (ctx->dev->devtype->product == CODA_HX4 ||2441	    ctx->dev->devtype->product == CODA_7541)2442		max = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;2443	else if (ctx->dev->devtype->product == CODA_960)2444		max = V4L2_MPEG_VIDEO_H264_LEVEL_4_1;2445	else2446		return;2447	ctx->h264_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2448		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_H264_LEVEL, max, 0, max);2449	if (ctx->h264_level_ctrl)2450		ctx->h264_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2451 2452	ctx->mpeg2_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2453		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE,2454		V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH, 0,2455		V4L2_MPEG_VIDEO_MPEG2_PROFILE_HIGH);2456	if (ctx->mpeg2_profile_ctrl)2457		ctx->mpeg2_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2458 2459	ctx->mpeg2_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2460		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL,2461		V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH, 0,2462		V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH);2463	if (ctx->mpeg2_level_ctrl)2464		ctx->mpeg2_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2465 2466	ctx->mpeg4_profile_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2467		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,2468		V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY, 0,2469		V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY);2470	if (ctx->mpeg4_profile_ctrl)2471		ctx->mpeg4_profile_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2472 2473	ctx->mpeg4_level_ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrls,2474		&coda_ctrl_ops, V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,2475		V4L2_MPEG_VIDEO_MPEG4_LEVEL_5, 0,2476		V4L2_MPEG_VIDEO_MPEG4_LEVEL_5);2477	if (ctx->mpeg4_level_ctrl)2478		ctx->mpeg4_level_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2479}2480 2481static const struct v4l2_ctrl_config coda_mb_err_cnt_ctrl_config = {2482	.id	= V4L2_CID_CODA_MB_ERR_CNT,2483	.name	= "Macroblocks Error Count",2484	.type	= V4L2_CTRL_TYPE_INTEGER,2485	.min	= 0,2486	.max	= 0x7fffffff,2487	.step	= 1,2488};2489 2490static int coda_ctrls_setup(struct coda_ctx *ctx)2491{2492	v4l2_ctrl_handler_init(&ctx->ctrls, 2);2493 2494	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2495		V4L2_CID_HFLIP, 0, 1, 1, 0);2496	v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2497		V4L2_CID_VFLIP, 0, 1, 1, 0);2498	if (ctx->inst_type == CODA_INST_ENCODER) {2499		v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2500				  V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,2501				  1, 1, 1, 1);2502		if (ctx->cvd->dst_formats[0] == V4L2_PIX_FMT_JPEG)2503			coda_jpeg_encode_ctrls(ctx);2504		else2505			coda_encode_ctrls(ctx);2506	} else {2507		v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,2508				  V4L2_CID_MIN_BUFFERS_FOR_CAPTURE,2509				  1, 1, 1, 1);2510		if (ctx->cvd->src_formats[0] == V4L2_PIX_FMT_H264)2511			coda_decode_ctrls(ctx);2512 2513		ctx->mb_err_cnt_ctrl = v4l2_ctrl_new_custom(&ctx->ctrls,2514						&coda_mb_err_cnt_ctrl_config,2515						NULL);2516		if (ctx->mb_err_cnt_ctrl)2517			ctx->mb_err_cnt_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;2518	}2519 2520	if (ctx->ctrls.error) {2521		v4l2_err(&ctx->dev->v4l2_dev,2522			"control initialization error (%d)",2523			ctx->ctrls.error);2524		return -EINVAL;2525	}2526 2527	return v4l2_ctrl_handler_setup(&ctx->ctrls);2528}2529 2530static int coda_queue_init(struct coda_ctx *ctx, struct vb2_queue *vq)2531{2532	vq->drv_priv = ctx;2533	vq->ops = &coda_qops;2534	vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);2535	vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;2536	vq->lock = &ctx->dev->dev_mutex;2537	/* One way to indicate end-of-stream for coda is to set the2538	 * bytesused == 0. However by default videobuf2 handles bytesused2539	 * equal to 0 as a special case and changes its value to the size2540	 * of the buffer. Set the allow_zero_bytesused flag, so2541	 * that videobuf2 will keep the value of bytesused intact.2542	 */2543	vq->allow_zero_bytesused = 1;2544	/*2545	 * We might be fine with no buffers on some of the queues, but that2546	 * would need to be reflected in job_ready(). Currently we expect all2547	 * queues to have at least one buffer queued.2548	 */2549	vq->min_queued_buffers = 1;2550	vq->dev = ctx->dev->dev;2551 2552	return vb2_queue_init(vq);2553}2554 2555int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq,2556			    struct vb2_queue *dst_vq)2557{2558	int ret;2559 2560	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;2561	src_vq->io_modes = VB2_DMABUF | VB2_MMAP;2562	src_vq->mem_ops = &vb2_dma_contig_memops;2563 2564	ret = coda_queue_init(priv, src_vq);2565	if (ret)2566		return ret;2567 2568	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;2569	dst_vq->io_modes = VB2_DMABUF | VB2_MMAP;2570	dst_vq->mem_ops = &vb2_dma_contig_memops;2571 2572	return coda_queue_init(priv, dst_vq);2573}2574 2575int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq,2576			    struct vb2_queue *dst_vq)2577{2578	int ret;2579 2580	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;2581	src_vq->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR;2582	src_vq->mem_ops = &vb2_vmalloc_memops;2583 2584	ret = coda_queue_init(priv, src_vq);2585	if (ret)2586		return ret;2587 2588	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;2589	dst_vq->io_modes = VB2_DMABUF | VB2_MMAP;2590	dst_vq->dma_attrs = DMA_ATTR_NO_KERNEL_MAPPING;2591	dst_vq->mem_ops = &vb2_dma_contig_memops;2592 2593	return coda_queue_init(priv, dst_vq);2594}2595 2596/*2597 * File operations2598 */2599 2600static int coda_open(struct file *file)2601{2602	struct video_device *vdev = video_devdata(file);2603	struct coda_dev *dev = video_get_drvdata(vdev);2604	struct coda_ctx *ctx;2605	unsigned int max = ~0;2606	char *name;2607	int ret;2608	int idx;2609 2610	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);2611	if (!ctx)2612		return -ENOMEM;2613 2614	if (dev->devtype->product == CODA_DX6)2615		max = CODADX6_MAX_INSTANCES - 1;2616	idx = ida_alloc_max(&dev->ida, max, GFP_KERNEL);2617	if (idx < 0) {2618		ret = idx;2619		goto err_coda_max;2620	}2621 2622	name = kasprintf(GFP_KERNEL, "context%d", idx);2623	if (!name) {2624		ret = -ENOMEM;2625		goto err_coda_name_init;2626	}2627 2628	ctx->debugfs_entry = debugfs_create_dir(name, dev->debugfs_root);2629	kfree(name);2630 2631	ctx->cvd = to_coda_video_device(vdev);2632	ctx->inst_type = ctx->cvd->type;2633	ctx->ops = ctx->cvd->ops;2634	ctx->use_bit = !ctx->cvd->direct;2635	init_completion(&ctx->completion);2636	INIT_WORK(&ctx->pic_run_work, coda_pic_run_work);2637	if (ctx->ops->seq_init_work)2638		INIT_WORK(&ctx->seq_init_work, ctx->ops->seq_init_work);2639	if (ctx->ops->seq_end_work)2640		INIT_WORK(&ctx->seq_end_work, ctx->ops->seq_end_work);2641	v4l2_fh_init(&ctx->fh, video_devdata(file));2642	file->private_data = &ctx->fh;2643	v4l2_fh_add(&ctx->fh);2644	ctx->dev = dev;2645	ctx->idx = idx;2646 2647	coda_dbg(1, ctx, "open instance (%p)\n", ctx);2648 2649	switch (dev->devtype->product) {2650	case CODA_960:2651		/*2652		 * Enabling the BWB when decoding can hang the firmware with2653		 * certain streams. The issue was tracked as ENGR00293425 by2654		 * Freescale. As a workaround, disable BWB for all decoders.2655		 * The enable_bwb module parameter allows to override this.2656		 */2657		if (enable_bwb || ctx->inst_type == CODA_INST_ENCODER)2658			ctx->frame_mem_ctrl = CODA9_FRAME_ENABLE_BWB;2659		fallthrough;2660	case CODA_HX4:2661	case CODA_7541:2662		ctx->reg_idx = 0;2663		break;2664	default:2665		ctx->reg_idx = idx;2666	}2667	if (ctx->dev->vdoa && !disable_vdoa) {2668		ctx->vdoa = vdoa_context_create(dev->vdoa);2669		if (!ctx->vdoa)2670			v4l2_warn(&dev->v4l2_dev,2671				  "Failed to create vdoa context: not using vdoa");2672	}2673	ctx->use_vdoa = false;2674 2675	/* Power up and upload firmware if necessary */2676	ret = pm_runtime_resume_and_get(dev->dev);2677	if (ret < 0) {2678		v4l2_err(&dev->v4l2_dev, "failed to power up: %d\n", ret);2679		goto err_pm_get;2680	}2681 2682	ret = clk_prepare_enable(dev->clk_per);2683	if (ret)2684		goto err_clk_enable;2685 2686	ret = clk_prepare_enable(dev->clk_ahb);2687	if (ret)2688		goto err_clk_ahb;2689 2690	set_default_params(ctx);2691	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx,2692					    ctx->ops->queue_init);2693	if (IS_ERR(ctx->fh.m2m_ctx)) {2694		ret = PTR_ERR(ctx->fh.m2m_ctx);2695 2696		v4l2_err(&dev->v4l2_dev, "%s return error (%d)\n",2697			 __func__, ret);2698		goto err_ctx_init;2699	}2700 2701	ret = coda_ctrls_setup(ctx);2702	if (ret) {2703		v4l2_err(&dev->v4l2_dev, "failed to setup coda controls\n");2704		goto err_ctrls_setup;2705	}2706 2707	ctx->fh.ctrl_handler = &ctx->ctrls;2708 2709	mutex_init(&ctx->bitstream_mutex);2710	mutex_init(&ctx->buffer_mutex);2711	mutex_init(&ctx->wakeup_mutex);2712	INIT_LIST_HEAD(&ctx->buffer_meta_list);2713	spin_lock_init(&ctx->buffer_meta_lock);2714 2715	return 0;2716 2717err_ctrls_setup:2718	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);2719err_ctx_init:2720	clk_disable_unprepare(dev->clk_ahb);2721err_clk_ahb:2722	clk_disable_unprepare(dev->clk_per);2723err_clk_enable:2724	pm_runtime_put_sync(dev->dev);2725err_pm_get:2726	v4l2_fh_del(&ctx->fh);2727	v4l2_fh_exit(&ctx->fh);2728err_coda_name_init:2729	ida_free(&dev->ida, ctx->idx);2730err_coda_max:2731	kfree(ctx);2732	return ret;2733}2734 2735static int coda_release(struct file *file)2736{2737	struct coda_dev *dev = video_drvdata(file);2738	struct coda_ctx *ctx = fh_to_ctx(file->private_data);2739 2740	coda_dbg(1, ctx, "release instance (%p)\n", ctx);2741 2742	if (ctx->inst_type == CODA_INST_DECODER && ctx->use_bit)2743		coda_bit_stream_end_flag(ctx);2744 2745	/* If this instance is running, call .job_abort and wait for it to end */2746	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);2747 2748	if (ctx->vdoa)2749		vdoa_context_destroy(ctx->vdoa);2750 2751	/* In case the instance was not running, we still need to call SEQ_END */2752	if (ctx->ops->seq_end_work) {2753		queue_work(dev->workqueue, &ctx->seq_end_work);2754		flush_work(&ctx->seq_end_work);2755	}2756 2757	if (ctx->dev->devtype->product == CODA_DX6)2758		coda_free_aux_buf(dev, &ctx->workbuf);2759 2760	v4l2_ctrl_handler_free(&ctx->ctrls);2761	clk_disable_unprepare(dev->clk_ahb);2762	clk_disable_unprepare(dev->clk_per);2763	pm_runtime_put_sync(dev->dev);2764	v4l2_fh_del(&ctx->fh);2765	v4l2_fh_exit(&ctx->fh);2766	ida_free(&dev->ida, ctx->idx);2767	if (ctx->ops->release)2768		ctx->ops->release(ctx);2769	debugfs_remove_recursive(ctx->debugfs_entry);2770	kfree(ctx);2771 2772	return 0;2773}2774 2775static const struct v4l2_file_operations coda_fops = {2776	.owner		= THIS_MODULE,2777	.open		= coda_open,2778	.release	= coda_release,2779	.poll		= v4l2_m2m_fop_poll,2780	.unlocked_ioctl	= video_ioctl2,2781	.mmap		= v4l2_m2m_fop_mmap,2782};2783 2784static int coda_hw_init(struct coda_dev *dev)2785{2786	u32 data;2787	u16 *p;2788	int i, ret;2789 2790	ret = clk_prepare_enable(dev->clk_per);2791	if (ret)2792		goto err_clk_per;2793 2794	ret = clk_prepare_enable(dev->clk_ahb);2795	if (ret)2796		goto err_clk_ahb;2797 2798	reset_control_reset(dev->rstc);2799 2800	/*2801	 * Copy the first CODA_ISRAM_SIZE in the internal SRAM.2802	 * The 16-bit chars in the code buffer are in memory access2803	 * order, re-sort them to CODA order for register download.2804	 * Data in this SRAM survives a reboot.2805	 */2806	p = (u16 *)dev->codebuf.vaddr;2807	if (dev->devtype->product == CODA_DX6) {2808		for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++)  {2809			data = CODA_DOWN_ADDRESS_SET(i) |2810				CODA_DOWN_DATA_SET(p[i ^ 1]);2811			coda_write(dev, data, CODA_REG_BIT_CODE_DOWN);2812		}2813	} else {2814		for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++) {2815			data = CODA_DOWN_ADDRESS_SET(i) |2816				CODA_DOWN_DATA_SET(p[round_down(i, 4) +2817							3 - (i % 4)]);2818			coda_write(dev, data, CODA_REG_BIT_CODE_DOWN);2819		}2820	}2821 2822	/* Clear registers */2823	for (i = 0; i < 64; i++)2824		coda_write(dev, 0, CODA_REG_BIT_CODE_BUF_ADDR + i * 4);2825 2826	/* Tell the BIT where to find everything it needs */2827	if (dev->devtype->product == CODA_960 ||2828	    dev->devtype->product == CODA_7541 ||2829	    dev->devtype->product == CODA_HX4) {2830		coda_write(dev, dev->tempbuf.paddr,2831				CODA_REG_BIT_TEMP_BUF_ADDR);2832		coda_write(dev, 0, CODA_REG_BIT_BIT_STREAM_PARAM);2833	} else {2834		coda_write(dev, dev->workbuf.paddr,2835			      CODA_REG_BIT_WORK_BUF_ADDR);2836	}2837	coda_write(dev, dev->codebuf.paddr,2838		      CODA_REG_BIT_CODE_BUF_ADDR);2839	coda_write(dev, 0, CODA_REG_BIT_CODE_RUN);2840 2841	/* Set default values */2842	switch (dev->devtype->product) {2843	case CODA_DX6:2844		coda_write(dev, CODADX6_STREAM_BUF_PIC_FLUSH,2845			   CODA_REG_BIT_STREAM_CTRL);2846		break;2847	default:2848		coda_write(dev, CODA7_STREAM_BUF_PIC_FLUSH,2849			   CODA_REG_BIT_STREAM_CTRL);2850	}2851	if (dev->devtype->product == CODA_960)2852		coda_write(dev, CODA9_FRAME_ENABLE_BWB,2853				CODA_REG_BIT_FRAME_MEM_CTRL);2854	else2855		coda_write(dev, 0, CODA_REG_BIT_FRAME_MEM_CTRL);2856 2857	if (dev->devtype->product != CODA_DX6)2858		coda_write(dev, 0, CODA7_REG_BIT_AXI_SRAM_USE);2859 2860	coda_write(dev, CODA_INT_INTERRUPT_ENABLE,2861		      CODA_REG_BIT_INT_ENABLE);2862 2863	/* Reset VPU and start processor */2864	data = coda_read(dev, CODA_REG_BIT_CODE_RESET);2865	data |= CODA_REG_RESET_ENABLE;2866	coda_write(dev, data, CODA_REG_BIT_CODE_RESET);2867	udelay(10);2868	data &= ~CODA_REG_RESET_ENABLE;2869	coda_write(dev, data, CODA_REG_BIT_CODE_RESET);2870	coda_write(dev, CODA_REG_RUN_ENABLE, CODA_REG_BIT_CODE_RUN);2871 2872	clk_disable_unprepare(dev->clk_ahb);2873	clk_disable_unprepare(dev->clk_per);2874 2875	return 0;2876 2877err_clk_ahb:2878	clk_disable_unprepare(dev->clk_per);2879err_clk_per:2880	return ret;2881}2882 2883static int coda_register_device(struct coda_dev *dev, int i)2884{2885	struct video_device *vfd = &dev->vfd[i];2886	const char *name;2887	int ret;2888 2889	if (i >= dev->devtype->num_vdevs)2890		return -EINVAL;2891	name = dev->devtype->vdevs[i]->name;2892 2893	strscpy(vfd->name, dev->devtype->vdevs[i]->name, sizeof(vfd->name));2894	vfd->fops	= &coda_fops;2895	vfd->ioctl_ops	= &coda_ioctl_ops;2896	vfd->release	= video_device_release_empty;2897	vfd->lock	= &dev->dev_mutex;2898	vfd->v4l2_dev	= &dev->v4l2_dev;2899	vfd->vfl_dir	= VFL_DIR_M2M;2900	vfd->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;2901	video_set_drvdata(vfd, dev);2902 2903	/* Not applicable, use the selection API instead */2904	v4l2_disable_ioctl(vfd, VIDIOC_CROPCAP);2905	v4l2_disable_ioctl(vfd, VIDIOC_G_CROP);2906	v4l2_disable_ioctl(vfd, VIDIOC_S_CROP);2907 2908	if (dev->devtype->vdevs[i]->type == CODA_INST_ENCODER) {2909		v4l2_disable_ioctl(vfd, VIDIOC_DECODER_CMD);2910		v4l2_disable_ioctl(vfd, VIDIOC_TRY_DECODER_CMD);2911		if (dev->devtype->vdevs[i]->dst_formats[0] == V4L2_PIX_FMT_JPEG) {2912			v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMEINTERVALS);2913			v4l2_disable_ioctl(vfd, VIDIOC_G_PARM);2914			v4l2_disable_ioctl(vfd, VIDIOC_S_PARM);2915		}2916	} else {2917		v4l2_disable_ioctl(vfd, VIDIOC_ENCODER_CMD);2918		v4l2_disable_ioctl(vfd, VIDIOC_TRY_ENCODER_CMD);2919		v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMESIZES);2920		v4l2_disable_ioctl(vfd, VIDIOC_ENUM_FRAMEINTERVALS);2921		v4l2_disable_ioctl(vfd, VIDIOC_G_PARM);2922		v4l2_disable_ioctl(vfd, VIDIOC_S_PARM);2923	}2924 2925	ret = video_register_device(vfd, VFL_TYPE_VIDEO, 0);2926	if (!ret)2927		v4l2_info(&dev->v4l2_dev, "%s registered as %s\n",2928			  name, video_device_node_name(vfd));2929	return ret;2930}2931 2932static void coda_copy_firmware(struct coda_dev *dev, const u8 * const buf,2933			       size_t size)2934{2935	u32 *src = (u32 *)buf;2936 2937	/* Check if the firmware has a 16-byte Freescale header, skip it */2938	if (buf[0] == 'M' && buf[1] == 'X')2939		src += 4;2940	/*2941	 * Check whether the firmware is in native order or pre-reordered for2942	 * memory access. The first instruction opcode always is 0xe40e.2943	 */2944	if (__le16_to_cpup((__le16 *)src) == 0xe40e) {2945		u32 *dst = dev->codebuf.vaddr;2946		int i;2947 2948		/* Firmware in native order, reorder while copying */2949		if (dev->devtype->product == CODA_DX6) {2950			for (i = 0; i < (size - 16) / 4; i++)2951				dst[i] = (src[i] << 16) | (src[i] >> 16);2952		} else {2953			for (i = 0; i < (size - 16) / 4; i += 2) {2954				dst[i] = (src[i + 1] << 16) | (src[i + 1] >> 16);2955				dst[i + 1] = (src[i] << 16) | (src[i] >> 16);2956			}2957		}2958	} else {2959		/* Copy the already reordered firmware image */2960		memcpy(dev->codebuf.vaddr, src, size);2961	}2962}2963 2964static void coda_fw_callback(const struct firmware *fw, void *context);2965 2966static int coda_firmware_request(struct coda_dev *dev)2967{2968	char *fw;2969 2970	if (dev->firmware >= ARRAY_SIZE(dev->devtype->firmware))2971		return -EINVAL;2972 2973	fw = dev->devtype->firmware[dev->firmware];2974 2975	dev_dbg(dev->dev, "requesting firmware '%s' for %s\n", fw,2976		coda_product_name(dev->devtype->product));2977 2978	return request_firmware_nowait(THIS_MODULE, true, fw, dev->dev,2979				       GFP_KERNEL, dev, coda_fw_callback);2980}2981 2982static void coda_fw_callback(const struct firmware *fw, void *context)2983{2984	struct coda_dev *dev = context;2985	int i, ret;2986 2987	if (!fw) {2988		dev->firmware++;2989		ret = coda_firmware_request(dev);2990		if (ret < 0) {2991			v4l2_err(&dev->v4l2_dev, "firmware request failed\n");2992			goto put_pm;2993		}2994		return;2995	}2996	if (dev->firmware > 0) {2997		/*2998		 * Since we can't suppress warnings for failed asynchronous2999		 * firmware requests, report that the fallback firmware was3000		 * found.3001		 */3002		dev_info(dev->dev, "Using fallback firmware %s\n",3003			 dev->devtype->firmware[dev->firmware]);3004	}3005 3006	/* allocate auxiliary per-device code buffer for the BIT processor */3007	ret = coda_alloc_aux_buf(dev, &dev->codebuf, fw->size, "codebuf",3008				 dev->debugfs_root);3009	if (ret < 0)3010		goto put_pm;3011 3012	coda_copy_firmware(dev, fw->data, fw->size);3013	release_firmware(fw);3014 3015	ret = coda_hw_init(dev);3016	if (ret < 0) {3017		v4l2_err(&dev->v4l2_dev, "HW initialization failed\n");3018		goto put_pm;3019	}3020 3021	ret = coda_check_firmware(dev);3022	if (ret < 0)3023		goto put_pm;3024 3025	dev->m2m_dev = v4l2_m2m_init(&coda_m2m_ops);3026	if (IS_ERR(dev->m2m_dev)) {3027		v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");3028		goto put_pm;3029	}3030 3031	for (i = 0; i < dev->devtype->num_vdevs; i++) {3032		ret = coda_register_device(dev, i);3033		if (ret) {3034			v4l2_err(&dev->v4l2_dev,3035				 "Failed to register %s video device: %d\n",3036				 dev->devtype->vdevs[i]->name, ret);3037			goto rel_vfd;3038		}3039	}3040 3041	pm_runtime_put_sync(dev->dev);3042	return;3043 3044rel_vfd:3045	while (--i >= 0)3046		video_unregister_device(&dev->vfd[i]);3047	v4l2_m2m_release(dev->m2m_dev);3048put_pm:3049	pm_runtime_put_sync(dev->dev);3050}3051 3052enum coda_platform {3053	CODA_IMX27,3054	CODA_IMX51,3055	CODA_IMX53,3056	CODA_IMX6Q,3057	CODA_IMX6DL,3058};3059 3060static const struct coda_devtype coda_devdata[] = {3061	[CODA_IMX27] = {3062		.firmware     = {3063			"vpu_fw_imx27_TO2.bin",3064			"vpu/vpu_fw_imx27_TO2.bin",3065			"v4l-codadx6-imx27.bin"3066		},3067		.product      = CODA_DX6,3068		.codecs       = codadx6_codecs,3069		.num_codecs   = ARRAY_SIZE(codadx6_codecs),3070		.vdevs        = codadx6_video_devices,3071		.num_vdevs    = ARRAY_SIZE(codadx6_video_devices),3072		.workbuf_size = 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE * 8 * 1024,3073		.iram_size    = 0xb000,3074	},3075	[CODA_IMX51] = {3076		.firmware     = {3077			"vpu_fw_imx51.bin",3078			"vpu/vpu_fw_imx51.bin",3079			"v4l-codahx4-imx51.bin"3080		},3081		.product      = CODA_HX4,3082		.codecs       = codahx4_codecs,3083		.num_codecs   = ARRAY_SIZE(codahx4_codecs),3084		.vdevs        = codahx4_video_devices,3085		.num_vdevs    = ARRAY_SIZE(codahx4_video_devices),3086		.workbuf_size = 128 * 1024,3087		.tempbuf_size = 304 * 1024,3088		.iram_size    = 0x14000,3089	},3090	[CODA_IMX53] = {3091		.firmware     = {3092			"vpu_fw_imx53.bin",3093			"vpu/vpu_fw_imx53.bin",3094			"v4l-coda7541-imx53.bin"3095		},3096		.product      = CODA_7541,3097		.codecs       = coda7_codecs,3098		.num_codecs   = ARRAY_SIZE(coda7_codecs),3099		.vdevs        = coda7_video_devices,3100		.num_vdevs    = ARRAY_SIZE(coda7_video_devices),3101		.workbuf_size = 128 * 1024,3102		.tempbuf_size = 304 * 1024,3103		.iram_size    = 0x14000,3104	},3105	[CODA_IMX6Q] = {3106		.firmware     = {3107			"vpu_fw_imx6q.bin",3108			"vpu/vpu_fw_imx6q.bin",3109			"v4l-coda960-imx6q.bin"3110		},3111		.product      = CODA_960,3112		.codecs       = coda9_codecs,3113		.num_codecs   = ARRAY_SIZE(coda9_codecs),3114		.vdevs        = coda9_video_devices,3115		.num_vdevs    = ARRAY_SIZE(coda9_video_devices),3116		.workbuf_size = 80 * 1024,3117		.tempbuf_size = 204 * 1024,3118		.iram_size    = 0x21000,3119	},3120	[CODA_IMX6DL] = {3121		.firmware     = {3122			"vpu_fw_imx6d.bin",3123			"vpu/vpu_fw_imx6d.bin",3124			"v4l-coda960-imx6dl.bin"3125		},3126		.product      = CODA_960,3127		.codecs       = coda9_codecs,3128		.num_codecs   = ARRAY_SIZE(coda9_codecs),3129		.vdevs        = coda9_video_devices,3130		.num_vdevs    = ARRAY_SIZE(coda9_video_devices),3131		.workbuf_size = 80 * 1024,3132		.tempbuf_size = 204 * 1024,3133		.iram_size    = 0x1f000, /* leave 4k for suspend code */3134	},3135};3136 3137static const struct of_device_id coda_dt_ids[] = {3138	{ .compatible = "fsl,imx27-vpu", .data = &coda_devdata[CODA_IMX27] },3139	{ .compatible = "fsl,imx51-vpu", .data = &coda_devdata[CODA_IMX51] },3140	{ .compatible = "fsl,imx53-vpu", .data = &coda_devdata[CODA_IMX53] },3141	{ .compatible = "fsl,imx6q-vpu", .data = &coda_devdata[CODA_IMX6Q] },3142	{ .compatible = "fsl,imx6dl-vpu", .data = &coda_devdata[CODA_IMX6DL] },3143	{ /* sentinel */ }3144};3145MODULE_DEVICE_TABLE(of, coda_dt_ids);3146 3147static int coda_probe(struct platform_device *pdev)3148{3149	struct device_node *np = pdev->dev.of_node;3150	struct gen_pool *pool;3151	struct coda_dev *dev;3152	int ret, irq;3153 3154	dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);3155	if (!dev)3156		return -ENOMEM;3157 3158	dev->devtype = of_device_get_match_data(&pdev->dev);3159 3160	dev->dev = &pdev->dev;3161	dev->clk_per = devm_clk_get(&pdev->dev, "per");3162	if (IS_ERR(dev->clk_per)) {3163		dev_err(&pdev->dev, "Could not get per clock\n");3164		return PTR_ERR(dev->clk_per);3165	}3166 3167	dev->clk_ahb = devm_clk_get(&pdev->dev, "ahb");3168	if (IS_ERR(dev->clk_ahb)) {3169		dev_err(&pdev->dev, "Could not get ahb clock\n");3170		return PTR_ERR(dev->clk_ahb);3171	}3172 3173	/* Get  memory for physical registers */3174	dev->regs_base = devm_platform_ioremap_resource(pdev, 0);3175	if (IS_ERR(dev->regs_base))3176		return PTR_ERR(dev->regs_base);3177 3178	/* IRQ */3179	irq = platform_get_irq_byname(pdev, "bit");3180	if (irq < 0)3181		irq = platform_get_irq(pdev, 0);3182	if (irq < 0)3183		return irq;3184 3185	ret = devm_request_irq(&pdev->dev, irq, coda_irq_handler, 0,3186			       CODA_NAME "-video", dev);3187	if (ret < 0) {3188		dev_err(&pdev->dev, "failed to request irq: %d\n", ret);3189		return ret;3190	}3191 3192	/* JPEG IRQ */3193	if (dev->devtype->product == CODA_960) {3194		irq = platform_get_irq_byname(pdev, "jpeg");3195		if (irq < 0)3196			return irq;3197 3198		ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,3199						coda9_jpeg_irq_handler,3200						IRQF_ONESHOT, CODA_NAME "-jpeg",3201						dev);3202		if (ret < 0) {3203			dev_err(&pdev->dev, "failed to request jpeg irq\n");3204			return ret;3205		}3206	}3207 3208	dev->rstc = devm_reset_control_get_optional_exclusive(&pdev->dev,3209							      NULL);3210	if (IS_ERR(dev->rstc)) {3211		ret = PTR_ERR(dev->rstc);3212		dev_err(&pdev->dev, "failed get reset control: %d\n", ret);3213		return ret;3214	}3215 3216	/* Get IRAM pool from device tree */3217	pool = of_gen_pool_get(np, "iram", 0);3218	if (!pool) {3219		dev_err(&pdev->dev, "iram pool not available\n");3220		return -ENOMEM;3221	}3222	dev->iram_pool = pool;3223 3224	/* Get vdoa_data if supported by the platform */3225	dev->vdoa = coda_get_vdoa_data();3226	if (PTR_ERR(dev->vdoa) == -EPROBE_DEFER)3227		return -EPROBE_DEFER;3228 3229	ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);3230	if (ret)3231		return ret;3232 3233	ratelimit_default_init(&dev->mb_err_rs);3234	mutex_init(&dev->dev_mutex);3235	mutex_init(&dev->coda_mutex);3236	ida_init(&dev->ida);3237 3238	dev->debugfs_root = debugfs_create_dir("coda", NULL);3239 3240	/* allocate auxiliary per-device buffers for the BIT processor */3241	if (dev->devtype->product == CODA_DX6) {3242		ret = coda_alloc_aux_buf(dev, &dev->workbuf,3243					 dev->devtype->workbuf_size, "workbuf",3244					 dev->debugfs_root);3245		if (ret < 0)3246			goto err_v4l2_register;3247	}3248 3249	if (dev->devtype->tempbuf_size) {3250		ret = coda_alloc_aux_buf(dev, &dev->tempbuf,3251					 dev->devtype->tempbuf_size, "tempbuf",3252					 dev->debugfs_root);3253		if (ret < 0)3254			goto err_v4l2_register;3255	}3256 3257	dev->iram.size = dev->devtype->iram_size;3258	dev->iram.vaddr = gen_pool_dma_alloc(dev->iram_pool, dev->iram.size,3259					     &dev->iram.paddr);3260	if (!dev->iram.vaddr) {3261		dev_warn(&pdev->dev, "unable to alloc iram\n");3262	} else {3263		memset(dev->iram.vaddr, 0, dev->iram.size);3264		dev->iram.blob.data = dev->iram.vaddr;3265		dev->iram.blob.size = dev->iram.size;3266		dev->iram.dentry = debugfs_create_blob("iram", 0444,3267						       dev->debugfs_root,3268						       &dev->iram.blob);3269	}3270 3271	dev->workqueue = alloc_ordered_workqueue("coda", WQ_MEM_RECLAIM);3272	if (!dev->workqueue) {3273		dev_err(&pdev->dev, "unable to alloc workqueue\n");3274		ret = -ENOMEM;3275		goto err_v4l2_register;3276	}3277 3278	platform_set_drvdata(pdev, dev);3279 3280	/*3281	 * Start activated so we can directly call coda_hw_init in3282	 * coda_fw_callback regardless of whether CONFIG_PM is3283	 * enabled or whether the device is associated with a PM domain.3284	 */3285	pm_runtime_get_noresume(&pdev->dev);3286	pm_runtime_set_active(&pdev->dev);3287	pm_runtime_enable(&pdev->dev);3288 3289	ret = coda_firmware_request(dev);3290	if (ret)3291		goto err_alloc_workqueue;3292	return 0;3293 3294err_alloc_workqueue:3295	pm_runtime_disable(&pdev->dev);3296	pm_runtime_put_noidle(&pdev->dev);3297	destroy_workqueue(dev->workqueue);3298err_v4l2_register:3299	v4l2_device_unregister(&dev->v4l2_dev);3300	return ret;3301}3302 3303static void coda_remove(struct platform_device *pdev)3304{3305	struct coda_dev *dev = platform_get_drvdata(pdev);3306	int i;3307 3308	for (i = 0; i < ARRAY_SIZE(dev->vfd); i++) {3309		if (video_get_drvdata(&dev->vfd[i]))3310			video_unregister_device(&dev->vfd[i]);3311	}3312	if (dev->m2m_dev)3313		v4l2_m2m_release(dev->m2m_dev);3314	pm_runtime_disable(&pdev->dev);3315	v4l2_device_unregister(&dev->v4l2_dev);3316	destroy_workqueue(dev->workqueue);3317	if (dev->iram.vaddr)3318		gen_pool_free(dev->iram_pool, (unsigned long)dev->iram.vaddr,3319			      dev->iram.size);3320	coda_free_aux_buf(dev, &dev->codebuf);3321	coda_free_aux_buf(dev, &dev->tempbuf);3322	coda_free_aux_buf(dev, &dev->workbuf);3323	debugfs_remove_recursive(dev->debugfs_root);3324	ida_destroy(&dev->ida);3325}3326 3327#ifdef CONFIG_PM3328static int coda_runtime_resume(struct device *dev)3329{3330	struct coda_dev *cdev = dev_get_drvdata(dev);3331	int ret = 0;3332 3333	if (dev->pm_domain && cdev->codebuf.vaddr) {3334		ret = coda_hw_init(cdev);3335		if (ret)3336			v4l2_err(&cdev->v4l2_dev, "HW initialization failed\n");3337	}3338 3339	return ret;3340}3341#endif3342 3343static const struct dev_pm_ops coda_pm_ops = {3344	SET_RUNTIME_PM_OPS(NULL, coda_runtime_resume, NULL)3345};3346 3347static struct platform_driver coda_driver = {3348	.probe	= coda_probe,3349	.remove_new = coda_remove,3350	.driver	= {3351		.name	= CODA_NAME,3352		.of_match_table = coda_dt_ids,3353		.pm	= &coda_pm_ops,3354	},3355};3356 3357module_platform_driver(coda_driver);3358 3359MODULE_LICENSE("GPL");3360MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");3361MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");3362