Lines Matching defs:fimc
31 #include <media/drv-intf/exynos-fimc.h>
34 #include "fimc-core.h"
35 #include "fimc-lite.h"
36 #include "fimc-lite-reg.h"
102 * fimc_lite_find_format - lookup fimc color format by fourcc or media bus code
133 static int fimc_lite_hw_init(struct fimc_lite *fimc, bool isp_output)
138 if (fimc->sensor == NULL)
141 if (fimc->inp_frame.fmt == NULL || fimc->out_frame.fmt == NULL)
145 si = v4l2_get_subdev_hostdata(fimc->sensor);
149 spin_lock_irqsave(&fimc->slock, flags);
151 flite_hw_set_camera_bus(fimc, si);
152 flite_hw_set_source_format(fimc, &fimc->inp_frame);
153 flite_hw_set_window_offset(fimc, &fimc->inp_frame);
154 flite_hw_set_dma_buf_mask(fimc, 0);
155 flite_hw_set_output_dma(fimc, &fimc->out_frame, !isp_output);
156 flite_hw_set_interrupt_mask(fimc);
157 flite_hw_set_test_pattern(fimc, fimc->test_pattern->val);
160 flite_hw_dump_regs(fimc, __func__);
162 spin_unlock_irqrestore(&fimc->slock, flags);
168 * Set fimc->state to indicate stream off and the hardware shut down state.
174 static int fimc_lite_reinit(struct fimc_lite *fimc, bool suspend)
180 spin_lock_irqsave(&fimc->slock, flags);
181 streaming = fimc->state & (1 << ST_SENSOR_STREAM);
183 fimc->state &= ~(1 << ST_FLITE_RUN | 1 << ST_FLITE_OFF |
186 fimc->state |= (1 << ST_FLITE_SUSPENDED);
188 fimc->state &= ~(1 << ST_FLITE_PENDING |
192 while (!suspend && !list_empty(&fimc->pending_buf_q)) {
193 buf = fimc_lite_pending_queue_pop(fimc);
197 while (!list_empty(&fimc->active_buf_q)) {
198 buf = fimc_lite_active_queue_pop(fimc);
200 fimc_lite_pending_queue_add(fimc, buf);
205 spin_unlock_irqrestore(&fimc->slock, flags);
207 flite_hw_reset(fimc);
212 return fimc_pipeline_call(&fimc->ve, set_stream, 0);
215 static int fimc_lite_stop_capture(struct fimc_lite *fimc, bool suspend)
219 if (!fimc_lite_active(fimc))
222 spin_lock_irqsave(&fimc->slock, flags);
223 set_bit(ST_FLITE_OFF, &fimc->state);
224 flite_hw_capture_stop(fimc);
225 spin_unlock_irqrestore(&fimc->slock, flags);
227 wait_event_timeout(fimc->irq_queue,
228 !test_bit(ST_FLITE_OFF, &fimc->state),
231 return fimc_lite_reinit(fimc, suspend);
234 /* Must be called with fimc.slock spinlock held. */
235 static void fimc_lite_config_update(struct fimc_lite *fimc)
237 flite_hw_set_window_offset(fimc, &fimc->inp_frame);
238 flite_hw_set_dma_window(fimc, &fimc->out_frame);
239 flite_hw_set_test_pattern(fimc, fimc->test_pattern->val);
240 clear_bit(ST_FLITE_CONFIG, &fimc->state);
245 struct fimc_lite *fimc = priv;
250 spin_lock_irqsave(&fimc->slock, flags);
252 intsrc = flite_hw_get_interrupt_source(fimc);
253 flite_hw_clear_pending_irq(fimc);
255 if (test_and_clear_bit(ST_FLITE_OFF, &fimc->state)) {
256 wake_up(&fimc->irq_queue);
261 clear_bit(ST_FLITE_RUN, &fimc->state);
262 fimc->events.data_overflow++;
266 flite_hw_clear_last_capture_end(fimc);
267 clear_bit(ST_FLITE_STREAM, &fimc->state);
268 wake_up(&fimc->irq_queue);
271 if (atomic_read(&fimc->out_path) != FIMC_IO_DMA)
275 test_bit(ST_FLITE_RUN, &fimc->state) &&
276 !list_empty(&fimc->pending_buf_q)) {
277 vbuf = fimc_lite_pending_queue_pop(fimc);
278 flite_hw_set_dma_buffer(fimc, vbuf);
279 fimc_lite_active_queue_add(fimc, vbuf);
283 test_bit(ST_FLITE_RUN, &fimc->state) &&
284 !list_empty(&fimc->active_buf_q)) {
285 vbuf = fimc_lite_active_queue_pop(fimc);
287 vbuf->vb.sequence = fimc->frame_count++;
288 flite_hw_mask_dma_buffer(fimc, vbuf->index);
292 if (test_bit(ST_FLITE_CONFIG, &fimc->state))
293 fimc_lite_config_update(fimc);
295 if (list_empty(&fimc->pending_buf_q)) {
296 flite_hw_capture_stop(fimc);
297 clear_bit(ST_FLITE_STREAM, &fimc->state);
300 set_bit(ST_FLITE_RUN, &fimc->state);
301 spin_unlock_irqrestore(&fimc->slock, flags);
307 struct fimc_lite *fimc = q->drv_priv;
311 spin_lock_irqsave(&fimc->slock, flags);
313 fimc->buf_index = 0;
314 fimc->frame_count = 0;
316 spin_unlock_irqrestore(&fimc->slock, flags);
318 ret = fimc_lite_hw_init(fimc, false);
320 fimc_lite_reinit(fimc, false);
324 set_bit(ST_FLITE_PENDING, &fimc->state);
326 if (!list_empty(&fimc->active_buf_q) &&
327 !test_and_set_bit(ST_FLITE_STREAM, &fimc->state)) {
328 flite_hw_capture_start(fimc);
330 if (!test_and_set_bit(ST_SENSOR_STREAM, &fimc->state))
331 fimc_pipeline_call(&fimc->ve, set_stream, 1);
334 flite_hw_dump_regs(fimc, __func__);
341 struct fimc_lite *fimc = q->drv_priv;
343 if (!fimc_lite_active(fimc))
346 fimc_lite_stop_capture(fimc, false);
353 struct fimc_lite *fimc = vq->drv_priv;
354 struct flite_frame *frame = &fimc->out_frame;
382 struct fimc_lite *fimc = vq->drv_priv;
385 if (fimc->out_frame.fmt == NULL)
388 for (i = 0; i < fimc->out_frame.fmt->memplanes; i++) {
389 unsigned long size = fimc->payload[i];
392 v4l2_err(&fimc->ve.vdev,
408 struct fimc_lite *fimc = vb2_get_drv_priv(vb->vb2_queue);
411 spin_lock_irqsave(&fimc->slock, flags);
414 buf->index = fimc->buf_index++;
415 if (fimc->buf_index >= fimc->reqbufs_count)
416 fimc->buf_index = 0;
418 if (!test_bit(ST_FLITE_SUSPENDED, &fimc->state) &&
419 !test_bit(ST_FLITE_STREAM, &fimc->state) &&
420 list_empty(&fimc->active_buf_q)) {
421 flite_hw_set_dma_buffer(fimc, buf);
422 fimc_lite_active_queue_add(fimc, buf);
424 fimc_lite_pending_queue_add(fimc, buf);
427 if (vb2_is_streaming(&fimc->vb_queue) &&
428 !list_empty(&fimc->pending_buf_q) &&
429 !test_and_set_bit(ST_FLITE_STREAM, &fimc->state)) {
430 flite_hw_capture_start(fimc);
431 spin_unlock_irqrestore(&fimc->slock, flags);
433 if (!test_and_set_bit(ST_SENSOR_STREAM, &fimc->state))
434 fimc_pipeline_call(&fimc->ve, set_stream, 1);
437 spin_unlock_irqrestore(&fimc->slock, flags);
450 static void fimc_lite_clear_event_counters(struct fimc_lite *fimc)
454 spin_lock_irqsave(&fimc->slock, flags);
455 memset(&fimc->events, 0, sizeof(fimc->events));
456 spin_unlock_irqrestore(&fimc->slock, flags);
461 struct fimc_lite *fimc = video_drvdata(file);
462 struct media_entity *me = &fimc->ve.vdev.entity;
465 mutex_lock(&fimc->lock);
466 if (atomic_read(&fimc->out_path) != FIMC_IO_DMA) {
471 set_bit(ST_FLITE_IN_USE, &fimc->state);
472 ret = pm_runtime_resume_and_get(&fimc->pdev->dev);
481 atomic_read(&fimc->out_path) != FIMC_IO_DMA)
486 ret = fimc_pipeline_call(&fimc->ve, open, me, true);
495 fimc_lite_clear_event_counters(fimc);
501 pm_runtime_put_sync(&fimc->pdev->dev);
503 clear_bit(ST_FLITE_IN_USE, &fimc->state);
505 mutex_unlock(&fimc->lock);
511 struct fimc_lite *fimc = video_drvdata(file);
512 struct media_entity *entity = &fimc->ve.vdev.entity;
514 mutex_lock(&fimc->lock);
517 atomic_read(&fimc->out_path) == FIMC_IO_DMA) {
518 if (fimc->streaming) {
520 fimc->streaming = false;
522 fimc_lite_stop_capture(fimc, false);
523 fimc_pipeline_call(&fimc->ve, close);
524 clear_bit(ST_FLITE_IN_USE, &fimc->state);
532 pm_runtime_put(&fimc->pdev->dev);
533 clear_bit(ST_FLITE_SUSPENDED, &fimc->state);
535 mutex_unlock(&fimc->lock);
552 static const struct fimc_fmt *fimc_lite_subdev_try_fmt(struct fimc_lite *fimc,
556 struct flite_drvdata *dd = fimc->dd;
572 struct flite_frame *sink = &fimc->inp_frame;
577 sink_fmt = v4l2_subdev_get_try_format(&fimc->subdev, cfg,
583 rect = v4l2_subdev_get_try_crop(&fimc->subdev, cfg,
598 v4l2_dbg(1, debug, &fimc->subdev, "code: %#x (%d), %dx%d\n",
604 static void fimc_lite_try_crop(struct fimc_lite *fimc, struct v4l2_rect *r)
606 struct flite_frame *frame = &fimc->inp_frame;
613 r->left = round_down(r->left, fimc->dd->win_hor_offs_align);
616 v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, sink fmt: %dx%d\n",
621 static void fimc_lite_try_compose(struct fimc_lite *fimc, struct v4l2_rect *r)
623 struct flite_frame *frame = &fimc->out_frame;
624 struct v4l2_rect *crop_rect = &fimc->inp_frame.rect;
633 r->left = round_down(r->left, fimc->dd->out_hor_offs_align);
634 r->top = clamp_t(u32, r->top, 0, fimc->out_frame.f_height - r->height);
636 v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, source fmt: %dx%d\n",
647 struct fimc_lite *fimc = video_drvdata(file);
652 dev_name(&fimc->pdev->dev));
673 struct fimc_lite *fimc = video_drvdata(file);
676 struct flite_frame *frame = &fimc->out_frame;
691 static int fimc_lite_try_fmt(struct fimc_lite *fimc,
696 struct flite_drvdata *dd = fimc->dd;
697 const struct fimc_fmt *inp_fmt = fimc->inp_frame.fmt;
738 struct fimc_lite *fimc = video_drvdata(file);
739 return fimc_lite_try_fmt(fimc, &f->fmt.pix_mp, NULL);
746 struct fimc_lite *fimc = video_drvdata(file);
747 struct flite_frame *frame = &fimc->out_frame;
751 if (vb2_is_busy(&fimc->vb_queue))
754 ret = fimc_lite_try_fmt(fimc, &f->fmt.pix_mp, &fmt);
759 fimc->payload[0] = max((pixm->width * pixm->height * fmt->depth[0]) / 8,
767 static int fimc_pipeline_validate(struct fimc_lite *fimc)
769 struct v4l2_subdev *sd = &fimc->subdev;
780 if (sd == &fimc->subdev) {
781 struct flite_frame *ff = &fimc->out_frame;
784 sink_fmt.format.code = fimc->inp_frame.fmt->mbus_code;
816 struct fimc_lite *fimc = video_drvdata(file);
817 struct media_entity *entity = &fimc->ve.vdev.entity;
820 if (fimc_lite_active(fimc))
823 ret = media_pipeline_start(entity, &fimc->ve.pipe->mp);
827 ret = fimc_pipeline_validate(fimc);
831 fimc->sensor = fimc_find_remote_sensor(&fimc->subdev.entity);
835 fimc->streaming = true;
847 struct fimc_lite *fimc = video_drvdata(file);
854 media_pipeline_stop(&fimc->ve.vdev.entity);
855 fimc->streaming = false;
862 struct fimc_lite *fimc = video_drvdata(file);
868 fimc->reqbufs_count = reqbufs->count;
876 struct fimc_lite *fimc = video_drvdata(file);
877 struct flite_frame *f = &fimc->out_frame;
902 struct fimc_lite *fimc = video_drvdata(file);
903 struct flite_frame *f = &fimc->out_frame;
911 fimc_lite_try_compose(fimc, &rect);
922 spin_lock_irqsave(&fimc->slock, flags);
924 set_bit(ST_FLITE_CONFIG, &fimc->state);
925 spin_unlock_irqrestore(&fimc->slock, flags);
954 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
957 if (WARN_ON(fimc == NULL))
962 flags, fimc->source_subdev_grp_id);
967 if (fimc->source_subdev_grp_id == 0)
968 fimc->source_subdev_grp_id = sd->grp_id;
972 fimc->source_subdev_grp_id = 0;
973 fimc->sensor = NULL;
979 atomic_set(&fimc->out_path, FIMC_IO_NONE);
981 atomic_set(&fimc->out_path, FIMC_IO_DMA);
986 atomic_set(&fimc->out_path, FIMC_IO_NONE);
988 atomic_set(&fimc->out_path, FIMC_IO_ISP);
1031 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1033 struct flite_frame *f = &fimc->inp_frame;
1041 mutex_lock(&fimc->lock);
1054 mutex_unlock(&fimc->lock);
1062 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1064 struct flite_frame *sink = &fimc->inp_frame;
1065 struct flite_frame *source = &fimc->out_frame;
1071 mutex_lock(&fimc->lock);
1073 if ((atomic_read(&fimc->out_path) == FIMC_IO_ISP &&
1075 (atomic_read(&fimc->out_path) == FIMC_IO_DMA &&
1076 vb2_is_busy(&fimc->vb_queue))) {
1077 mutex_unlock(&fimc->lock);
1081 ffmt = fimc_lite_subdev_try_fmt(fimc, cfg, fmt);
1095 mutex_unlock(&fimc->lock);
1114 mutex_unlock(&fimc->lock);
1122 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1123 struct flite_frame *f = &fimc->inp_frame;
1135 mutex_lock(&fimc->lock);
1144 mutex_unlock(&fimc->lock);
1157 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1158 struct flite_frame *f = &fimc->inp_frame;
1164 mutex_lock(&fimc->lock);
1165 fimc_lite_try_crop(fimc, &sel->r);
1171 spin_lock_irqsave(&fimc->slock, flags);
1174 fimc->out_frame.rect = sel->r;
1175 set_bit(ST_FLITE_CONFIG, &fimc->state);
1176 spin_unlock_irqrestore(&fimc->slock, flags);
1178 mutex_unlock(&fimc->lock);
1189 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1200 fimc->sensor = fimc_find_remote_sensor(&sd->entity);
1202 if (atomic_read(&fimc->out_path) != FIMC_IO_ISP)
1205 mutex_lock(&fimc->lock);
1207 flite_hw_reset(fimc);
1208 ret = fimc_lite_hw_init(fimc, true);
1210 spin_lock_irqsave(&fimc->slock, flags);
1211 flite_hw_capture_start(fimc);
1212 spin_unlock_irqrestore(&fimc->slock, flags);
1215 set_bit(ST_FLITE_OFF, &fimc->state);
1217 spin_lock_irqsave(&fimc->slock, flags);
1218 flite_hw_capture_stop(fimc);
1219 spin_unlock_irqrestore(&fimc->slock, flags);
1221 ret = wait_event_timeout(fimc->irq_queue,
1222 !test_bit(ST_FLITE_OFF, &fimc->state),
1226 clear_bit(ST_FLITE_RUN, &fimc->state);
1229 mutex_unlock(&fimc->lock);
1235 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1237 flite_hw_dump_regs(fimc, __func__);
1243 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1244 struct vb2_queue *q = &fimc->vb_queue;
1245 struct video_device *vfd = &fimc->ve.vdev;
1249 atomic_set(&fimc->out_path, FIMC_IO_DMA);
1251 snprintf(vfd->name, sizeof(vfd->name), "fimc-lite.%d.capture",
1252 fimc->index);
1261 fimc->reqbufs_count = 0;
1263 INIT_LIST_HEAD(&fimc->pending_buf_q);
1264 INIT_LIST_HEAD(&fimc->active_buf_q);
1272 q->drv_priv = fimc;
1274 q->lock = &fimc->lock;
1275 q->dev = &fimc->pdev->dev;
1281 fimc->vd_pad.flags = MEDIA_PAD_FL_SINK;
1282 ret = media_entity_pads_init(&vfd->entity, 1, &fimc->vd_pad);
1286 video_set_drvdata(vfd, fimc);
1287 fimc->ve.pipe = v4l2_get_subdev_hostdata(sd);
1292 fimc->ve.pipe = NULL;
1303 struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
1305 if (fimc == NULL)
1308 mutex_lock(&fimc->lock);
1310 if (video_is_registered(&fimc->ve.vdev)) {
1311 video_unregister_device(&fimc->ve.vdev);
1312 media_entity_cleanup(&fimc->ve.vdev.entity);
1313 fimc->ve.pipe = NULL;
1316 mutex_unlock(&fimc->lock);
1348 struct fimc_lite *fimc = container_of(ctrl->handler, struct fimc_lite,
1350 set_bit(ST_FLITE_CONFIG, &fimc->state);
1366 static void fimc_lite_set_default_config(struct fimc_lite *fimc)
1368 struct flite_frame *sink = &fimc->inp_frame;
1369 struct flite_frame *source = &fimc->out_frame;
1383 static int fimc_lite_create_capture_subdev(struct fimc_lite *fimc)
1385 struct v4l2_ctrl_handler *handler = &fimc->ctrl_handler;
1386 struct v4l2_subdev *sd = &fimc->subdev;
1391 snprintf(sd->name, sizeof(sd->name), "FIMC-LITE.%d", fimc->index);
1393 fimc->subdev_pads[FLITE_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
1394 fimc->subdev_pads[FLITE_SD_PAD_SOURCE_DMA].flags = MEDIA_PAD_FL_SOURCE;
1395 fimc->subdev_pads[FLITE_SD_PAD_SOURCE_ISP].flags = MEDIA_PAD_FL_SOURCE;
1397 fimc->subdev_pads);
1402 fimc->test_pattern = v4l2_ctrl_new_custom(handler, &fimc_lite_ctrl,
1414 v4l2_set_subdevdata(sd, fimc);
1419 static void fimc_lite_unregister_capture_subdev(struct fimc_lite *fimc)
1421 struct v4l2_subdev *sd = &fimc->subdev;
1425 v4l2_ctrl_handler_free(&fimc->ctrl_handler);
1429 static void fimc_lite_clk_put(struct fimc_lite *fimc)
1431 if (IS_ERR(fimc->clock))
1434 clk_put(fimc->clock);
1435 fimc->clock = ERR_PTR(-EINVAL);
1438 static int fimc_lite_clk_get(struct fimc_lite *fimc)
1440 fimc->clock = clk_get(&fimc->pdev->dev, FLITE_CLK_NAME);
1441 return PTR_ERR_OR_ZERO(fimc->clock);
1451 struct fimc_lite *fimc;
1458 fimc = devm_kzalloc(dev, sizeof(*fimc), GFP_KERNEL);
1459 if (!fimc)
1465 fimc->index = of_alias_get_id(dev->of_node, "fimc-lite");
1467 if (!drv_data || fimc->index >= drv_data->num_instances ||
1468 fimc->index < 0) {
1473 fimc->dd = drv_data;
1474 fimc->pdev = pdev;
1476 init_waitqueue_head(&fimc->irq_queue);
1477 spin_lock_init(&fimc->slock);
1478 mutex_init(&fimc->lock);
1481 fimc->regs = devm_ioremap_resource(dev, res);
1482 if (IS_ERR(fimc->regs))
1483 return PTR_ERR(fimc->regs);
1491 ret = fimc_lite_clk_get(fimc);
1496 0, dev_name(dev), fimc);
1503 ret = fimc_lite_create_capture_subdev(fimc);
1507 platform_set_drvdata(pdev, fimc);
1511 ret = clk_prepare_enable(fimc->clock);
1518 fimc_lite_set_default_config(fimc);
1521 fimc->index);
1525 fimc_lite_unregister_capture_subdev(fimc);
1527 fimc_lite_clk_put(fimc);
1534 struct fimc_lite *fimc = dev_get_drvdata(dev);
1536 clk_prepare_enable(fimc->clock);
1542 struct fimc_lite *fimc = dev_get_drvdata(dev);
1544 clk_disable_unprepare(fimc->clock);
1552 struct fimc_lite *fimc = dev_get_drvdata(dev);
1557 spin_lock_irqsave(&fimc->slock, flags);
1558 if (!test_and_clear_bit(ST_LPM, &fimc->state) ||
1559 !test_bit(ST_FLITE_IN_USE, &fimc->state)) {
1560 spin_unlock_irqrestore(&fimc->slock, flags);
1563 flite_hw_reset(fimc);
1564 spin_unlock_irqrestore(&fimc->slock, flags);
1566 if (!test_and_clear_bit(ST_FLITE_SUSPENDED, &fimc->state))
1569 INIT_LIST_HEAD(&fimc->active_buf_q);
1570 fimc_pipeline_call(&fimc->ve, open,
1571 &fimc->ve.vdev.entity, false);
1572 fimc_lite_hw_init(fimc, atomic_read(&fimc->out_path) == FIMC_IO_ISP);
1573 clear_bit(ST_FLITE_SUSPENDED, &fimc->state);
1575 for (i = 0; i < fimc->reqbufs_count; i++) {
1576 if (list_empty(&fimc->pending_buf_q))
1578 buf = fimc_lite_pending_queue_pop(fimc);
1586 struct fimc_lite *fimc = dev_get_drvdata(dev);
1587 bool suspend = test_bit(ST_FLITE_IN_USE, &fimc->state);
1590 if (test_and_set_bit(ST_LPM, &fimc->state))
1593 ret = fimc_lite_stop_capture(fimc, suspend);
1594 if (ret < 0 || !fimc_lite_active(fimc))
1597 return fimc_pipeline_call(&fimc->ve, close);
1603 struct fimc_lite *fimc = platform_get_drvdata(pdev);
1607 clk_disable_unprepare(fimc->clock);
1611 fimc_lite_unregister_capture_subdev(fimc);
1613 fimc_lite_clk_put(fimc);
1649 .compatible = "samsung,exynos4212-fimc-lite",
1653 .compatible = "samsung,exynos5250-fimc-lite",