Re: [PATCH v4 2/8] [media] stm32-dcmi: STM32 DCMI camera interface driver

[Hans Verkuil]

Hi Hugues,

I found a few small things that should be fixed first. It should all be
easy and quick to fix.

On 04/20/17 18:07, Hugues Fruchet wrote:
> This V4L2 subdev driver enables Digital Camera Memory Interface (DCMI)
> of STMicroelectronics STM32 SoC series.
> 
> Reviewed-by: Hans Verkuil <hans.verkuil@xxxxxxxxx>
> Signed-off-by: Yannick Fertre <yannick.fertre@xxxxxx>
> Signed-off-by: Hugues Fruchet <hugues.fruchet@xxxxxx>
> ---
>  drivers/media/platform/Kconfig            |   12 +
>  drivers/media/platform/Makefile           |    2 +
>  drivers/media/platform/stm32/Makefile     |    1 +
>  drivers/media/platform/stm32/stm32-dcmi.c | 1419 +++++++++++++++++++++++++++++
>  4 files changed, 1434 insertions(+)
>  create mode 100644 drivers/media/platform/stm32/Makefile
>  create mode 100644 drivers/media/platform/stm32/stm32-dcmi.c
> 

> diff --git a/drivers/media/platform/stm32/stm32-dcmi.c b/drivers/media/platform/stm32/stm32-dcmi.c
> new file mode 100644
> index 0000000..0ed3bd9
> --- /dev/null
> +++ b/drivers/media/platform/stm32/stm32-dcmi.c
> @@ -0,0 +1,1419 @@

...

> +static int dcmi_start_streaming(struct vb2_queue *vq, unsigned int count)
> +{
> +	struct stm32_dcmi *dcmi = vb2_get_drv_priv(vq);
> +	struct dcmi_buf *buf, *node;
> +	u32 val;
> +	int ret;
> +
> +	/* Enable stream on the sub device */
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, video, s_stream, 1);
> +	if (ret && ret != -ENOIOCTLCMD) {
> +		dev_err(dcmi->dev, "%s: Failed to start streaming, subdev streamon error",
> +			__func__);
> +		goto err_release_buffers;
> +	}
> +
> +	if (clk_enable(dcmi->mclk)) {
> +		dev_err(dcmi->dev, "%s: Failed to start streaming, cannot enable clock",
> +			__func__);
> +		goto err_subdev_streamoff;
> +	}

It feels more natural to me to first enable the clock, then call s_stream.

It seems what stop_streaming expects as well, since that disables the clock last,
so here you would expect to see the opposite: the clock is enabled first.

> +
> +	spin_lock_irq(&dcmi->irqlock);
> +
> +	val = reg_read(dcmi->regs, DCMI_CR);
> +
> +	val &= ~(CR_PCKPOL | CR_HSPOL | CR_VSPOL |
> +		 CR_EDM_0 | CR_EDM_1 | CR_FCRC_0 |
> +		 CR_FCRC_1 | CR_JPEG | CR_ESS);
> +
> +	/* Set bus width */
> +	switch (dcmi->bus.bus_width) {
> +	case 14:
> +		val &= CR_EDM_0 + CR_EDM_1;
> +		break;
> +	case 12:
> +		val &= CR_EDM_1;
> +		break;
> +	case 10:
> +		val &= CR_EDM_0;
> +		break;
> +	default:
> +		/* Set bus width to 8 bits by default */
> +		break;
> +	}
> +
> +	/* Set vertical synchronization polarity */
> +	if (dcmi->bus.flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
> +		val |= CR_VSPOL;
> +
> +	/* Set horizontal synchronization polarity */
> +	if (dcmi->bus.flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH)
> +		val |= CR_HSPOL;
> +
> +	/* Set pixel clock polarity */
> +	if (dcmi->bus.flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
> +		val |= CR_PCKPOL;
> +
> +	reg_write(dcmi->regs, DCMI_CR, val);
> +
> +	/* Enable dcmi */
> +	reg_set(dcmi->regs, DCMI_CR, CR_ENABLE);
> +
> +	dcmi->state = RUNNING;
> +
> +	dcmi->sequence = 0;
> +	dcmi->errors_count = 0;
> +	dcmi->buffers_count = 0;
> +	dcmi->active = NULL;
> +
> +	/*
> +	 * Start transfer if at least one buffer has been queued,
> +	 * otherwise transfer is defered at buffer queueing

typo: defered -> deferred

> +	 */
> +	if (list_empty(&dcmi->buffers)) {
> +		dev_dbg(dcmi->dev, "Start streaming is defered to next buffer queueing\n");

ditto (do a search & replace)

> +		spin_unlock_irq(&dcmi->irqlock);
> +		return 0;
> +	}
> +
> +	dcmi->active = list_entry(dcmi->buffers.next, struct dcmi_buf, list);
> +	list_del_init(&dcmi->active->list);
> +
> +	dev_dbg(dcmi->dev, "Start streaming, starting capture\n");
> +
> +	ret = dcmi_start_capture(dcmi);
> +	if (ret) {
> +		dev_err(dcmi->dev, "%s: Start streaming failed, cannot start capture",
> +			__func__);
> +
> +		spin_unlock_irq(&dcmi->irqlock);

The clock isn't disabled in this error path.

> +		goto err_subdev_streamoff;
> +	}
> +
> +	/* Enable interruptions */
> +	reg_set(dcmi->regs, DCMI_IER, IT_FRAME | IT_OVR | IT_ERR);
> +
> +	spin_unlock_irq(&dcmi->irqlock);
> +
> +	return 0;
> +
> +err_subdev_streamoff:
> +	v4l2_subdev_call(dcmi->entity.subdev, video, s_stream, 0);
> +
> +err_release_buffers:
> +	spin_lock_irq(&dcmi->irqlock);
> +	/*
> +	 * Return all buffers to vb2 in QUEUED state.
> +	 * This will give ownership back to userspace
> +	 */
> +	if (dcmi->active) {
> +		buf = dcmi->active;
> +		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED);
> +		dcmi->active = NULL;
> +	}
> +	list_for_each_entry_safe(buf, node, &dcmi->buffers, list) {
> +		list_del_init(&buf->list);
> +		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED);
> +	}
> +	spin_unlock_irq(&dcmi->irqlock);
> +
> +	return ret;
> +}
> +
> +static void dcmi_stop_streaming(struct vb2_queue *vq)
> +{
> +	struct stm32_dcmi *dcmi = vb2_get_drv_priv(vq);
> +	struct dcmi_buf *buf, *node;
> +	unsigned long time_ms = msecs_to_jiffies(TIMEOUT_MS);
> +	long timeout;
> +	int ret;
> +
> +	/* Disable stream on the sub device */
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, video, s_stream, 0);
> +	if (ret && ret != -ENOIOCTLCMD)
> +		dev_err(dcmi->dev, "stream off failed in subdev\n");
> +
> +	dcmi->state = STOPPING;
> +
> +	timeout = wait_for_completion_interruptible_timeout(&dcmi->complete,
> +							    time_ms);
> +
> +	spin_lock_irq(&dcmi->irqlock);
> +
> +	/* Disable interruptions */
> +	reg_clear(dcmi->regs, DCMI_IER, IT_FRAME | IT_OVR | IT_ERR);
> +
> +	/* Disable DCMI */
> +	reg_clear(dcmi->regs, DCMI_CR, CR_ENABLE);
> +
> +	if (!timeout) {
> +		dev_err(dcmi->dev, "Timeout during stop streaming\n");
> +		dcmi->state = STOPPED;
> +	}
> +
> +	/* Return all queued buffers to vb2 in ERROR state */
> +	if (dcmi->active) {
> +		buf = dcmi->active;
> +		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
> +		dcmi->active = NULL;
> +	}
> +	list_for_each_entry_safe(buf, node, &dcmi->buffers, list) {
> +		list_del_init(&buf->list);
> +		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
> +	}
> +
> +	spin_unlock_irq(&dcmi->irqlock);
> +
> +	/* Stop all pending DMA operations */
> +	dmaengine_terminate_all(dcmi->dma_chan);
> +
> +	clk_disable(dcmi->mclk);
> +
> +	dev_dbg(dcmi->dev, "Stop streaming, errors=%d buffers=%d\n",
> +		dcmi->errors_count, dcmi->buffers_count);
> +}
> +
> +static struct vb2_ops dcmi_video_qops = {
> +	.queue_setup		= dcmi_queue_setup,
> +	.buf_init		= dcmi_buf_init,
> +	.buf_prepare		= dcmi_buf_prepare,
> +	.buf_queue		= dcmi_buf_queue,
> +	.start_streaming	= dcmi_start_streaming,
> +	.stop_streaming		= dcmi_stop_streaming,
> +	.wait_prepare		= vb2_ops_wait_prepare,
> +	.wait_finish		= vb2_ops_wait_finish,
> +};
> +
> +static int dcmi_g_fmt_vid_cap(struct file *file, void *priv,
> +			      struct v4l2_format *fmt)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +
> +	*fmt = dcmi->fmt;
> +
> +	return 0;
> +}
> +
> +static const struct dcmi_format *find_format_by_fourcc(struct stm32_dcmi *dcmi,
> +						       unsigned int fourcc)
> +{
> +	unsigned int num_formats = dcmi->num_user_formats;
> +	const struct dcmi_format *fmt;
> +	unsigned int i;
> +
> +	for (i = 0; i < num_formats; i++) {
> +		fmt = dcmi->user_formats[i];
> +		if (fmt->fourcc == fourcc)
> +			return fmt;
> +	}
> +
> +	return NULL;
> +}
> +
> +static int dcmi_try_fmt(struct stm32_dcmi *dcmi, struct v4l2_format *f,
> +			const struct dcmi_format **current_fmt)
> +{
> +	const struct dcmi_format *dcmi_fmt;
> +	struct v4l2_pix_format *pixfmt = &f->fmt.pix;
> +	struct v4l2_subdev_pad_config pad_cfg;
> +	struct v4l2_subdev_format format = {
> +		.which = V4L2_SUBDEV_FORMAT_TRY,
> +	};
> +	int ret;
> +
> +	if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
> +		return -EINVAL;

This test is not needed, the v4l2 core tests for this already.

> +
> +	dcmi_fmt = find_format_by_fourcc(dcmi, pixfmt->pixelformat);
> +	if (!dcmi_fmt) {
> +		dcmi_fmt = dcmi->user_formats[dcmi->num_user_formats - 1];
> +		pixfmt->pixelformat = dcmi_fmt->fourcc;
> +	}
> +
> +	/* Limit to hardware capabilities */
> +	if (pixfmt->width > MAX_SUPPORT_WIDTH)
> +		pixfmt->width = MAX_SUPPORT_WIDTH;
> +	if (pixfmt->height > MAX_SUPPORT_HEIGHT)
> +		pixfmt->height = MAX_SUPPORT_HEIGHT;
> +	if (pixfmt->width < MIN_SUPPORT_WIDTH)
> +		pixfmt->width = MIN_SUPPORT_WIDTH;
> +	if (pixfmt->height < MIN_SUPPORT_HEIGHT)
> +		pixfmt->height = MIN_SUPPORT_HEIGHT;

I suggest using the clamp macro here.

> +
> +	v4l2_fill_mbus_format(&format.format, pixfmt, dcmi_fmt->mbus_code);
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, pad, set_fmt,
> +			       &pad_cfg, &format);
> +	if (ret < 0)
> +		return ret;
> +
> +	v4l2_fill_pix_format(pixfmt, &format.format);
> +
> +	pixfmt->field = V4L2_FIELD_NONE;
> +	pixfmt->bytesperline = pixfmt->width * dcmi_fmt->bpp;
> +	pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height;
> +
> +	if (current_fmt)
> +		*current_fmt = dcmi_fmt;
> +
> +	return 0;
> +}
> +
> +static int dcmi_set_fmt(struct stm32_dcmi *dcmi, struct v4l2_format *f)
> +{
> +	struct v4l2_subdev_format format = {
> +		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
> +	};
> +	const struct dcmi_format *current_fmt;
> +	int ret;
> +
> +	ret = dcmi_try_fmt(dcmi, f, &current_fmt);
> +	if (ret)
> +		return ret;
> +
> +	v4l2_fill_mbus_format(&format.format, &f->fmt.pix,
> +			      current_fmt->mbus_code);
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, pad,
> +			       set_fmt, NULL, &format);
> +	if (ret < 0)
> +		return ret;
> +
> +	dcmi->fmt = *f;
> +	dcmi->current_fmt = current_fmt;
> +
> +	return 0;
> +}
> +
> +static int dcmi_s_fmt_vid_cap(struct file *file, void *priv,
> +			      struct v4l2_format *f)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +
> +	if (vb2_is_streaming(&dcmi->queue))
> +		return -EBUSY;
> +
> +	return dcmi_set_fmt(dcmi, f);
> +}
> +
> +static int dcmi_try_fmt_vid_cap(struct file *file, void *priv,
> +				struct v4l2_format *f)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +
> +	return dcmi_try_fmt(dcmi, f, NULL);
> +}
> +
> +static int dcmi_enum_fmt_vid_cap(struct file *file, void  *priv,
> +				 struct v4l2_fmtdesc *f)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +
> +	if (f->index >= dcmi->num_user_formats)
> +		return -EINVAL;
> +
> +	f->pixelformat = dcmi->user_formats[f->index]->fourcc;
> +	return 0;
> +}
> +
> +static int dcmi_querycap(struct file *file, void *priv,
> +			 struct v4l2_capability *cap)
> +{
> +	strlcpy(cap->driver, DRV_NAME, sizeof(cap->driver));
> +	strlcpy(cap->card, "STM32 Digital Camera Memory Interface",
> +		sizeof(cap->card));

I don't think this fits in cap->card.

> +	strlcpy(cap->bus_info, "platform:dcmi", sizeof(cap->bus_info));
> +	return 0;
> +}
> +
> +static int dcmi_enum_input(struct file *file, void *priv,
> +			   struct v4l2_input *i)
> +{
> +	if (i->index != 0)
> +		return -EINVAL;
> +
> +	i->type = V4L2_INPUT_TYPE_CAMERA;
> +	strlcpy(i->name, "Camera", sizeof(i->name));
> +	return 0;
> +}
> +
> +static int dcmi_g_input(struct file *file, void *priv, unsigned int *i)
> +{
> +	*i = 0;
> +	return 0;
> +}
> +
> +static int dcmi_s_input(struct file *file, void *priv, unsigned int i)
> +{
> +	if (i > 0)
> +		return -EINVAL;
> +	return 0;
> +}
> +
> +static int dcmi_enum_framesizes(struct file *file, void *fh,
> +				struct v4l2_frmsizeenum *fsize)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +	const struct dcmi_format *dcmi_fmt;
> +	struct v4l2_subdev_frame_size_enum fse = {
> +		.index = fsize->index,
> +		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
> +	};
> +	int ret;
> +
> +	dcmi_fmt = find_format_by_fourcc(dcmi, fsize->pixel_format);
> +	if (!dcmi_fmt)
> +		return -EINVAL;
> +
> +	fse.code = dcmi_fmt->mbus_code;
> +
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, pad, enum_frame_size,
> +			       NULL, &fse);
> +	if (ret)
> +		return ret;
> +
> +	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
> +	fsize->discrete.width = fse.max_width;
> +	fsize->discrete.height = fse.max_height;
> +
> +	return 0;
> +}
> +
> +static int dcmi_enum_frameintervals(struct file *file, void *fh,
> +				    struct v4l2_frmivalenum *fival)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +	const struct dcmi_format *dcmi_fmt;
> +	struct v4l2_subdev_frame_interval_enum fie = {
> +		.index = fival->index,
> +		.width = fival->width,
> +		.height = fival->height,
> +		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
> +	};
> +	int ret;
> +
> +	dcmi_fmt = find_format_by_fourcc(dcmi, fival->pixel_format);
> +	if (!dcmi_fmt)
> +		return -EINVAL;
> +
> +	fie.code = dcmi_fmt->mbus_code;
> +
> +	ret = v4l2_subdev_call(dcmi->entity.subdev, pad,
> +			       enum_frame_interval, NULL, &fie);
> +	if (ret)
> +		return ret;
> +
> +	fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
> +	fival->discrete = fie.interval;
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id stm32_dcmi_of_match[] = {
> +	{ .compatible = "st,stm32-dcmi"},
> +	{ /* end node */ },
> +};
> +MODULE_DEVICE_TABLE(of, stm32_dcmi_of_match);
> +
> +static int dcmi_open(struct file *file)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +	struct v4l2_subdev *sd = dcmi->entity.subdev;
> +	int ret;
> +
> +	if (mutex_lock_interruptible(&dcmi->lock))
> +		return -ERESTARTSYS;
> +
> +	ret = v4l2_fh_open(file);
> +	if (ret < 0)
> +		goto unlock;
> +
> +	if (!v4l2_fh_is_singular_file(file))
> +		goto fh_rel;
> +
> +	ret = v4l2_subdev_call(sd, core, s_power, 1);
> +	if (ret < 0 && ret != -ENOIOCTLCMD)
> +		goto fh_rel;
> +
> +	ret = dcmi_set_fmt(dcmi, &dcmi->fmt);
> +	if (ret)
> +		v4l2_subdev_call(sd, core, s_power, 0);
> +fh_rel:
> +	if (ret)
> +		v4l2_fh_release(file);
> +unlock:
> +	mutex_unlock(&dcmi->lock);
> +	return ret;
> +}
> +
> +static int dcmi_release(struct file *file)
> +{
> +	struct stm32_dcmi *dcmi = video_drvdata(file);
> +	struct v4l2_subdev *sd = dcmi->entity.subdev;
> +	bool fh_singular;
> +	int ret;
> +
> +	mutex_lock(&dcmi->lock);
> +
> +	fh_singular = v4l2_fh_is_singular_file(file);
> +
> +	ret = _vb2_fop_release(file, NULL);
> +
> +	if (fh_singular)
> +		v4l2_subdev_call(sd, core, s_power, 0);
> +
> +	mutex_unlock(&dcmi->lock);
> +
> +	return ret;
> +}
> +
> +static const struct v4l2_ioctl_ops dcmi_ioctl_ops = {
> +	.vidioc_querycap		= dcmi_querycap,
> +
> +	.vidioc_try_fmt_vid_cap		= dcmi_try_fmt_vid_cap,
> +	.vidioc_g_fmt_vid_cap		= dcmi_g_fmt_vid_cap,
> +	.vidioc_s_fmt_vid_cap		= dcmi_s_fmt_vid_cap,
> +	.vidioc_enum_fmt_vid_cap	= dcmi_enum_fmt_vid_cap,
> +
> +	.vidioc_enum_input		= dcmi_enum_input,
> +	.vidioc_g_input			= dcmi_g_input,
> +	.vidioc_s_input			= dcmi_s_input,
> +
> +	.vidioc_enum_framesizes		= dcmi_enum_framesizes,
> +	.vidioc_enum_frameintervals	= dcmi_enum_frameintervals,
> +
> +	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
> +	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
> +	.vidioc_querybuf		= vb2_ioctl_querybuf,
> +	.vidioc_qbuf			= vb2_ioctl_qbuf,
> +	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
> +	.vidioc_expbuf			= vb2_ioctl_expbuf,
> +	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
> +	.vidioc_streamon		= vb2_ioctl_streamon,
> +	.vidioc_streamoff		= vb2_ioctl_streamoff,
> +
> +	.vidioc_log_status		= v4l2_ctrl_log_status,
> +	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
> +	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
> +};
> +
> +static const struct v4l2_file_operations dcmi_fops = {
> +	.owner		= THIS_MODULE,
> +	.unlocked_ioctl	= video_ioctl2,
> +	.open		= dcmi_open,
> +	.release	= dcmi_release,
> +	.poll		= vb2_fop_poll,
> +	.mmap		= vb2_fop_mmap,
> +#ifndef CONFIG_MMU
> +	.get_unmapped_area = vb2_fop_get_unmapped_area,
> +#endif
> +	.read		= vb2_fop_read,
> +};
> +
> +static int dcmi_set_default_fmt(struct stm32_dcmi *dcmi)
> +{
> +	struct v4l2_format f = {
> +		.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
> +		.fmt.pix = {
> +			.width		= CIF_WIDTH,
> +			.height		= CIF_HEIGHT,
> +			.field		= V4L2_FIELD_NONE,
> +			.pixelformat	= dcmi->user_formats[0]->fourcc,
> +		},
> +	};
> +	int ret;
> +
> +	ret = dcmi_try_fmt(dcmi, &f, NULL);
> +	if (ret)
> +		return ret;
> +	dcmi->current_fmt = dcmi->user_formats[0];
> +	dcmi->fmt = f;
> +	return 0;
> +}
> +
> +static const struct dcmi_format dcmi_formats[] = {
> +	{
> +		.fourcc = V4L2_PIX_FMT_RGB565,
> +		.mbus_code = MEDIA_BUS_FMT_RGB565_2X8_LE,
> +		.bpp = 2,
> +	}, {
> +		.fourcc = V4L2_PIX_FMT_YUYV,
> +		.mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
> +		.bpp = 2,
> +	}, {
> +		.fourcc = V4L2_PIX_FMT_UYVY,
> +		.mbus_code = MEDIA_BUS_FMT_UYVY8_2X8,
> +		.bpp = 2,
> +	},
> +};
> +
> +static int dcmi_formats_init(struct stm32_dcmi *dcmi)
> +{
> +	const struct dcmi_format *dcmi_fmts[ARRAY_SIZE(dcmi_formats)];
> +	unsigned int num_fmts = 0, i, j;
> +	struct v4l2_subdev *subdev = dcmi->entity.subdev;
> +	struct v4l2_subdev_mbus_code_enum mbus_code = {
> +		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
> +	};
> +
> +	while (!v4l2_subdev_call(subdev, pad, enum_mbus_code,
> +				 NULL, &mbus_code)) {
> +		for (i = 0; i < ARRAY_SIZE(dcmi_formats); i++) {
> +			if (dcmi_formats[i].mbus_code != mbus_code.code)
> +				continue;
> +
> +			/* Code supported, have we got this fourcc yet? */
> +			for (j = 0; j < num_fmts; j++)
> +				if (dcmi_fmts[j]->fourcc ==
> +						dcmi_formats[i].fourcc)
> +					/* Already available */
> +					break;
> +			if (j == num_fmts)
> +				/* New */
> +				dcmi_fmts[num_fmts++] = dcmi_formats + i;
> +		}
> +		mbus_code.index++;
> +	}
> +
> +	if (!num_fmts)
> +		return -ENXIO;
> +
> +	dcmi->num_user_formats = num_fmts;
> +	dcmi->user_formats = devm_kcalloc(dcmi->dev,
> +					 num_fmts, sizeof(struct dcmi_format *),
> +					 GFP_KERNEL);
> +	if (!dcmi->user_formats) {
> +		dev_err(dcmi->dev, "could not allocate memory\n");
> +		return -ENOMEM;
> +	}
> +
> +	memcpy(dcmi->user_formats, dcmi_fmts,
> +	       num_fmts * sizeof(struct dcmi_format *));
> +	dcmi->current_fmt = dcmi->user_formats[0];
> +
> +	return 0;
> +}
> +
> +static int dcmi_graph_notify_complete(struct v4l2_async_notifier *notifier)
> +{
> +	struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
> +	int ret;
> +
> +	dcmi->vdev->ctrl_handler	= dcmi->entity.subdev->ctrl_handler;

Replace the tab before the '=' by a simple space.

> +	ret = dcmi_formats_init(dcmi);
> +	if (ret) {
> +		dev_err(dcmi->dev, "No supported mediabus format found\n");
> +		return ret;
> +	}
> +
> +	ret = dcmi_set_default_fmt(dcmi);
> +	if (ret) {
> +		dev_err(dcmi->dev, "Could not set default format\n");
> +		return ret;
> +	}
> +
> +	ret = video_register_device(dcmi->vdev, VFL_TYPE_GRABBER, -1);
> +	if (ret) {
> +		dev_err(dcmi->dev, "Failed to register video device\n");
> +		return ret;
> +	}
> +
> +	dev_dbg(dcmi->dev, "Device registered as %s\n",
> +		video_device_node_name(dcmi->vdev));
> +	return 0;
> +}
> +
> +static void dcmi_graph_notify_unbind(struct v4l2_async_notifier *notifier,
> +				     struct v4l2_subdev *sd,
> +				     struct v4l2_async_subdev *asd)
> +{
> +	struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
> +
> +	dev_dbg(dcmi->dev, "Removing %s\n", video_device_node_name(dcmi->vdev));
> +
> +	/* Checks internaly if vdev has been init or not */
> +	video_unregister_device(dcmi->vdev);
> +}
> +
> +static int dcmi_graph_notify_bound(struct v4l2_async_notifier *notifier,
> +				   struct v4l2_subdev *subdev,
> +				   struct v4l2_async_subdev *asd)
> +{
> +	struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
> +
> +	dev_dbg(dcmi->dev, "Subdev %s bound\n", subdev->name);
> +
> +	dcmi->entity.subdev = subdev;
> +
> +	return 0;
> +}
> +
> +static int dcmi_graph_parse(struct stm32_dcmi *dcmi, struct device_node *node)
> +{
> +	struct device_node *ep = NULL;
> +	struct device_node *remote;
> +
> +	while (1) {
> +		ep = of_graph_get_next_endpoint(node, ep);
> +		if (!ep)
> +			return -EINVAL;
> +
> +		remote = of_graph_get_remote_port_parent(ep);
> +		if (!remote) {
> +			of_node_put(ep);
> +			return -EINVAL;
> +		}
> +
> +		/* Remote node to connect */
> +		dcmi->entity.node = remote;
> +		dcmi->entity.asd.match_type = V4L2_ASYNC_MATCH_OF;
> +		dcmi->entity.asd.match.of.node = remote;
> +		return 0;
> +	}
> +}
> +
> +static int dcmi_graph_init(struct stm32_dcmi *dcmi)
> +{
> +	struct v4l2_async_subdev **subdevs = NULL;
> +	int ret;
> +
> +	/* Parse the graph to extract a list of subdevice DT nodes. */
> +	ret = dcmi_graph_parse(dcmi, dcmi->dev->of_node);
> +	if (ret < 0) {
> +		dev_err(dcmi->dev, "Graph parsing failed\n");
> +		return ret;
> +	}
> +
> +	/* Register the subdevices notifier. */
> +	subdevs = devm_kzalloc(dcmi->dev, sizeof(*subdevs), GFP_KERNEL);
> +	if (!subdevs) {
> +		of_node_put(dcmi->entity.node);
> +		return -ENOMEM;
> +	}
> +
> +	subdevs[0] = &dcmi->entity.asd;
> +
> +	dcmi->notifier.subdevs = subdevs;
> +	dcmi->notifier.num_subdevs = 1;
> +	dcmi->notifier.bound = dcmi_graph_notify_bound;
> +	dcmi->notifier.unbind = dcmi_graph_notify_unbind;
> +	dcmi->notifier.complete = dcmi_graph_notify_complete;
> +
> +	ret = v4l2_async_notifier_register(&dcmi->v4l2_dev, &dcmi->notifier);
> +	if (ret < 0) {
> +		dev_err(dcmi->dev, "Notifier registration failed\n");
> +		of_node_put(dcmi->entity.node);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int dcmi_probe(struct platform_device *pdev)
> +{
> +	struct device_node *np = pdev->dev.of_node;
> +	const struct of_device_id *match = NULL;
> +	struct v4l2_of_endpoint ep;
> +	struct stm32_dcmi *dcmi;
> +	struct vb2_queue *q;
> +	struct dma_chan *chan;
> +	struct clk *mclk;
> +	int irq;
> +	int ret = 0;
> +
> +	match = of_match_device(of_match_ptr(stm32_dcmi_of_match), &pdev->dev);
> +	if (!match) {
> +		dev_err(&pdev->dev, "Could not find a match in devicetree\n");
> +		return -ENODEV;
> +	}
> +
> +	dcmi = devm_kzalloc(&pdev->dev, sizeof(struct stm32_dcmi), GFP_KERNEL);
> +	if (!dcmi)
> +		return -ENOMEM;
> +
> +	dcmi->rstc = of_reset_control_get(np, NULL);
> +	if (IS_ERR(dcmi->rstc)) {
> +		dev_err(&pdev->dev, "Could not get reset control\n");
> +		return -ENODEV;
> +	}
> +
> +	/* Get bus characteristics from devicetree */
> +	np = of_graph_get_next_endpoint(np, NULL);
> +	if (!np) {
> +		dev_err(&pdev->dev, "Could not find the endpoint\n");
> +		of_node_put(np);
> +		goto err_reset_control_put;
> +	}
> +
> +	ret = v4l2_of_parse_endpoint(np, &ep);
> +	if (ret) {
> +		dev_err(&pdev->dev, "Could not parse the endpoint\n");
> +		of_node_put(np);
> +		goto err_reset_control_put;
> +	}
> +
> +	if (ep.bus_type == V4L2_MBUS_CSI2) {
> +		dev_err(&pdev->dev, "CSI bus not supported\n");
> +		of_node_put(np);
> +		goto err_reset_control_put;
> +	}
> +	dcmi->bus.flags = ep.bus.parallel.flags;
> +	dcmi->bus.bus_width = ep.bus.parallel.bus_width;
> +	dcmi->bus.data_shift = ep.bus.parallel.data_shift;
> +
> +	of_node_put(np);
> +
> +	irq = platform_get_irq(pdev, 0);
> +	if (irq <= 0) {
> +		dev_err(&pdev->dev, "Could not get irq\n");
> +		return -ENODEV;
> +	}
> +
> +	dcmi->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	if (!dcmi->res) {
> +		dev_err(&pdev->dev, "Could not get resource\n");
> +		return -ENODEV;
> +	}
> +
> +	dcmi->regs = devm_ioremap_resource(&pdev->dev, dcmi->res);
> +	if (IS_ERR(dcmi->regs)) {
> +		dev_err(&pdev->dev, "Could not map registers\n");
> +		return PTR_ERR(dcmi->regs);
> +	}
> +
> +	ret = devm_request_threaded_irq(&pdev->dev, irq, dcmi_irq_callback,
> +					dcmi_irq_thread, IRQF_ONESHOT,
> +					dev_name(&pdev->dev), dcmi);
> +	if (ret) {
> +		dev_err(&pdev->dev, "Unable to request irq %d\n", irq);
> +		return -ENODEV;
> +	}
> +
> +	mclk = devm_clk_get(&pdev->dev, "mclk");
> +	if (IS_ERR(mclk)) {
> +		dev_err(&pdev->dev, "Unable to get mclk\n");
> +		return PTR_ERR(mclk);
> +	}
> +
> +	chan = dma_request_slave_channel(&pdev->dev, "tx");
> +	if (!chan) {
> +		dev_info(&pdev->dev, "Unable to request DMA channel, defer probing\n");
> +		return -EPROBE_DEFER;
> +	}
> +
> +	ret = clk_prepare(mclk);
> +	if (ret) {
> +		dev_err(&pdev->dev, "Unable to prepare mclk %p\n", mclk);
> +		goto err_dma_release;
> +	}
> +
> +	spin_lock_init(&dcmi->irqlock);
> +	mutex_init(&dcmi->lock);
> +	init_completion(&dcmi->complete);
> +	INIT_LIST_HEAD(&dcmi->buffers);
> +
> +	dcmi->dev = &pdev->dev;
> +	dcmi->mclk = mclk;
> +	dcmi->state = STOPPED;
> +	dcmi->dma_chan = chan;
> +
> +	q = &dcmi->queue;
> +
> +	/* Initialize the top-level structure */
> +	ret = v4l2_device_register(&pdev->dev, &dcmi->v4l2_dev);
> +	if (ret)
> +		goto err_clk_unprepare;
> +
> +	dcmi->vdev = video_device_alloc();
> +	if (!dcmi->vdev) {
> +		ret = -ENOMEM;
> +		goto err_device_unregister;
> +	}
> +
> +	/* Video node */
> +	dcmi->vdev->fops = &dcmi_fops;
> +	dcmi->vdev->v4l2_dev = &dcmi->v4l2_dev;
> +	dcmi->vdev->queue = &dcmi->queue;
> +	strlcpy(dcmi->vdev->name, KBUILD_MODNAME, sizeof(dcmi->vdev->name));
> +	dcmi->vdev->release = video_device_release;
> +	dcmi->vdev->ioctl_ops = &dcmi_ioctl_ops;
> +	dcmi->vdev->lock = &dcmi->lock;
> +	dcmi->vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
> +				  V4L2_CAP_READWRITE;
> +	video_set_drvdata(dcmi->vdev, dcmi);
> +
> +	/* Buffer queue */
> +	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> +	q->io_modes = VB2_MMAP | VB2_READ | VB2_DMABUF;
> +	q->lock = &dcmi->lock;
> +	q->drv_priv = dcmi;
> +	q->buf_struct_size = sizeof(struct dcmi_buf);
> +	q->ops = &dcmi_video_qops;
> +	q->mem_ops = &vb2_dma_contig_memops;
> +	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
> +	q->min_buffers_needed = 2;
> +	q->dev = &pdev->dev;
> +
> +	ret = vb2_queue_init(q);
> +	if (ret < 0) {
> +		dev_err(&pdev->dev, "Failed to initialize vb2 queue\n");
> +		goto err_device_release;
> +	}
> +
> +	ret = dcmi_graph_init(dcmi);
> +	if (ret < 0)
> +		goto err_device_release;
> +
> +	/* Reset device */
> +	ret = reset_control_assert(dcmi->rstc);
> +	if (ret) {
> +		dev_err(&pdev->dev, "Failed to assert the reset line\n");
> +		goto err_device_release;
> +	}
> +
> +	usleep_range(3000, 5000);
> +
> +	ret = reset_control_deassert(dcmi->rstc);
> +	if (ret) {
> +		dev_err(&pdev->dev, "Failed to deassert the reset line\n");
> +		goto err_device_release;
> +	}
> +
> +	dev_info(&pdev->dev, "Probe done\n");
> +
> +	platform_set_drvdata(pdev, dcmi);
> +	return 0;
> +
> +err_reset_control_put:
> +	reset_control_put(dcmi->rstc);
> +err_device_release:
> +	video_device_release(dcmi->vdev);
> +err_device_unregister:
> +	v4l2_device_unregister(&dcmi->v4l2_dev);
> +err_clk_unprepare:
> +	clk_unprepare(dcmi->mclk);
> +err_dma_release:
> +	dma_release_channel(dcmi->dma_chan);
> +
> +	return ret;
> +}
> +
> +static int dcmi_remove(struct platform_device *pdev)
> +{
> +	struct stm32_dcmi *dcmi = platform_get_drvdata(pdev);
> +
> +	v4l2_async_notifier_unregister(&dcmi->notifier);
> +	v4l2_device_unregister(&dcmi->v4l2_dev);
> +	clk_unprepare(dcmi->mclk);
> +	dma_release_channel(dcmi->dma_chan);
> +	reset_control_put(dcmi->rstc);
> +
> +	return 0;
> +}
> +
> +static struct platform_driver stm32_dcmi_driver = {
> +	.probe		= dcmi_probe,
> +	.remove		= dcmi_remove,
> +	.driver		= {
> +		.name = DRV_NAME,
> +		.of_match_table = of_match_ptr(stm32_dcmi_of_match),
> +	},
> +};
> +
> +module_platform_driver(stm32_dcmi_driver);
> +
> +MODULE_AUTHOR("Yannick Fertre <yannick.fertre@xxxxxx>");
> +MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@xxxxxx>");
> +MODULE_DESCRIPTION("STMicroelectronics STM32 Digital Camera Memory Interface driver");
> +MODULE_LICENSE("GPL");
> +MODULE_SUPPORTED_DEVICE("video");
> 

Regards,

	Hans