Lines Matching refs:dcmi
41 #define DRV_NAME "stm32-dcmi"
204 static int dcmi_start_capture(struct stm32_dcmi *dcmi, struct dcmi_buf *buf);
206 static void dcmi_buffer_done(struct stm32_dcmi *dcmi,
220 vbuf->sequence = dcmi->sequence++;
226 dev_dbg(dcmi->dev, "buffer[%d] done seq=%d, bytesused=%zu\n",
229 dcmi->buffers_count++;
230 dcmi->active = NULL;
233 static int dcmi_restart_capture(struct stm32_dcmi *dcmi)
237 spin_lock_irq(&dcmi->irqlock);
239 if (dcmi->state != RUNNING) {
240 spin_unlock_irq(&dcmi->irqlock);
245 if (list_empty(&dcmi->buffers)) {
246 dev_dbg(dcmi->dev, "Capture restart is deferred to next buffer queueing\n");
247 dcmi->state = WAIT_FOR_BUFFER;
248 spin_unlock_irq(&dcmi->irqlock);
251 buf = list_entry(dcmi->buffers.next, struct dcmi_buf, list);
252 dcmi->active = buf;
254 spin_unlock_irq(&dcmi->irqlock);
256 return dcmi_start_capture(dcmi, buf);
261 struct stm32_dcmi *dcmi = (struct stm32_dcmi *)param;
264 struct dcmi_buf *buf = dcmi->active;
266 spin_lock_irq(&dcmi->irqlock);
269 status = dmaengine_tx_status(dcmi->dma_chan, dcmi->dma_cookie, &state);
273 dev_dbg(dcmi->dev, "%s: Received DMA_IN_PROGRESS\n", __func__);
276 dev_err(dcmi->dev, "%s: Received DMA_PAUSED\n", __func__);
279 dev_err(dcmi->dev, "%s: Received DMA_ERROR\n", __func__);
282 dcmi_buffer_done(dcmi, buf, 0, -EIO);
285 dev_dbg(dcmi->dev, "%s: Received DMA_COMPLETE\n", __func__);
288 dcmi_buffer_done(dcmi, buf, buf->size, 0);
290 spin_unlock_irq(&dcmi->irqlock);
293 if (dcmi_restart_capture(dcmi))
294 dev_err(dcmi->dev, "%s: Cannot restart capture on DMA complete\n",
298 dev_err(dcmi->dev, "%s: Received unknown status\n", __func__);
302 spin_unlock_irq(&dcmi->irqlock);
305 static int dcmi_start_dma(struct stm32_dcmi *dcmi,
314 config.src_addr = (dma_addr_t)dcmi->res->start + DCMI_DR;
320 ret = dmaengine_slave_config(dcmi->dma_chan, &config);
322 dev_err(dcmi->dev, "%s: DMA channel config failed (%d)\n",
332 mutex_lock(&dcmi->dma_lock);
335 desc = dmaengine_prep_slave_single(dcmi->dma_chan, buf->paddr,
340 dev_err(dcmi->dev, "%s: DMA dmaengine_prep_slave_single failed for buffer phy=%pad size=%zu\n",
342 mutex_unlock(&dcmi->dma_lock);
348 desc->callback_param = dcmi;
351 dcmi->dma_cookie = dmaengine_submit(desc);
352 if (dma_submit_error(dcmi->dma_cookie)) {
353 dev_err(dcmi->dev, "%s: DMA submission failed\n", __func__);
354 mutex_unlock(&dcmi->dma_lock);
358 mutex_unlock(&dcmi->dma_lock);
360 dma_async_issue_pending(dcmi->dma_chan);
365 static int dcmi_start_capture(struct stm32_dcmi *dcmi, struct dcmi_buf *buf)
372 ret = dcmi_start_dma(dcmi, buf);
374 dcmi->errors_count++;
379 reg_set(dcmi->regs, DCMI_CR, CR_CAPTURE);
384 static void dcmi_set_crop(struct stm32_dcmi *dcmi)
389 size = ((dcmi->crop.height - 1) << 16) |
390 ((dcmi->crop.width << 1) - 1);
391 reg_write(dcmi->regs, DCMI_CWSIZE, size);
394 start = ((dcmi->crop.top) << 16) |
395 ((dcmi->crop.left << 1));
396 reg_write(dcmi->regs, DCMI_CWSTRT, start);
398 dev_dbg(dcmi->dev, "Cropping to %ux%u@%u:%u\n",
399 dcmi->crop.width, dcmi->crop.height,
400 dcmi->crop.left, dcmi->crop.top);
403 reg_set(dcmi->regs, DCMI_CR, CR_CROP);
406 static void dcmi_process_jpeg(struct stm32_dcmi *dcmi)
410 struct dcmi_buf *buf = dcmi->active;
426 dmaengine_synchronize(dcmi->dma_chan);
429 status = dmaengine_tx_status(dcmi->dma_chan, dcmi->dma_cookie, &state);
432 dcmi_buffer_done(dcmi, buf, buf->size - state.residue, 0);
434 dcmi->errors_count++;
435 dev_err(dcmi->dev, "%s: Cannot get JPEG size from DMA\n",
438 dcmi_buffer_done(dcmi, buf, 0, -EIO);
442 dmaengine_terminate_all(dcmi->dma_chan);
445 if (dcmi_restart_capture(dcmi))
446 dev_err(dcmi->dev, "%s: Cannot restart capture on JPEG received\n",
452 struct stm32_dcmi *dcmi = arg;
454 spin_lock_irq(&dcmi->irqlock);
456 if (dcmi->misr & IT_OVR) {
457 dcmi->overrun_count++;
458 if (dcmi->overrun_count > OVERRUN_ERROR_THRESHOLD)
459 dcmi->errors_count++;
461 if (dcmi->misr & IT_ERR)
462 dcmi->errors_count++;
464 if (dcmi->sd_format->fourcc == V4L2_PIX_FMT_JPEG &&
465 dcmi->misr & IT_FRAME) {
467 spin_unlock_irq(&dcmi->irqlock);
468 dcmi_process_jpeg(dcmi);
472 spin_unlock_irq(&dcmi->irqlock);
478 struct stm32_dcmi *dcmi = arg;
481 spin_lock_irqsave(&dcmi->irqlock, flags);
483 dcmi->misr = reg_read(dcmi->regs, DCMI_MIS);
486 reg_set(dcmi->regs, DCMI_ICR, IT_FRAME | IT_OVR | IT_ERR);
488 spin_unlock_irqrestore(&dcmi->irqlock, flags);
499 struct stm32_dcmi *dcmi = vb2_get_drv_priv(vq);
502 size = dcmi->fmt.fmt.pix.sizeimage;
511 dev_dbg(dcmi->dev, "Setup queue, count=%d, size=%d\n",
529 struct stm32_dcmi *dcmi = vb2_get_drv_priv(vb->vb2_queue);
534 size = dcmi->fmt.fmt.pix.sizeimage;
537 dev_err(dcmi->dev, "%s data will not fit into plane (%lu < %lu)\n",
553 dev_dbg(dcmi->dev, "buffer[%d] phy=%pad size=%zu\n",
562 struct stm32_dcmi *dcmi = vb2_get_drv_priv(vb->vb2_queue);
566 spin_lock_irq(&dcmi->irqlock);
569 list_add_tail(&buf->list, &dcmi->buffers);
571 if (dcmi->state == WAIT_FOR_BUFFER) {
572 dcmi->state = RUNNING;
573 dcmi->active = buf;
575 dev_dbg(dcmi->dev, "Starting capture on buffer[%d] queued\n",
578 spin_unlock_irq(&dcmi->irqlock);
579 if (dcmi_start_capture(dcmi, buf))
580 dev_err(dcmi->dev, "%s: Cannot restart capture on overflow or error\n",
585 spin_unlock_irq(&dcmi->irqlock);
588 static struct media_entity *dcmi_find_source(struct stm32_dcmi *dcmi)
590 struct media_entity *entity = &dcmi->vdev->entity;
609 static int dcmi_pipeline_s_fmt(struct stm32_dcmi *dcmi,
613 struct media_entity *entity = &dcmi->entity.source->entity;
647 dev_dbg(dcmi->dev, "\"%s\":%d pad format set to 0x%x %ux%u\n",
654 dev_err(dcmi->dev, "%s: Failed to set format 0x%x %ux%u on \"%s\":%d pad (%d)\n",
664 dev_dbg(dcmi->dev, "\"%s\":%d pad format has been changed to 0x%x %ux%u\n",
681 static int dcmi_pipeline_s_stream(struct stm32_dcmi *dcmi, int state)
683 struct media_entity *entity = &dcmi->vdev->entity;
703 dev_err(dcmi->dev, "%s: \"%s\" failed to %s streaming (%d)\n",
709 dev_dbg(dcmi->dev, "\"%s\" is %s\n",
716 static int dcmi_pipeline_start(struct stm32_dcmi *dcmi)
718 return dcmi_pipeline_s_stream(dcmi, 1);
721 static void dcmi_pipeline_stop(struct stm32_dcmi *dcmi)
723 dcmi_pipeline_s_stream(dcmi, 0);
728 struct stm32_dcmi *dcmi = vb2_get_drv_priv(vq);
733 ret = pm_runtime_get_sync(dcmi->dev);
735 dev_err(dcmi->dev, "%s: Failed to start streaming, cannot get sync (%d)\n",
740 ret = media_pipeline_start(&dcmi->vdev->entity, &dcmi->pipeline);
742 dev_err(dcmi->dev, "%s: Failed to start streaming, media pipeline start error (%d)\n",
747 ret = dcmi_pipeline_start(dcmi);
751 spin_lock_irq(&dcmi->irqlock);
754 switch (dcmi->bus.bus_width) {
770 if (dcmi->bus.flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
774 if (dcmi->bus.flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH)
778 if (dcmi->bus.flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
781 reg_write(dcmi->regs, DCMI_CR, val);
784 if (dcmi->do_crop)
785 dcmi_set_crop(dcmi);
788 if (dcmi->sd_format->fourcc == V4L2_PIX_FMT_JPEG)
789 reg_set(dcmi->regs, DCMI_CR, CR_CM);/* Snapshot mode */
791 /* Enable dcmi */
792 reg_set(dcmi->regs, DCMI_CR, CR_ENABLE);
794 dcmi->sequence = 0;
795 dcmi->errors_count = 0;
796 dcmi->overrun_count = 0;
797 dcmi->buffers_count = 0;
803 if (list_empty(&dcmi->buffers)) {
804 dev_dbg(dcmi->dev, "Start streaming is deferred to next buffer queueing\n");
805 dcmi->state = WAIT_FOR_BUFFER;
806 spin_unlock_irq(&dcmi->irqlock);
810 buf = list_entry(dcmi->buffers.next, struct dcmi_buf, list);
811 dcmi->active = buf;
813 dcmi->state = RUNNING;
815 dev_dbg(dcmi->dev, "Start streaming, starting capture\n");
817 spin_unlock_irq(&dcmi->irqlock);
818 ret = dcmi_start_capture(dcmi, buf);
820 dev_err(dcmi->dev, "%s: Start streaming failed, cannot start capture\n",
826 if (dcmi->sd_format->fourcc == V4L2_PIX_FMT_JPEG)
827 reg_set(dcmi->regs, DCMI_IER, IT_FRAME | IT_OVR | IT_ERR);
829 reg_set(dcmi->regs, DCMI_IER, IT_OVR | IT_ERR);
834 dcmi_pipeline_stop(dcmi);
837 media_pipeline_stop(&dcmi->vdev->entity);
840 pm_runtime_put(dcmi->dev);
841 spin_lock_irq(&dcmi->irqlock);
846 list_for_each_entry_safe(buf, node, &dcmi->buffers, list) {
850 dcmi->active = NULL;
851 spin_unlock_irq(&dcmi->irqlock);
858 struct stm32_dcmi *dcmi = vb2_get_drv_priv(vq);
861 dcmi_pipeline_stop(dcmi);
863 media_pipeline_stop(&dcmi->vdev->entity);
865 spin_lock_irq(&dcmi->irqlock);
868 reg_clear(dcmi->regs, DCMI_IER, IT_FRAME | IT_OVR | IT_ERR);
871 reg_clear(dcmi->regs, DCMI_CR, CR_ENABLE);
874 list_for_each_entry_safe(buf, node, &dcmi->buffers, list) {
879 dcmi->active = NULL;
880 dcmi->state = STOPPED;
882 spin_unlock_irq(&dcmi->irqlock);
885 mutex_lock(&dcmi->dma_lock);
886 dmaengine_terminate_all(dcmi->dma_chan);
887 mutex_unlock(&dcmi->dma_lock);
889 pm_runtime_put(dcmi->dev);
891 if (dcmi->errors_count)
892 dev_warn(dcmi->dev, "Some errors found while streaming: errors=%d (overrun=%d), buffers=%d\n",
893 dcmi->errors_count, dcmi->overrun_count,
894 dcmi->buffers_count);
895 dev_dbg(dcmi->dev, "Stop streaming, errors=%d (overrun=%d), buffers=%d\n",
896 dcmi->errors_count, dcmi->overrun_count,
897 dcmi->buffers_count);
914 struct stm32_dcmi *dcmi = video_drvdata(file);
916 *fmt = dcmi->fmt;
921 static const struct dcmi_format *find_format_by_fourcc(struct stm32_dcmi *dcmi,
924 unsigned int num_formats = dcmi->num_of_sd_formats;
929 fmt = dcmi->sd_formats[i];
937 static void __find_outer_frame_size(struct stm32_dcmi *dcmi,
945 for (i = 0; i < dcmi->num_of_sd_framesizes; i++) {
946 struct dcmi_framesize *fsize = &dcmi->sd_framesizes[i];
957 match = &dcmi->sd_framesizes[0];
962 static int dcmi_try_fmt(struct stm32_dcmi *dcmi, struct v4l2_format *f,
976 sd_fmt = find_format_by_fourcc(dcmi, pix->pixelformat);
978 if (!dcmi->num_of_sd_formats)
981 sd_fmt = dcmi->sd_formats[dcmi->num_of_sd_formats - 1];
990 do_crop = dcmi->do_crop && (pix->pixelformat != V4L2_PIX_FMT_JPEG);
992 if (do_crop && dcmi->num_of_sd_framesizes) {
998 __find_outer_frame_size(dcmi, pix, &outer_sd_fsize);
1004 ret = v4l2_subdev_call(dcmi->entity.source, pad, set_fmt,
1017 struct v4l2_rect c = dcmi->crop;
1031 dcmi->crop = c;
1034 pix->width = dcmi->crop.width;
1035 pix->height = dcmi->crop.height;
1050 static int dcmi_set_fmt(struct stm32_dcmi *dcmi, struct v4l2_format *f)
1067 ret = dcmi_try_fmt(dcmi, f, &sd_format, &sd_framesize);
1073 dcmi->do_crop = false;
1081 ret = dcmi_pipeline_s_fmt(dcmi, NULL, &format);
1085 dev_dbg(dcmi->dev, "Sensor format set to 0x%x %ux%u\n",
1087 dev_dbg(dcmi->dev, "Buffer format set to %4.4s %ux%u\n",
1091 dcmi->fmt = *f;
1092 dcmi->sd_format = sd_format;
1093 dcmi->sd_framesize = sd_framesize;
1101 struct stm32_dcmi *dcmi = video_drvdata(file);
1103 if (vb2_is_streaming(&dcmi->queue))
1106 return dcmi_set_fmt(dcmi, f);
1112 struct stm32_dcmi *dcmi = video_drvdata(file);
1114 return dcmi_try_fmt(dcmi, f, NULL, NULL);
1120 struct stm32_dcmi *dcmi = video_drvdata(file);
1122 if (f->index >= dcmi->num_of_sd_formats)
1125 f->pixelformat = dcmi->sd_formats[f->index]->fourcc;
1129 static int dcmi_get_sensor_format(struct stm32_dcmi *dcmi,
1137 ret = v4l2_subdev_call(dcmi->entity.source, pad, get_fmt, NULL, &fmt);
1146 static int dcmi_set_sensor_format(struct stm32_dcmi *dcmi,
1156 sd_fmt = find_format_by_fourcc(dcmi, pix->pixelformat);
1158 if (!dcmi->num_of_sd_formats)
1161 sd_fmt = dcmi->sd_formats[dcmi->num_of_sd_formats - 1];
1166 ret = v4l2_subdev_call(dcmi->entity.source, pad, set_fmt,
1174 static int dcmi_get_sensor_bounds(struct stm32_dcmi *dcmi,
1189 ret = v4l2_subdev_call(dcmi->entity.source, pad, get_selection,
1204 for (i = 0; i < dcmi->num_of_sd_framesizes; i++) {
1205 struct dcmi_framesize *fsize = &dcmi->sd_framesizes[i];
1226 ret = dcmi_get_sensor_format(dcmi, &pix);
1241 struct stm32_dcmi *dcmi = video_drvdata(file);
1249 s->r = dcmi->sd_bounds;
1252 if (dcmi->do_crop) {
1253 s->r = dcmi->crop;
1257 s->r.width = dcmi->fmt.fmt.pix.width;
1258 s->r.height = dcmi->fmt.fmt.pix.height;
1271 struct stm32_dcmi *dcmi = video_drvdata(file);
1281 pix.pixelformat = dcmi->fmt.fmt.pix.pixelformat;
1282 pix.width = dcmi->sd_bounds.width;
1283 pix.height = dcmi->sd_bounds.height;
1284 dcmi_set_sensor_format(dcmi, &pix);
1299 if (!(r.top == dcmi->sd_bounds.top &&
1300 r.left == dcmi->sd_bounds.left &&
1301 r.width == dcmi->sd_bounds.width &&
1302 r.height == dcmi->sd_bounds.height)) {
1304 dcmi->do_crop = true;
1305 dcmi->crop = r;
1306 dev_dbg(dcmi->dev, "s_selection: crop %ux%u@(%u,%u) from %ux%u\n",
1311 dcmi->do_crop = false;
1312 dev_dbg(dcmi->dev, "s_selection: crop is disabled\n");
1325 strscpy(cap->bus_info, "platform:dcmi", sizeof(cap->bus_info));
1356 struct stm32_dcmi *dcmi = video_drvdata(file);
1364 sd_fmt = find_format_by_fourcc(dcmi, fsize->pixel_format);
1370 ret = v4l2_subdev_call(dcmi->entity.source, pad, enum_frame_size,
1385 struct stm32_dcmi *dcmi = video_drvdata(file);
1387 return v4l2_g_parm_cap(video_devdata(file), dcmi->entity.source, p);
1393 struct stm32_dcmi *dcmi = video_drvdata(file);
1395 return v4l2_s_parm_cap(video_devdata(file), dcmi->entity.source, p);
1401 struct stm32_dcmi *dcmi = video_drvdata(file);
1411 sd_fmt = find_format_by_fourcc(dcmi, fival->pixel_format);
1417 ret = v4l2_subdev_call(dcmi->entity.source, pad,
1429 { .compatible = "st,stm32-dcmi"},
1436 struct stm32_dcmi *dcmi = video_drvdata(file);
1437 struct v4l2_subdev *sd = dcmi->entity.source;
1440 if (mutex_lock_interruptible(&dcmi->lock))
1454 ret = dcmi_set_fmt(dcmi, &dcmi->fmt);
1461 mutex_unlock(&dcmi->lock);
1467 struct stm32_dcmi *dcmi = video_drvdata(file);
1468 struct v4l2_subdev *sd = dcmi->entity.source;
1472 mutex_lock(&dcmi->lock);
1481 mutex_unlock(&dcmi->lock);
1534 static int dcmi_set_default_fmt(struct stm32_dcmi *dcmi)
1542 .pixelformat = dcmi->sd_formats[0]->fourcc,
1547 ret = dcmi_try_fmt(dcmi, &f, NULL, NULL);
1550 dcmi->sd_format = dcmi->sd_formats[0];
1551 dcmi->fmt = f;
1581 static int dcmi_formats_init(struct stm32_dcmi *dcmi)
1585 struct v4l2_subdev *subdev = dcmi->entity.source;
1601 dev_dbg(dcmi->dev, "Skipping fourcc/code: %4.4s/0x%x\n",
1609 dev_dbg(dcmi->dev, "Supported fourcc/code: %4.4s/0x%x\n",
1620 dcmi->num_of_sd_formats = num_fmts;
1621 dcmi->sd_formats = devm_kcalloc(dcmi->dev,
1624 if (!dcmi->sd_formats) {
1625 dev_err(dcmi->dev, "Could not allocate memory\n");
1629 memcpy(dcmi->sd_formats, sd_fmts,
1631 dcmi->sd_format = dcmi->sd_formats[0];
1636 static int dcmi_framesizes_init(struct stm32_dcmi *dcmi)
1639 struct v4l2_subdev *subdev = dcmi->entity.source;
1642 .code = dcmi->sd_format->mbus_code,
1656 dcmi->num_of_sd_framesizes = num_fsize;
1657 dcmi->sd_framesizes = devm_kcalloc(dcmi->dev, num_fsize,
1660 if (!dcmi->sd_framesizes) {
1661 dev_err(dcmi->dev, "Could not allocate memory\n");
1666 dev_dbg(dcmi->dev, "Sensor supports %u frame sizes:\n", num_fsize);
1667 for (i = 0; i < dcmi->num_of_sd_framesizes; i++) {
1673 dcmi->sd_framesizes[fse.index].width = fse.max_width;
1674 dcmi->sd_framesizes[fse.index].height = fse.max_height;
1675 dev_dbg(dcmi->dev, "%ux%u\n", fse.max_width, fse.max_height);
1683 struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
1691 dcmi->entity.source =
1692 media_entity_to_v4l2_subdev(dcmi_find_source(dcmi));
1693 if (!dcmi->entity.source) {
1694 dev_err(dcmi->dev, "Source subdevice not found\n");
1698 dcmi->vdev->ctrl_handler = dcmi->entity.source->ctrl_handler;
1700 ret = dcmi_formats_init(dcmi);
1702 dev_err(dcmi->dev, "No supported mediabus format found\n");
1706 ret = dcmi_framesizes_init(dcmi);
1708 dev_err(dcmi->dev, "Could not initialize framesizes\n");
1712 ret = dcmi_get_sensor_bounds(dcmi, &dcmi->sd_bounds);
1714 dev_err(dcmi->dev, "Could not get sensor bounds\n");
1718 ret = dcmi_set_default_fmt(dcmi);
1720 dev_err(dcmi->dev, "Could not set default format\n");
1724 ret = devm_request_threaded_irq(dcmi->dev, dcmi->irq, dcmi_irq_callback,
1726 dev_name(dcmi->dev), dcmi);
1728 dev_err(dcmi->dev, "Unable to request irq %d\n", dcmi->irq);
1739 struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
1741 dev_dbg(dcmi->dev, "Removing %s\n", video_device_node_name(dcmi->vdev));
1744 video_unregister_device(dcmi->vdev);
1751 struct stm32_dcmi *dcmi = notifier_to_dcmi(notifier);
1755 dev_dbg(dcmi->dev, "Subdev \"%s\" bound\n", subdev->name);
1766 &dcmi->vdev->entity, 0,
1770 dev_err(dcmi->dev, "Failed to create media pad link with subdev \"%s\"\n",
1773 dev_dbg(dcmi->dev, "DCMI is now linked to \"%s\"\n",
1785 static int dcmi_graph_parse(struct stm32_dcmi *dcmi, struct device_node *node)
1800 dcmi->entity.remote_node = remote;
1801 dcmi->entity.asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
1802 dcmi->entity.asd.match.fwnode = of_fwnode_handle(remote);
1806 static int dcmi_graph_init(struct stm32_dcmi *dcmi)
1811 ret = dcmi_graph_parse(dcmi, dcmi->dev->of_node);
1813 dev_err(dcmi->dev, "Failed to parse graph\n");
1817 v4l2_async_notifier_init(&dcmi->notifier);
1819 ret = v4l2_async_notifier_add_subdev(&dcmi->notifier,
1820 &dcmi->entity.asd);
1822 dev_err(dcmi->dev, "Failed to add subdev notifier\n");
1823 of_node_put(dcmi->entity.remote_node);
1827 dcmi->notifier.ops = &dcmi_graph_notify_ops;
1829 ret = v4l2_async_notifier_register(&dcmi->v4l2_dev, &dcmi->notifier);
1831 dev_err(dcmi->dev, "Failed to register notifier\n");
1832 v4l2_async_notifier_cleanup(&dcmi->notifier);
1844 struct stm32_dcmi *dcmi;
1857 dcmi = devm_kzalloc(&pdev->dev, sizeof(struct stm32_dcmi), GFP_KERNEL);
1858 if (!dcmi)
1861 dcmi->rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL);
1862 if (IS_ERR(dcmi->rstc)) {
1864 return PTR_ERR(dcmi->rstc);
1885 dcmi->bus.flags = ep.bus.parallel.flags;
1886 dcmi->bus.bus_width = ep.bus.parallel.bus_width;
1887 dcmi->bus.data_shift = ep.bus.parallel.data_shift;
1893 dcmi->irq = irq;
1895 dcmi->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1896 if (!dcmi->res) {
1901 dcmi->regs = devm_ioremap_resource(&pdev->dev, dcmi->res);
1902 if (IS_ERR(dcmi->regs)) {
1904 return PTR_ERR(dcmi->regs);
1923 spin_lock_init(&dcmi->irqlock);
1924 mutex_init(&dcmi->lock);
1925 mutex_init(&dcmi->dma_lock);
1926 init_completion(&dcmi->complete);
1927 INIT_LIST_HEAD(&dcmi->buffers);
1929 dcmi->dev = &pdev->dev;
1930 dcmi->mclk = mclk;
1931 dcmi->state = STOPPED;
1932 dcmi->dma_chan = chan;
1934 q = &dcmi->queue;
1936 dcmi->v4l2_dev.mdev = &dcmi->mdev;
1939 strscpy(dcmi->mdev.model, DRV_NAME, sizeof(dcmi->mdev.model));
1940 snprintf(dcmi->mdev.bus_info, sizeof(dcmi->mdev.bus_info),
1942 dcmi->mdev.dev = &pdev->dev;
1943 media_device_init(&dcmi->mdev);
1946 ret = v4l2_device_register(&pdev->dev, &dcmi->v4l2_dev);
1950 dcmi->vdev = video_device_alloc();
1951 if (!dcmi->vdev) {
1957 dcmi->vdev->fops = &dcmi_fops;
1958 dcmi->vdev->v4l2_dev = &dcmi->v4l2_dev;
1959 dcmi->vdev->queue = &dcmi->queue;
1960 strscpy(dcmi->vdev->name, KBUILD_MODNAME, sizeof(dcmi->vdev->name));
1961 dcmi->vdev->release = video_device_release;
1962 dcmi->vdev->ioctl_ops = &dcmi_ioctl_ops;
1963 dcmi->vdev->lock = &dcmi->lock;
1964 dcmi->vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1966 video_set_drvdata(dcmi->vdev, dcmi);
1969 dcmi->vid_cap_pad.flags = MEDIA_PAD_FL_SINK;
1970 ret = media_entity_pads_init(&dcmi->vdev->entity,
1971 1, &dcmi->vid_cap_pad);
1973 dev_err(dcmi->dev, "Failed to init media entity pad\n");
1976 dcmi->vdev->entity.flags |= MEDIA_ENT_FL_DEFAULT;
1978 ret = video_register_device(dcmi->vdev, VFL_TYPE_VIDEO, -1);
1980 dev_err(dcmi->dev, "Failed to register video device\n");
1984 dev_dbg(dcmi->dev, "Device registered as %s\n",
1985 video_device_node_name(dcmi->vdev));
1990 q->lock = &dcmi->lock;
1991 q->drv_priv = dcmi;
2005 ret = dcmi_graph_init(dcmi);
2010 ret = reset_control_assert(dcmi->rstc);
2018 ret = reset_control_deassert(dcmi->rstc);
2026 platform_set_drvdata(pdev, dcmi);
2033 v4l2_async_notifier_cleanup(&dcmi->notifier);
2035 media_entity_cleanup(&dcmi->vdev->entity);
2037 video_device_release(dcmi->vdev);
2039 v4l2_device_unregister(&dcmi->v4l2_dev);
2041 media_device_cleanup(&dcmi->mdev);
2042 dma_release_channel(dcmi->dma_chan);
2049 struct stm32_dcmi *dcmi = platform_get_drvdata(pdev);
2053 v4l2_async_notifier_unregister(&dcmi->notifier);
2054 v4l2_async_notifier_cleanup(&dcmi->notifier);
2055 media_entity_cleanup(&dcmi->vdev->entity);
2056 v4l2_device_unregister(&dcmi->v4l2_dev);
2057 media_device_cleanup(&dcmi->mdev);
2059 dma_release_channel(dcmi->dma_chan);
2066 struct stm32_dcmi *dcmi = dev_get_drvdata(dev);
2068 clk_disable_unprepare(dcmi->mclk);
2075 struct stm32_dcmi *dcmi = dev_get_drvdata(dev);
2078 ret = clk_prepare_enable(dcmi->mclk);