2 * Samsung EXYNOS FIMC-LITE (camera host interface) driver
4 * Copyright (C) 2012 Samsung Electronics Co., Ltd.
5 * Sylwester Nawrocki <s.nawrocki@samsung.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 #define pr_fmt(fmt) "%s:%d " fmt, __func__, __LINE__
13 #include <linux/bug.h>
14 #include <linux/device.h>
15 #include <linux/errno.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/platform_device.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/slab.h>
24 #include <linux/videodev2.h>
26 #include <media/v4l2-device.h>
27 #include <media/v4l2-ioctl.h>
28 #include <media/v4l2-mem2mem.h>
29 #include <media/videobuf2-core.h>
30 #include <media/videobuf2-dma-contig.h>
31 #include <media/s5p_fimc.h>
33 #include "fimc-mdevice.h"
34 #include "fimc-core.h"
35 #include "fimc-lite.h"
36 #include "fimc-lite-reg.h"
39 module_param(debug
, int, 0644);
41 static const struct fimc_fmt fimc_lite_formats
[] = {
43 .name
= "YUV 4:2:2 packed, YCbYCr",
44 .fourcc
= V4L2_PIX_FMT_YUYV
,
46 .color
= FIMC_FMT_YCBYCR422
,
48 .mbus_code
= V4L2_MBUS_FMT_YUYV8_2X8
,
50 .name
= "YUV 4:2:2 packed, CbYCrY",
51 .fourcc
= V4L2_PIX_FMT_UYVY
,
53 .color
= FIMC_FMT_CBYCRY422
,
55 .mbus_code
= V4L2_MBUS_FMT_UYVY8_2X8
,
57 .name
= "YUV 4:2:2 packed, CrYCbY",
58 .fourcc
= V4L2_PIX_FMT_VYUY
,
60 .color
= FIMC_FMT_CRYCBY422
,
62 .mbus_code
= V4L2_MBUS_FMT_VYUY8_2X8
,
64 .name
= "YUV 4:2:2 packed, YCrYCb",
65 .fourcc
= V4L2_PIX_FMT_YVYU
,
67 .color
= FIMC_FMT_YCRYCB422
,
69 .mbus_code
= V4L2_MBUS_FMT_YVYU8_2X8
,
71 .name
= "RAW8 (GRBG)",
72 .fourcc
= V4L2_PIX_FMT_SGRBG8
,
74 .color
= FIMC_FMT_RAW8
,
76 .mbus_code
= V4L2_MBUS_FMT_SGRBG8_1X8
,
78 .name
= "RAW10 (GRBG)",
79 .fourcc
= V4L2_PIX_FMT_SGRBG10
,
81 .color
= FIMC_FMT_RAW10
,
83 .mbus_code
= V4L2_MBUS_FMT_SGRBG10_1X10
,
85 .name
= "RAW12 (GRBG)",
86 .fourcc
= V4L2_PIX_FMT_SGRBG12
,
88 .color
= FIMC_FMT_RAW12
,
90 .mbus_code
= V4L2_MBUS_FMT_SGRBG12_1X12
,
95 * fimc_lite_find_format - lookup fimc color format by fourcc or media bus code
96 * @pixelformat: fourcc to match, ignored if null
97 * @mbus_code: media bus code to match, ignored if null
98 * @index: index to the fimc_lite_formats array, ignored if negative
100 static const struct fimc_fmt
*fimc_lite_find_format(const u32
*pixelformat
,
101 const u32
*mbus_code
, int index
)
103 const struct fimc_fmt
*fmt
, *def_fmt
= NULL
;
107 if (index
>= (int)ARRAY_SIZE(fimc_lite_formats
))
110 for (i
= 0; i
< ARRAY_SIZE(fimc_lite_formats
); ++i
) {
111 fmt
= &fimc_lite_formats
[i
];
112 if (pixelformat
&& fmt
->fourcc
== *pixelformat
)
114 if (mbus_code
&& fmt
->mbus_code
== *mbus_code
)
123 static int fimc_lite_hw_init(struct fimc_lite
*fimc
)
125 struct fimc_pipeline
*pipeline
= &fimc
->pipeline
;
126 struct fimc_sensor_info
*sensor
;
129 if (pipeline
->subdevs
[IDX_SENSOR
] == NULL
)
132 if (fimc
->fmt
== NULL
)
135 sensor
= v4l2_get_subdev_hostdata(pipeline
->subdevs
[IDX_SENSOR
]);
136 spin_lock_irqsave(&fimc
->slock
, flags
);
138 flite_hw_set_camera_bus(fimc
, &sensor
->pdata
);
139 flite_hw_set_source_format(fimc
, &fimc
->inp_frame
);
140 flite_hw_set_window_offset(fimc
, &fimc
->inp_frame
);
141 flite_hw_set_output_dma(fimc
, &fimc
->out_frame
, true);
142 flite_hw_set_interrupt_mask(fimc
);
143 flite_hw_set_test_pattern(fimc
, fimc
->test_pattern
->val
);
146 flite_hw_dump_regs(fimc
, __func__
);
148 spin_unlock_irqrestore(&fimc
->slock
, flags
);
153 * Reinitialize the driver so it is ready to start the streaming again.
154 * Set fimc->state to indicate stream off and the hardware shut down state.
155 * If not suspending (@suspend is false), return any buffers to videobuf2.
156 * Otherwise put any owned buffers onto the pending buffers queue, so they
157 * can be re-spun when the device is being resumed. Also perform FIMC
158 * software reset and disable streaming on the whole pipeline if required.
160 static int fimc_lite_reinit(struct fimc_lite
*fimc
, bool suspend
)
162 struct flite_buffer
*buf
;
166 spin_lock_irqsave(&fimc
->slock
, flags
);
167 streaming
= fimc
->state
& (1 << ST_SENSOR_STREAM
);
169 fimc
->state
&= ~(1 << ST_FLITE_RUN
| 1 << ST_FLITE_OFF
|
170 1 << ST_FLITE_STREAM
| 1 << ST_SENSOR_STREAM
);
172 fimc
->state
|= (1 << ST_FLITE_SUSPENDED
);
174 fimc
->state
&= ~(1 << ST_FLITE_PENDING
|
175 1 << ST_FLITE_SUSPENDED
);
177 /* Release unused buffers */
178 while (!suspend
&& !list_empty(&fimc
->pending_buf_q
)) {
179 buf
= fimc_lite_pending_queue_pop(fimc
);
180 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
182 /* If suspending put unused buffers onto pending queue */
183 while (!list_empty(&fimc
->active_buf_q
)) {
184 buf
= fimc_lite_active_queue_pop(fimc
);
186 fimc_lite_pending_queue_add(fimc
, buf
);
188 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
191 spin_unlock_irqrestore(&fimc
->slock
, flags
);
193 flite_hw_reset(fimc
);
198 return fimc_pipeline_call(fimc
, set_stream
, &fimc
->pipeline
, 0);
201 static int fimc_lite_stop_capture(struct fimc_lite
*fimc
, bool suspend
)
205 if (!fimc_lite_active(fimc
))
208 spin_lock_irqsave(&fimc
->slock
, flags
);
209 set_bit(ST_FLITE_OFF
, &fimc
->state
);
210 flite_hw_capture_stop(fimc
);
211 spin_unlock_irqrestore(&fimc
->slock
, flags
);
213 wait_event_timeout(fimc
->irq_queue
,
214 !test_bit(ST_FLITE_OFF
, &fimc
->state
),
215 (2*HZ
/10)); /* 200 ms */
217 return fimc_lite_reinit(fimc
, suspend
);
220 /* Must be called with fimc.slock spinlock held. */
221 static void fimc_lite_config_update(struct fimc_lite
*fimc
)
223 flite_hw_set_window_offset(fimc
, &fimc
->inp_frame
);
224 flite_hw_set_dma_window(fimc
, &fimc
->out_frame
);
225 flite_hw_set_test_pattern(fimc
, fimc
->test_pattern
->val
);
226 clear_bit(ST_FLITE_CONFIG
, &fimc
->state
);
229 static irqreturn_t
flite_irq_handler(int irq
, void *priv
)
231 struct fimc_lite
*fimc
= priv
;
232 struct flite_buffer
*vbuf
;
238 spin_lock_irqsave(&fimc
->slock
, flags
);
240 intsrc
= flite_hw_get_interrupt_source(fimc
);
241 flite_hw_clear_pending_irq(fimc
);
243 if (test_and_clear_bit(ST_FLITE_OFF
, &fimc
->state
)) {
244 wake_up(&fimc
->irq_queue
);
248 if (intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_OVERFLOW
) {
249 clear_bit(ST_FLITE_RUN
, &fimc
->state
);
250 fimc
->events
.data_overflow
++;
253 if (intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_LASTCAPEND
) {
254 flite_hw_clear_last_capture_end(fimc
);
255 clear_bit(ST_FLITE_STREAM
, &fimc
->state
);
256 wake_up(&fimc
->irq_queue
);
259 if (fimc
->out_path
!= FIMC_IO_DMA
)
262 if ((intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_FRMSTART
) &&
263 test_bit(ST_FLITE_RUN
, &fimc
->state
) &&
264 !list_empty(&fimc
->active_buf_q
) &&
265 !list_empty(&fimc
->pending_buf_q
)) {
266 vbuf
= fimc_lite_active_queue_pop(fimc
);
268 tv
= &vbuf
->vb
.v4l2_buf
.timestamp
;
269 tv
->tv_sec
= ts
.tv_sec
;
270 tv
->tv_usec
= ts
.tv_nsec
/ NSEC_PER_USEC
;
271 vbuf
->vb
.v4l2_buf
.sequence
= fimc
->frame_count
++;
272 vb2_buffer_done(&vbuf
->vb
, VB2_BUF_STATE_DONE
);
274 vbuf
= fimc_lite_pending_queue_pop(fimc
);
275 flite_hw_set_output_addr(fimc
, vbuf
->paddr
);
276 fimc_lite_active_queue_add(fimc
, vbuf
);
279 if (test_bit(ST_FLITE_CONFIG
, &fimc
->state
))
280 fimc_lite_config_update(fimc
);
282 if (list_empty(&fimc
->pending_buf_q
)) {
283 flite_hw_capture_stop(fimc
);
284 clear_bit(ST_FLITE_STREAM
, &fimc
->state
);
287 set_bit(ST_FLITE_RUN
, &fimc
->state
);
288 spin_unlock_irqrestore(&fimc
->slock
, flags
);
292 static int start_streaming(struct vb2_queue
*q
, unsigned int count
)
294 struct fimc_lite
*fimc
= q
->drv_priv
;
297 fimc
->frame_count
= 0;
299 ret
= fimc_lite_hw_init(fimc
);
301 fimc_lite_reinit(fimc
, false);
305 set_bit(ST_FLITE_PENDING
, &fimc
->state
);
307 if (!list_empty(&fimc
->active_buf_q
) &&
308 !test_and_set_bit(ST_FLITE_STREAM
, &fimc
->state
)) {
309 flite_hw_capture_start(fimc
);
311 if (!test_and_set_bit(ST_SENSOR_STREAM
, &fimc
->state
))
312 fimc_pipeline_call(fimc
, set_stream
,
316 flite_hw_dump_regs(fimc
, __func__
);
321 static int stop_streaming(struct vb2_queue
*q
)
323 struct fimc_lite
*fimc
= q
->drv_priv
;
325 if (!fimc_lite_active(fimc
))
328 return fimc_lite_stop_capture(fimc
, false);
331 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*pfmt
,
332 unsigned int *num_buffers
, unsigned int *num_planes
,
333 unsigned int sizes
[], void *allocators
[])
335 const struct v4l2_pix_format_mplane
*pixm
= NULL
;
336 struct fimc_lite
*fimc
= vq
->drv_priv
;
337 struct flite_frame
*frame
= &fimc
->out_frame
;
338 const struct fimc_fmt
*fmt
= fimc
->fmt
;
343 pixm
= &pfmt
->fmt
.pix_mp
;
344 fmt
= fimc_lite_find_format(&pixm
->pixelformat
, NULL
, -1);
345 wh
= pixm
->width
* pixm
->height
;
347 wh
= frame
->f_width
* frame
->f_height
;
353 *num_planes
= fmt
->memplanes
;
355 for (i
= 0; i
< fmt
->memplanes
; i
++) {
356 unsigned int size
= (wh
* fmt
->depth
[i
]) / 8;
358 sizes
[i
] = max(size
, pixm
->plane_fmt
[i
].sizeimage
);
361 allocators
[i
] = fimc
->alloc_ctx
;
367 static int buffer_prepare(struct vb2_buffer
*vb
)
369 struct vb2_queue
*vq
= vb
->vb2_queue
;
370 struct fimc_lite
*fimc
= vq
->drv_priv
;
373 if (fimc
->fmt
== NULL
)
376 for (i
= 0; i
< fimc
->fmt
->memplanes
; i
++) {
377 unsigned long size
= fimc
->payload
[i
];
379 if (vb2_plane_size(vb
, i
) < size
) {
381 "User buffer too small (%ld < %ld)\n",
382 vb2_plane_size(vb
, i
), size
);
385 vb2_set_plane_payload(vb
, i
, size
);
391 static void buffer_queue(struct vb2_buffer
*vb
)
393 struct flite_buffer
*buf
394 = container_of(vb
, struct flite_buffer
, vb
);
395 struct fimc_lite
*fimc
= vb2_get_drv_priv(vb
->vb2_queue
);
398 spin_lock_irqsave(&fimc
->slock
, flags
);
399 buf
->paddr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
401 if (!test_bit(ST_FLITE_SUSPENDED
, &fimc
->state
) &&
402 !test_bit(ST_FLITE_STREAM
, &fimc
->state
) &&
403 list_empty(&fimc
->active_buf_q
)) {
404 flite_hw_set_output_addr(fimc
, buf
->paddr
);
405 fimc_lite_active_queue_add(fimc
, buf
);
407 fimc_lite_pending_queue_add(fimc
, buf
);
410 if (vb2_is_streaming(&fimc
->vb_queue
) &&
411 !list_empty(&fimc
->pending_buf_q
) &&
412 !test_and_set_bit(ST_FLITE_STREAM
, &fimc
->state
)) {
413 flite_hw_capture_start(fimc
);
414 spin_unlock_irqrestore(&fimc
->slock
, flags
);
416 if (!test_and_set_bit(ST_SENSOR_STREAM
, &fimc
->state
))
417 fimc_pipeline_call(fimc
, set_stream
,
421 spin_unlock_irqrestore(&fimc
->slock
, flags
);
424 static void fimc_lock(struct vb2_queue
*vq
)
426 struct fimc_lite
*fimc
= vb2_get_drv_priv(vq
);
427 mutex_lock(&fimc
->lock
);
430 static void fimc_unlock(struct vb2_queue
*vq
)
432 struct fimc_lite
*fimc
= vb2_get_drv_priv(vq
);
433 mutex_unlock(&fimc
->lock
);
436 static const struct vb2_ops fimc_lite_qops
= {
437 .queue_setup
= queue_setup
,
438 .buf_prepare
= buffer_prepare
,
439 .buf_queue
= buffer_queue
,
440 .wait_prepare
= fimc_unlock
,
441 .wait_finish
= fimc_lock
,
442 .start_streaming
= start_streaming
,
443 .stop_streaming
= stop_streaming
,
446 static void fimc_lite_clear_event_counters(struct fimc_lite
*fimc
)
450 spin_lock_irqsave(&fimc
->slock
, flags
);
451 memset(&fimc
->events
, 0, sizeof(fimc
->events
));
452 spin_unlock_irqrestore(&fimc
->slock
, flags
);
455 static int fimc_lite_open(struct file
*file
)
457 struct fimc_lite
*fimc
= video_drvdata(file
);
460 if (mutex_lock_interruptible(&fimc
->lock
))
463 set_bit(ST_FLITE_IN_USE
, &fimc
->state
);
464 ret
= pm_runtime_get_sync(&fimc
->pdev
->dev
);
468 ret
= v4l2_fh_open(file
);
472 if (++fimc
->ref_count
== 1 && fimc
->out_path
== FIMC_IO_DMA
) {
473 ret
= fimc_pipeline_call(fimc
, open
, &fimc
->pipeline
,
474 &fimc
->vfd
.entity
, true);
476 pm_runtime_put_sync(&fimc
->pdev
->dev
);
478 v4l2_fh_release(file
);
479 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
482 fimc_lite_clear_event_counters(fimc
);
485 mutex_unlock(&fimc
->lock
);
489 static int fimc_lite_close(struct file
*file
)
491 struct fimc_lite
*fimc
= video_drvdata(file
);
494 if (mutex_lock_interruptible(&fimc
->lock
))
497 if (--fimc
->ref_count
== 0 && fimc
->out_path
== FIMC_IO_DMA
) {
498 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
499 fimc_lite_stop_capture(fimc
, false);
500 fimc_pipeline_call(fimc
, close
, &fimc
->pipeline
);
501 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
504 pm_runtime_put(&fimc
->pdev
->dev
);
506 if (fimc
->ref_count
== 0)
507 vb2_queue_release(&fimc
->vb_queue
);
509 ret
= v4l2_fh_release(file
);
511 mutex_unlock(&fimc
->lock
);
515 static unsigned int fimc_lite_poll(struct file
*file
,
516 struct poll_table_struct
*wait
)
518 struct fimc_lite
*fimc
= video_drvdata(file
);
521 if (mutex_lock_interruptible(&fimc
->lock
))
524 ret
= vb2_poll(&fimc
->vb_queue
, file
, wait
);
525 mutex_unlock(&fimc
->lock
);
530 static int fimc_lite_mmap(struct file
*file
, struct vm_area_struct
*vma
)
532 struct fimc_lite
*fimc
= video_drvdata(file
);
535 if (mutex_lock_interruptible(&fimc
->lock
))
538 ret
= vb2_mmap(&fimc
->vb_queue
, vma
);
539 mutex_unlock(&fimc
->lock
);
544 static const struct v4l2_file_operations fimc_lite_fops
= {
545 .owner
= THIS_MODULE
,
546 .open
= fimc_lite_open
,
547 .release
= fimc_lite_close
,
548 .poll
= fimc_lite_poll
,
549 .unlocked_ioctl
= video_ioctl2
,
550 .mmap
= fimc_lite_mmap
,
554 * Format and crop negotiation helpers
557 static const struct fimc_fmt
*fimc_lite_try_format(struct fimc_lite
*fimc
,
558 u32
*width
, u32
*height
,
559 u32
*code
, u32
*fourcc
, int pad
)
561 struct flite_variant
*variant
= fimc
->variant
;
562 const struct fimc_fmt
*fmt
;
564 fmt
= fimc_lite_find_format(fourcc
, code
, 0);
569 *code
= fmt
->mbus_code
;
571 *fourcc
= fmt
->fourcc
;
573 if (pad
== FLITE_SD_PAD_SINK
) {
574 v4l_bound_align_image(width
, 8, variant
->max_width
,
575 ffs(variant
->out_width_align
) - 1,
576 height
, 0, variant
->max_height
, 0, 0);
578 v4l_bound_align_image(width
, 8, fimc
->inp_frame
.rect
.width
,
579 ffs(variant
->out_width_align
) - 1,
580 height
, 0, fimc
->inp_frame
.rect
.height
,
584 v4l2_dbg(1, debug
, &fimc
->subdev
, "code: 0x%x, %dx%d\n",
585 code
? *code
: 0, *width
, *height
);
590 static void fimc_lite_try_crop(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
592 struct flite_frame
*frame
= &fimc
->inp_frame
;
594 v4l_bound_align_image(&r
->width
, 0, frame
->f_width
, 0,
595 &r
->height
, 0, frame
->f_height
, 0, 0);
597 /* Adjust left/top if cropping rectangle got out of bounds */
598 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
599 r
->left
= round_down(r
->left
, fimc
->variant
->win_hor_offs_align
);
600 r
->top
= clamp_t(u32
, r
->top
, 0, frame
->f_height
- r
->height
);
602 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, sink fmt: %dx%d",
603 r
->left
, r
->top
, r
->width
, r
->height
,
604 frame
->f_width
, frame
->f_height
);
607 static void fimc_lite_try_compose(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
609 struct flite_frame
*frame
= &fimc
->out_frame
;
610 struct v4l2_rect
*crop_rect
= &fimc
->inp_frame
.rect
;
612 /* Scaling is not supported so we enforce compose rectangle size
613 same as size of the sink crop rectangle. */
614 r
->width
= crop_rect
->width
;
615 r
->height
= crop_rect
->height
;
617 /* Adjust left/top if the composing rectangle got out of bounds */
618 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
619 r
->left
= round_down(r
->left
, fimc
->variant
->out_hor_offs_align
);
620 r
->top
= clamp_t(u32
, r
->top
, 0, fimc
->out_frame
.f_height
- r
->height
);
622 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, source fmt: %dx%d",
623 r
->left
, r
->top
, r
->width
, r
->height
,
624 frame
->f_width
, frame
->f_height
);
628 * Video node ioctl operations
630 static int fimc_vidioc_querycap_capture(struct file
*file
, void *priv
,
631 struct v4l2_capability
*cap
)
633 strlcpy(cap
->driver
, FIMC_LITE_DRV_NAME
, sizeof(cap
->driver
));
634 cap
->bus_info
[0] = 0;
636 cap
->capabilities
= V4L2_CAP_STREAMING
;
640 static int fimc_lite_enum_fmt_mplane(struct file
*file
, void *priv
,
641 struct v4l2_fmtdesc
*f
)
643 const struct fimc_fmt
*fmt
;
645 if (f
->index
>= ARRAY_SIZE(fimc_lite_formats
))
648 fmt
= &fimc_lite_formats
[f
->index
];
649 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
650 f
->pixelformat
= fmt
->fourcc
;
655 static int fimc_lite_g_fmt_mplane(struct file
*file
, void *fh
,
656 struct v4l2_format
*f
)
658 struct fimc_lite
*fimc
= video_drvdata(file
);
659 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
660 struct v4l2_plane_pix_format
*plane_fmt
= &pixm
->plane_fmt
[0];
661 struct flite_frame
*frame
= &fimc
->out_frame
;
662 const struct fimc_fmt
*fmt
= fimc
->fmt
;
664 plane_fmt
->bytesperline
= (frame
->f_width
* fmt
->depth
[0]) / 8;
665 plane_fmt
->sizeimage
= plane_fmt
->bytesperline
* frame
->f_height
;
667 pixm
->num_planes
= fmt
->memplanes
;
668 pixm
->pixelformat
= fmt
->fourcc
;
669 pixm
->width
= frame
->f_width
;
670 pixm
->height
= frame
->f_height
;
671 pixm
->field
= V4L2_FIELD_NONE
;
672 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
676 static int fimc_lite_try_fmt(struct fimc_lite
*fimc
,
677 struct v4l2_pix_format_mplane
*pixm
,
678 const struct fimc_fmt
**ffmt
)
680 struct flite_variant
*variant
= fimc
->variant
;
681 u32 bpl
= pixm
->plane_fmt
[0].bytesperline
;
682 const struct fimc_fmt
*fmt
;
684 fmt
= fimc_lite_find_format(&pixm
->pixelformat
, NULL
, 0);
685 if (WARN_ON(fmt
== NULL
))
689 v4l_bound_align_image(&pixm
->width
, 8, variant
->max_width
,
690 ffs(variant
->out_width_align
) - 1,
691 &pixm
->height
, 0, variant
->max_height
, 0, 0);
693 if ((bpl
== 0 || ((bpl
* 8) / fmt
->depth
[0]) < pixm
->width
))
694 pixm
->plane_fmt
[0].bytesperline
= (pixm
->width
*
697 if (pixm
->plane_fmt
[0].sizeimage
== 0)
698 pixm
->plane_fmt
[0].sizeimage
= (pixm
->width
* pixm
->height
*
700 pixm
->num_planes
= fmt
->memplanes
;
701 pixm
->pixelformat
= fmt
->fourcc
;
702 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
703 pixm
->field
= V4L2_FIELD_NONE
;
707 static int fimc_lite_try_fmt_mplane(struct file
*file
, void *fh
,
708 struct v4l2_format
*f
)
710 struct fimc_lite
*fimc
= video_drvdata(file
);
712 return fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, NULL
);
715 static int fimc_lite_s_fmt_mplane(struct file
*file
, void *priv
,
716 struct v4l2_format
*f
)
718 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
719 struct fimc_lite
*fimc
= video_drvdata(file
);
720 struct flite_frame
*frame
= &fimc
->out_frame
;
721 const struct fimc_fmt
*fmt
= NULL
;
724 if (vb2_is_busy(&fimc
->vb_queue
))
727 ret
= fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, &fmt
);
732 fimc
->payload
[0] = max((pixm
->width
* pixm
->height
* fmt
->depth
[0]) / 8,
733 pixm
->plane_fmt
[0].sizeimage
);
734 frame
->f_width
= pixm
->width
;
735 frame
->f_height
= pixm
->height
;
740 static int fimc_pipeline_validate(struct fimc_lite
*fimc
)
742 struct v4l2_subdev
*sd
= &fimc
->subdev
;
743 struct v4l2_subdev_format sink_fmt
, src_fmt
;
744 struct media_pad
*pad
;
748 /* Retrieve format at the sink pad */
749 pad
= &sd
->entity
.pads
[0];
750 if (!(pad
->flags
& MEDIA_PAD_FL_SINK
))
752 /* Don't call FIMC subdev operation to avoid nested locking */
753 if (sd
== &fimc
->subdev
) {
754 struct flite_frame
*ff
= &fimc
->out_frame
;
755 sink_fmt
.format
.width
= ff
->f_width
;
756 sink_fmt
.format
.height
= ff
->f_height
;
757 sink_fmt
.format
.code
= fimc
->fmt
->mbus_code
;
759 sink_fmt
.pad
= pad
->index
;
760 sink_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
761 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
,
763 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
766 /* Retrieve format at the source pad */
767 pad
= media_entity_remote_source(pad
);
769 media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
772 sd
= media_entity_to_v4l2_subdev(pad
->entity
);
773 src_fmt
.pad
= pad
->index
;
774 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
775 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &src_fmt
);
776 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
779 if (src_fmt
.format
.width
!= sink_fmt
.format
.width
||
780 src_fmt
.format
.height
!= sink_fmt
.format
.height
||
781 src_fmt
.format
.code
!= sink_fmt
.format
.code
)
787 static int fimc_lite_streamon(struct file
*file
, void *priv
,
788 enum v4l2_buf_type type
)
790 struct fimc_lite
*fimc
= video_drvdata(file
);
791 struct v4l2_subdev
*sensor
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
792 struct fimc_pipeline
*p
= &fimc
->pipeline
;
795 if (fimc_lite_active(fimc
))
798 ret
= media_entity_pipeline_start(&sensor
->entity
, p
->m_pipeline
);
802 ret
= fimc_pipeline_validate(fimc
);
804 media_entity_pipeline_stop(&sensor
->entity
);
808 return vb2_streamon(&fimc
->vb_queue
, type
);
811 static int fimc_lite_streamoff(struct file
*file
, void *priv
,
812 enum v4l2_buf_type type
)
814 struct fimc_lite
*fimc
= video_drvdata(file
);
815 struct v4l2_subdev
*sd
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
818 ret
= vb2_streamoff(&fimc
->vb_queue
, type
);
820 media_entity_pipeline_stop(&sd
->entity
);
824 static int fimc_lite_reqbufs(struct file
*file
, void *priv
,
825 struct v4l2_requestbuffers
*reqbufs
)
827 struct fimc_lite
*fimc
= video_drvdata(file
);
830 reqbufs
->count
= max_t(u32
, FLITE_REQ_BUFS_MIN
, reqbufs
->count
);
831 ret
= vb2_reqbufs(&fimc
->vb_queue
, reqbufs
);
833 fimc
->reqbufs_count
= reqbufs
->count
;
838 static int fimc_lite_querybuf(struct file
*file
, void *priv
,
839 struct v4l2_buffer
*buf
)
841 struct fimc_lite
*fimc
= video_drvdata(file
);
843 return vb2_querybuf(&fimc
->vb_queue
, buf
);
846 static int fimc_lite_qbuf(struct file
*file
, void *priv
,
847 struct v4l2_buffer
*buf
)
849 struct fimc_lite
*fimc
= video_drvdata(file
);
851 return vb2_qbuf(&fimc
->vb_queue
, buf
);
854 static int fimc_lite_dqbuf(struct file
*file
, void *priv
,
855 struct v4l2_buffer
*buf
)
857 struct fimc_lite
*fimc
= video_drvdata(file
);
859 return vb2_dqbuf(&fimc
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
862 static int fimc_lite_create_bufs(struct file
*file
, void *priv
,
863 struct v4l2_create_buffers
*create
)
865 struct fimc_lite
*fimc
= video_drvdata(file
);
867 return vb2_create_bufs(&fimc
->vb_queue
, create
);
870 static int fimc_lite_prepare_buf(struct file
*file
, void *priv
,
871 struct v4l2_buffer
*b
)
873 struct fimc_lite
*fimc
= video_drvdata(file
);
875 return vb2_prepare_buf(&fimc
->vb_queue
, b
);
878 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
879 static int enclosed_rectangle(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
881 if (a
->left
< b
->left
|| a
->top
< b
->top
)
883 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
885 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
891 static int fimc_lite_g_selection(struct file
*file
, void *fh
,
892 struct v4l2_selection
*sel
)
894 struct fimc_lite
*fimc
= video_drvdata(file
);
895 struct flite_frame
*f
= &fimc
->out_frame
;
897 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
900 switch (sel
->target
) {
901 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
902 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
905 sel
->r
.width
= f
->f_width
;
906 sel
->r
.height
= f
->f_height
;
909 case V4L2_SEL_TGT_COMPOSE
:
917 static int fimc_lite_s_selection(struct file
*file
, void *fh
,
918 struct v4l2_selection
*sel
)
920 struct fimc_lite
*fimc
= video_drvdata(file
);
921 struct flite_frame
*f
= &fimc
->out_frame
;
922 struct v4l2_rect rect
= sel
->r
;
925 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
||
926 sel
->target
!= V4L2_SEL_TGT_COMPOSE
)
929 fimc_lite_try_compose(fimc
, &rect
);
931 if ((sel
->flags
& V4L2_SEL_FLAG_LE
) &&
932 !enclosed_rectangle(&rect
, &sel
->r
))
935 if ((sel
->flags
& V4L2_SEL_FLAG_GE
) &&
936 !enclosed_rectangle(&sel
->r
, &rect
))
940 spin_lock_irqsave(&fimc
->slock
, flags
);
942 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
943 spin_unlock_irqrestore(&fimc
->slock
, flags
);
948 static const struct v4l2_ioctl_ops fimc_lite_ioctl_ops
= {
949 .vidioc_querycap
= fimc_vidioc_querycap_capture
,
950 .vidioc_enum_fmt_vid_cap_mplane
= fimc_lite_enum_fmt_mplane
,
951 .vidioc_try_fmt_vid_cap_mplane
= fimc_lite_try_fmt_mplane
,
952 .vidioc_s_fmt_vid_cap_mplane
= fimc_lite_s_fmt_mplane
,
953 .vidioc_g_fmt_vid_cap_mplane
= fimc_lite_g_fmt_mplane
,
954 .vidioc_g_selection
= fimc_lite_g_selection
,
955 .vidioc_s_selection
= fimc_lite_s_selection
,
956 .vidioc_reqbufs
= fimc_lite_reqbufs
,
957 .vidioc_querybuf
= fimc_lite_querybuf
,
958 .vidioc_prepare_buf
= fimc_lite_prepare_buf
,
959 .vidioc_create_bufs
= fimc_lite_create_bufs
,
960 .vidioc_qbuf
= fimc_lite_qbuf
,
961 .vidioc_dqbuf
= fimc_lite_dqbuf
,
962 .vidioc_streamon
= fimc_lite_streamon
,
963 .vidioc_streamoff
= fimc_lite_streamoff
,
966 /* Capture subdev media entity operations */
967 static int fimc_lite_link_setup(struct media_entity
*entity
,
968 const struct media_pad
*local
,
969 const struct media_pad
*remote
, u32 flags
)
971 struct v4l2_subdev
*sd
= media_entity_to_v4l2_subdev(entity
);
972 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
973 unsigned int remote_ent_type
= media_entity_type(remote
->entity
);
975 if (WARN_ON(fimc
== NULL
))
978 v4l2_dbg(1, debug
, sd
, "%s: %s --> %s, flags: 0x%x. source_id: 0x%x",
979 __func__
, local
->entity
->name
, remote
->entity
->name
,
980 flags
, fimc
->source_subdev_grp_id
);
982 switch (local
->index
) {
983 case FIMC_SD_PAD_SINK
:
984 if (remote_ent_type
!= MEDIA_ENT_T_V4L2_SUBDEV
)
987 if (flags
& MEDIA_LNK_FL_ENABLED
) {
988 if (fimc
->source_subdev_grp_id
!= 0)
990 fimc
->source_subdev_grp_id
= sd
->grp_id
;
994 fimc
->source_subdev_grp_id
= 0;
997 case FIMC_SD_PAD_SOURCE
:
998 if (!(flags
& MEDIA_LNK_FL_ENABLED
)) {
999 fimc
->out_path
= FIMC_IO_NONE
;
1002 if (remote_ent_type
== MEDIA_ENT_T_V4L2_SUBDEV
)
1003 fimc
->out_path
= FIMC_IO_ISP
;
1005 fimc
->out_path
= FIMC_IO_DMA
;
1009 v4l2_err(sd
, "Invalid pad index\n");
1016 static const struct media_entity_operations fimc_lite_subdev_media_ops
= {
1017 .link_setup
= fimc_lite_link_setup
,
1020 static int fimc_lite_subdev_enum_mbus_code(struct v4l2_subdev
*sd
,
1021 struct v4l2_subdev_fh
*fh
,
1022 struct v4l2_subdev_mbus_code_enum
*code
)
1024 const struct fimc_fmt
*fmt
;
1026 fmt
= fimc_lite_find_format(NULL
, NULL
, code
->index
);
1029 code
->code
= fmt
->mbus_code
;
1033 static int fimc_lite_subdev_get_fmt(struct v4l2_subdev
*sd
,
1034 struct v4l2_subdev_fh
*fh
,
1035 struct v4l2_subdev_format
*fmt
)
1037 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1038 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1039 struct flite_frame
*f
= &fimc
->out_frame
;
1041 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1042 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1046 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1048 mutex_lock(&fimc
->lock
);
1049 mf
->code
= fimc
->fmt
->mbus_code
;
1051 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1052 /* full camera input frame size */
1053 mf
->width
= f
->f_width
;
1054 mf
->height
= f
->f_height
;
1057 mf
->width
= f
->rect
.width
;
1058 mf
->height
= f
->rect
.height
;
1060 mutex_unlock(&fimc
->lock
);
1064 static int fimc_lite_subdev_set_fmt(struct v4l2_subdev
*sd
,
1065 struct v4l2_subdev_fh
*fh
,
1066 struct v4l2_subdev_format
*fmt
)
1068 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1069 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1070 struct flite_frame
*sink
= &fimc
->inp_frame
;
1071 struct flite_frame
*source
= &fimc
->out_frame
;
1072 const struct fimc_fmt
*ffmt
;
1074 v4l2_dbg(1, debug
, sd
, "pad%d: code: 0x%x, %dx%d",
1075 fmt
->pad
, mf
->code
, mf
->width
, mf
->height
);
1077 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1078 mutex_lock(&fimc
->lock
);
1080 if ((fimc
->out_path
== FIMC_IO_ISP
&& sd
->entity
.stream_count
> 0) ||
1081 (fimc
->out_path
== FIMC_IO_DMA
&& vb2_is_busy(&fimc
->vb_queue
))) {
1082 mutex_unlock(&fimc
->lock
);
1086 ffmt
= fimc_lite_try_format(fimc
, &mf
->width
, &mf
->height
,
1087 &mf
->code
, NULL
, fmt
->pad
);
1089 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1090 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1092 mutex_unlock(&fimc
->lock
);
1096 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1097 sink
->f_width
= mf
->width
;
1098 sink
->f_height
= mf
->height
;
1100 /* Set sink crop rectangle */
1101 sink
->rect
.width
= mf
->width
;
1102 sink
->rect
.height
= mf
->height
;
1103 sink
->rect
.left
= 0;
1105 /* Reset source format and crop rectangle */
1106 source
->rect
= sink
->rect
;
1107 source
->f_width
= mf
->width
;
1108 source
->f_height
= mf
->height
;
1110 /* Allow changing format only on sink pad */
1111 mf
->code
= fimc
->fmt
->mbus_code
;
1112 mf
->width
= sink
->rect
.width
;
1113 mf
->height
= sink
->rect
.height
;
1116 mutex_unlock(&fimc
->lock
);
1120 static int fimc_lite_subdev_get_selection(struct v4l2_subdev
*sd
,
1121 struct v4l2_subdev_fh
*fh
,
1122 struct v4l2_subdev_selection
*sel
)
1124 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1125 struct flite_frame
*f
= &fimc
->inp_frame
;
1127 if ((sel
->target
!= V4L2_SEL_TGT_CROP
&&
1128 sel
->target
!= V4L2_SEL_TGT_CROP_BOUNDS
) ||
1129 sel
->pad
!= FLITE_SD_PAD_SINK
)
1132 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1133 sel
->r
= *v4l2_subdev_get_try_crop(fh
, sel
->pad
);
1137 mutex_lock(&fimc
->lock
);
1138 if (sel
->target
== V4L2_SEL_TGT_CROP
) {
1143 sel
->r
.width
= f
->f_width
;
1144 sel
->r
.height
= f
->f_height
;
1146 mutex_unlock(&fimc
->lock
);
1148 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1149 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1150 f
->rect
.height
, f
->f_width
, f
->f_height
);
1155 static int fimc_lite_subdev_set_selection(struct v4l2_subdev
*sd
,
1156 struct v4l2_subdev_fh
*fh
,
1157 struct v4l2_subdev_selection
*sel
)
1159 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1160 struct flite_frame
*f
= &fimc
->inp_frame
;
1163 if (sel
->target
!= V4L2_SEL_TGT_CROP
|| sel
->pad
!= FLITE_SD_PAD_SINK
)
1166 mutex_lock(&fimc
->lock
);
1167 fimc_lite_try_crop(fimc
, &sel
->r
);
1169 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1170 *v4l2_subdev_get_try_crop(fh
, sel
->pad
) = sel
->r
;
1172 unsigned long flags
;
1173 spin_lock_irqsave(&fimc
->slock
, flags
);
1175 /* Same crop rectangle on the source pad */
1176 fimc
->out_frame
.rect
= sel
->r
;
1177 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1178 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1180 mutex_unlock(&fimc
->lock
);
1182 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1183 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1184 f
->rect
.height
, f
->f_width
, f
->f_height
);
1189 static int fimc_lite_subdev_s_stream(struct v4l2_subdev
*sd
, int on
)
1191 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1193 if (fimc
->out_path
== FIMC_IO_DMA
)
1194 return -ENOIOCTLCMD
;
1201 static int fimc_lite_subdev_s_power(struct v4l2_subdev
*sd
, int on
)
1203 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1205 if (fimc
->out_path
== FIMC_IO_DMA
)
1206 return -ENOIOCTLCMD
;
1213 static int fimc_lite_log_status(struct v4l2_subdev
*sd
)
1215 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1217 flite_hw_dump_regs(fimc
, __func__
);
1221 static int fimc_lite_subdev_registered(struct v4l2_subdev
*sd
)
1223 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1224 struct vb2_queue
*q
= &fimc
->vb_queue
;
1225 struct video_device
*vfd
= &fimc
->vfd
;
1228 memset(vfd
, 0, sizeof(*vfd
));
1230 fimc
->fmt
= &fimc_lite_formats
[0];
1231 fimc
->out_path
= FIMC_IO_DMA
;
1233 snprintf(vfd
->name
, sizeof(vfd
->name
), "fimc-lite.%d.capture",
1236 vfd
->fops
= &fimc_lite_fops
;
1237 vfd
->ioctl_ops
= &fimc_lite_ioctl_ops
;
1238 vfd
->v4l2_dev
= sd
->v4l2_dev
;
1240 vfd
->release
= video_device_release_empty
;
1241 vfd
->lock
= &fimc
->lock
;
1242 fimc
->ref_count
= 0;
1243 fimc
->reqbufs_count
= 0;
1245 INIT_LIST_HEAD(&fimc
->pending_buf_q
);
1246 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1248 memset(q
, 0, sizeof(*q
));
1249 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
;
1250 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1251 q
->ops
= &fimc_lite_qops
;
1252 q
->mem_ops
= &vb2_dma_contig_memops
;
1253 q
->buf_struct_size
= sizeof(struct flite_buffer
);
1258 fimc
->vd_pad
.flags
= MEDIA_PAD_FL_SINK
;
1259 ret
= media_entity_init(&vfd
->entity
, 1, &fimc
->vd_pad
, 0);
1263 video_set_drvdata(vfd
, fimc
);
1265 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, -1);
1267 media_entity_cleanup(&vfd
->entity
);
1271 v4l2_info(sd
->v4l2_dev
, "Registered %s as /dev/%s\n",
1272 vfd
->name
, video_device_node_name(vfd
));
1276 static void fimc_lite_subdev_unregistered(struct v4l2_subdev
*sd
)
1278 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1283 if (video_is_registered(&fimc
->vfd
)) {
1284 video_unregister_device(&fimc
->vfd
);
1285 media_entity_cleanup(&fimc
->vfd
.entity
);
1289 static const struct v4l2_subdev_internal_ops fimc_lite_subdev_internal_ops
= {
1290 .registered
= fimc_lite_subdev_registered
,
1291 .unregistered
= fimc_lite_subdev_unregistered
,
1294 static const struct v4l2_subdev_pad_ops fimc_lite_subdev_pad_ops
= {
1295 .enum_mbus_code
= fimc_lite_subdev_enum_mbus_code
,
1296 .get_selection
= fimc_lite_subdev_get_selection
,
1297 .set_selection
= fimc_lite_subdev_set_selection
,
1298 .get_fmt
= fimc_lite_subdev_get_fmt
,
1299 .set_fmt
= fimc_lite_subdev_set_fmt
,
1302 static const struct v4l2_subdev_video_ops fimc_lite_subdev_video_ops
= {
1303 .s_stream
= fimc_lite_subdev_s_stream
,
1306 static const struct v4l2_subdev_core_ops fimc_lite_core_ops
= {
1307 .s_power
= fimc_lite_subdev_s_power
,
1308 .log_status
= fimc_lite_log_status
,
1311 static struct v4l2_subdev_ops fimc_lite_subdev_ops
= {
1312 .core
= &fimc_lite_core_ops
,
1313 .video
= &fimc_lite_subdev_video_ops
,
1314 .pad
= &fimc_lite_subdev_pad_ops
,
1317 static int fimc_lite_s_ctrl(struct v4l2_ctrl
*ctrl
)
1319 struct fimc_lite
*fimc
= container_of(ctrl
->handler
, struct fimc_lite
,
1321 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1325 static const struct v4l2_ctrl_ops fimc_lite_ctrl_ops
= {
1326 .s_ctrl
= fimc_lite_s_ctrl
,
1329 static const struct v4l2_ctrl_config fimc_lite_ctrl
= {
1330 .ops
= &fimc_lite_ctrl_ops
,
1331 .id
= V4L2_CTRL_CLASS_USER
| 0x1001,
1332 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1333 .name
= "Test Pattern 640x480",
1336 static int fimc_lite_create_capture_subdev(struct fimc_lite
*fimc
)
1338 struct v4l2_ctrl_handler
*handler
= &fimc
->ctrl_handler
;
1339 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1342 v4l2_subdev_init(sd
, &fimc_lite_subdev_ops
);
1343 sd
->flags
= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1344 snprintf(sd
->name
, sizeof(sd
->name
), "FIMC-LITE.%d", fimc
->index
);
1346 fimc
->subdev_pads
[FIMC_SD_PAD_SINK
].flags
= MEDIA_PAD_FL_SINK
;
1347 fimc
->subdev_pads
[FIMC_SD_PAD_SOURCE
].flags
= MEDIA_PAD_FL_SOURCE
;
1348 ret
= media_entity_init(&sd
->entity
, FIMC_SD_PADS_NUM
,
1349 fimc
->subdev_pads
, 0);
1353 v4l2_ctrl_handler_init(handler
, 1);
1354 fimc
->test_pattern
= v4l2_ctrl_new_custom(handler
, &fimc_lite_ctrl
,
1356 if (handler
->error
) {
1357 media_entity_cleanup(&sd
->entity
);
1358 return handler
->error
;
1361 sd
->ctrl_handler
= handler
;
1362 sd
->internal_ops
= &fimc_lite_subdev_internal_ops
;
1363 sd
->entity
.ops
= &fimc_lite_subdev_media_ops
;
1364 v4l2_set_subdevdata(sd
, fimc
);
1369 static void fimc_lite_unregister_capture_subdev(struct fimc_lite
*fimc
)
1371 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1373 v4l2_device_unregister_subdev(sd
);
1374 media_entity_cleanup(&sd
->entity
);
1375 v4l2_ctrl_handler_free(&fimc
->ctrl_handler
);
1376 v4l2_set_subdevdata(sd
, NULL
);
1379 static void fimc_lite_clk_put(struct fimc_lite
*fimc
)
1381 if (IS_ERR_OR_NULL(fimc
->clock
))
1384 clk_unprepare(fimc
->clock
);
1385 clk_put(fimc
->clock
);
1389 static int fimc_lite_clk_get(struct fimc_lite
*fimc
)
1393 fimc
->clock
= clk_get(&fimc
->pdev
->dev
, FLITE_CLK_NAME
);
1394 if (IS_ERR(fimc
->clock
))
1395 return PTR_ERR(fimc
->clock
);
1397 ret
= clk_prepare(fimc
->clock
);
1399 clk_put(fimc
->clock
);
1405 static int __devinit
fimc_lite_probe(struct platform_device
*pdev
)
1407 struct flite_drvdata
*drv_data
= fimc_lite_get_drvdata(pdev
);
1408 struct fimc_lite
*fimc
;
1409 struct resource
*res
;
1412 fimc
= devm_kzalloc(&pdev
->dev
, sizeof(*fimc
), GFP_KERNEL
);
1416 fimc
->index
= pdev
->id
;
1417 fimc
->variant
= drv_data
->variant
[fimc
->index
];
1420 init_waitqueue_head(&fimc
->irq_queue
);
1421 spin_lock_init(&fimc
->slock
);
1422 mutex_init(&fimc
->lock
);
1424 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1425 fimc
->regs
= devm_request_and_ioremap(&pdev
->dev
, res
);
1426 if (fimc
->regs
== NULL
) {
1427 dev_err(&pdev
->dev
, "Failed to obtain io memory\n");
1431 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1433 dev_err(&pdev
->dev
, "Failed to get IRQ resource\n");
1437 ret
= fimc_lite_clk_get(fimc
);
1441 ret
= devm_request_irq(&pdev
->dev
, res
->start
, flite_irq_handler
,
1442 0, dev_name(&pdev
->dev
), fimc
);
1444 dev_err(&pdev
->dev
, "Failed to install irq (%d)\n", ret
);
1448 /* The video node will be created within the subdev's registered() op */
1449 ret
= fimc_lite_create_capture_subdev(fimc
);
1453 platform_set_drvdata(pdev
, fimc
);
1454 pm_runtime_enable(&pdev
->dev
);
1455 ret
= pm_runtime_get_sync(&pdev
->dev
);
1459 fimc
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1460 if (IS_ERR(fimc
->alloc_ctx
)) {
1461 ret
= PTR_ERR(fimc
->alloc_ctx
);
1464 pm_runtime_put(&pdev
->dev
);
1466 dev_dbg(&pdev
->dev
, "FIMC-LITE.%d registered successfully\n",
1470 pm_runtime_put(&pdev
->dev
);
1472 fimc_lite_unregister_capture_subdev(fimc
);
1474 fimc_lite_clk_put(fimc
);
1478 static int fimc_lite_runtime_resume(struct device
*dev
)
1480 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1482 clk_enable(fimc
->clock
);
1486 static int fimc_lite_runtime_suspend(struct device
*dev
)
1488 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1490 clk_disable(fimc
->clock
);
1494 #ifdef CONFIG_PM_SLEEP
1495 static int fimc_lite_resume(struct device
*dev
)
1497 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1498 struct flite_buffer
*buf
;
1499 unsigned long flags
;
1502 spin_lock_irqsave(&fimc
->slock
, flags
);
1503 if (!test_and_clear_bit(ST_LPM
, &fimc
->state
) ||
1504 !test_bit(ST_FLITE_IN_USE
, &fimc
->state
)) {
1505 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1508 flite_hw_reset(fimc
);
1509 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1511 if (!test_and_clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
))
1514 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1515 fimc_pipeline_call(fimc
, open
, &fimc
->pipeline
,
1516 &fimc
->vfd
.entity
, false);
1517 fimc_lite_hw_init(fimc
);
1518 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
1520 for (i
= 0; i
< fimc
->reqbufs_count
; i
++) {
1521 if (list_empty(&fimc
->pending_buf_q
))
1523 buf
= fimc_lite_pending_queue_pop(fimc
);
1524 buffer_queue(&buf
->vb
);
1529 static int fimc_lite_suspend(struct device
*dev
)
1531 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1532 bool suspend
= test_bit(ST_FLITE_IN_USE
, &fimc
->state
);
1535 if (test_and_set_bit(ST_LPM
, &fimc
->state
))
1538 ret
= fimc_lite_stop_capture(fimc
, suspend
);
1539 if (ret
< 0 || !fimc_lite_active(fimc
))
1542 return fimc_pipeline_call(fimc
, close
, &fimc
->pipeline
);
1544 #endif /* CONFIG_PM_SLEEP */
1546 static int __devexit
fimc_lite_remove(struct platform_device
*pdev
)
1548 struct fimc_lite
*fimc
= platform_get_drvdata(pdev
);
1549 struct device
*dev
= &pdev
->dev
;
1551 pm_runtime_disable(dev
);
1552 pm_runtime_set_suspended(dev
);
1553 fimc_lite_unregister_capture_subdev(fimc
);
1554 vb2_dma_contig_cleanup_ctx(fimc
->alloc_ctx
);
1555 fimc_lite_clk_put(fimc
);
1557 dev_info(dev
, "Driver unloaded\n");
1561 static struct flite_variant fimc_lite0_variant_exynos4
= {
1564 .out_width_align
= 8,
1565 .win_hor_offs_align
= 2,
1566 .out_hor_offs_align
= 8,
1569 /* EXYNOS4212, EXYNOS4412 */
1570 static struct flite_drvdata fimc_lite_drvdata_exynos4
= {
1572 [0] = &fimc_lite0_variant_exynos4
,
1573 [1] = &fimc_lite0_variant_exynos4
,
1577 static struct platform_device_id fimc_lite_driver_ids
[] = {
1579 .name
= "exynos-fimc-lite",
1580 .driver_data
= (unsigned long)&fimc_lite_drvdata_exynos4
,
1584 MODULE_DEVICE_TABLE(platform
, fimc_lite_driver_ids
);
1586 static const struct dev_pm_ops fimc_lite_pm_ops
= {
1587 SET_SYSTEM_SLEEP_PM_OPS(fimc_lite_suspend
, fimc_lite_resume
)
1588 SET_RUNTIME_PM_OPS(fimc_lite_runtime_suspend
, fimc_lite_runtime_resume
,
1592 static struct platform_driver fimc_lite_driver
= {
1593 .probe
= fimc_lite_probe
,
1594 .remove
= __devexit_p(fimc_lite_remove
),
1595 .id_table
= fimc_lite_driver_ids
,
1597 .name
= FIMC_LITE_DRV_NAME
,
1598 .owner
= THIS_MODULE
,
1599 .pm
= &fimc_lite_pm_ops
,
1602 module_platform_driver(fimc_lite_driver
);
1603 MODULE_LICENSE("GPL");
1604 MODULE_ALIAS("platform:" FIMC_LITE_DRV_NAME
);