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>
32 #include "fimc-mdevice.h"
33 #include "fimc-core.h"
34 #include "fimc-lite-reg.h"
37 module_param(debug
, int, 0644);
39 static const struct fimc_fmt fimc_lite_formats
[] = {
41 .name
= "YUV 4:2:2 packed, YCbYCr",
42 .fourcc
= V4L2_PIX_FMT_YUYV
,
44 .color
= FIMC_FMT_YCBYCR422
,
46 .mbus_code
= V4L2_MBUS_FMT_YUYV8_2X8
,
48 .name
= "YUV 4:2:2 packed, CbYCrY",
49 .fourcc
= V4L2_PIX_FMT_UYVY
,
51 .color
= FIMC_FMT_CBYCRY422
,
53 .mbus_code
= V4L2_MBUS_FMT_UYVY8_2X8
,
55 .name
= "YUV 4:2:2 packed, CrYCbY",
56 .fourcc
= V4L2_PIX_FMT_VYUY
,
58 .color
= FIMC_FMT_CRYCBY422
,
60 .mbus_code
= V4L2_MBUS_FMT_VYUY8_2X8
,
62 .name
= "YUV 4:2:2 packed, YCrYCb",
63 .fourcc
= V4L2_PIX_FMT_YVYU
,
65 .color
= FIMC_FMT_YCRYCB422
,
67 .mbus_code
= V4L2_MBUS_FMT_YVYU8_2X8
,
69 .name
= "RAW8 (GRBG)",
70 .fourcc
= V4L2_PIX_FMT_SGRBG8
,
72 .color
= FIMC_FMT_RAW8
,
74 .mbus_code
= V4L2_MBUS_FMT_SGRBG8_1X8
,
76 .name
= "RAW10 (GRBG)",
77 .fourcc
= V4L2_PIX_FMT_SGRBG10
,
79 .color
= FIMC_FMT_RAW10
,
81 .mbus_code
= V4L2_MBUS_FMT_SGRBG10_1X10
,
83 .name
= "RAW12 (GRBG)",
84 .fourcc
= V4L2_PIX_FMT_SGRBG12
,
86 .color
= FIMC_FMT_RAW12
,
88 .mbus_code
= V4L2_MBUS_FMT_SGRBG12_1X12
,
93 * fimc_lite_find_format - lookup fimc color format by fourcc or media bus code
94 * @pixelformat: fourcc to match, ignored if null
95 * @mbus_code: media bus code to match, ignored if null
96 * @index: index to the fimc_lite_formats array, ignored if negative
98 static const struct fimc_fmt
*fimc_lite_find_format(const u32
*pixelformat
,
99 const u32
*mbus_code
, int index
)
101 const struct fimc_fmt
*fmt
, *def_fmt
= NULL
;
105 if (index
>= (int)ARRAY_SIZE(fimc_lite_formats
))
108 for (i
= 0; i
< ARRAY_SIZE(fimc_lite_formats
); ++i
) {
109 fmt
= &fimc_lite_formats
[i
];
110 if (pixelformat
&& fmt
->fourcc
== *pixelformat
)
112 if (mbus_code
&& fmt
->mbus_code
== *mbus_code
)
121 static int fimc_lite_hw_init(struct fimc_lite
*fimc
)
123 struct fimc_pipeline
*pipeline
= &fimc
->pipeline
;
124 struct fimc_sensor_info
*sensor
;
127 if (pipeline
->subdevs
[IDX_SENSOR
] == NULL
)
130 if (fimc
->fmt
== NULL
)
133 sensor
= v4l2_get_subdev_hostdata(pipeline
->subdevs
[IDX_SENSOR
]);
134 spin_lock_irqsave(&fimc
->slock
, flags
);
136 flite_hw_set_camera_bus(fimc
, sensor
->pdata
);
137 flite_hw_set_source_format(fimc
, &fimc
->inp_frame
);
138 flite_hw_set_window_offset(fimc
, &fimc
->inp_frame
);
139 flite_hw_set_output_dma(fimc
, &fimc
->out_frame
, true);
140 flite_hw_set_interrupt_mask(fimc
);
141 flite_hw_set_test_pattern(fimc
, fimc
->test_pattern
->val
);
144 flite_hw_dump_regs(fimc
, __func__
);
146 spin_unlock_irqrestore(&fimc
->slock
, flags
);
151 * Reinitialize the driver so it is ready to start the streaming again.
152 * Set fimc->state to indicate stream off and the hardware shut down state.
153 * If not suspending (@suspend is false), return any buffers to videobuf2.
154 * Otherwise put any owned buffers onto the pending buffers queue, so they
155 * can be re-spun when the device is being resumed. Also perform FIMC
156 * software reset and disable streaming on the whole pipeline if required.
158 static int fimc_lite_reinit(struct fimc_lite
*fimc
, bool suspend
)
160 struct flite_buffer
*buf
;
164 spin_lock_irqsave(&fimc
->slock
, flags
);
165 streaming
= fimc
->state
& (1 << ST_SENSOR_STREAM
);
167 fimc
->state
&= ~(1 << ST_FLITE_RUN
| 1 << ST_FLITE_OFF
|
168 1 << ST_FLITE_STREAM
| 1 << ST_SENSOR_STREAM
);
170 fimc
->state
|= (1 << ST_FLITE_SUSPENDED
);
172 fimc
->state
&= ~(1 << ST_FLITE_PENDING
|
173 1 << ST_FLITE_SUSPENDED
);
175 /* Release unused buffers */
176 while (!suspend
&& !list_empty(&fimc
->pending_buf_q
)) {
177 buf
= fimc_lite_pending_queue_pop(fimc
);
178 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
180 /* If suspending put unused buffers onto pending queue */
181 while (!list_empty(&fimc
->active_buf_q
)) {
182 buf
= fimc_lite_active_queue_pop(fimc
);
184 fimc_lite_pending_queue_add(fimc
, buf
);
186 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
189 spin_unlock_irqrestore(&fimc
->slock
, flags
);
191 flite_hw_reset(fimc
);
196 return fimc_pipeline_s_stream(&fimc
->pipeline
, 0);
199 static int fimc_lite_stop_capture(struct fimc_lite
*fimc
, bool suspend
)
203 if (!fimc_lite_active(fimc
))
206 spin_lock_irqsave(&fimc
->slock
, flags
);
207 set_bit(ST_FLITE_OFF
, &fimc
->state
);
208 flite_hw_capture_stop(fimc
);
209 spin_unlock_irqrestore(&fimc
->slock
, flags
);
211 wait_event_timeout(fimc
->irq_queue
,
212 !test_bit(ST_FLITE_OFF
, &fimc
->state
),
213 (2*HZ
/10)); /* 200 ms */
215 return fimc_lite_reinit(fimc
, suspend
);
218 /* Must be called with fimc.slock spinlock held. */
219 static void fimc_lite_config_update(struct fimc_lite
*fimc
)
221 flite_hw_set_window_offset(fimc
, &fimc
->inp_frame
);
222 flite_hw_set_dma_window(fimc
, &fimc
->out_frame
);
223 flite_hw_set_test_pattern(fimc
, fimc
->test_pattern
->val
);
224 clear_bit(ST_FLITE_CONFIG
, &fimc
->state
);
227 static irqreturn_t
flite_irq_handler(int irq
, void *priv
)
229 struct fimc_lite
*fimc
= priv
;
230 struct flite_buffer
*vbuf
;
236 spin_lock_irqsave(&fimc
->slock
, flags
);
238 intsrc
= flite_hw_get_interrupt_source(fimc
);
239 flite_hw_clear_pending_irq(fimc
);
241 if (test_and_clear_bit(ST_FLITE_OFF
, &fimc
->state
)) {
242 wake_up(&fimc
->irq_queue
);
246 if (intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_OVERFLOW
) {
247 clear_bit(ST_FLITE_RUN
, &fimc
->state
);
248 fimc
->events
.data_overflow
++;
251 if (intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_LASTCAPEND
) {
252 flite_hw_clear_last_capture_end(fimc
);
253 clear_bit(ST_FLITE_STREAM
, &fimc
->state
);
254 wake_up(&fimc
->irq_queue
);
257 if (fimc
->out_path
!= FIMC_IO_DMA
)
260 if ((intsrc
& FLITE_REG_CISTATUS_IRQ_SRC_FRMSTART
) &&
261 test_bit(ST_FLITE_RUN
, &fimc
->state
) &&
262 !list_empty(&fimc
->active_buf_q
) &&
263 !list_empty(&fimc
->pending_buf_q
)) {
264 vbuf
= fimc_lite_active_queue_pop(fimc
);
266 tv
= &vbuf
->vb
.v4l2_buf
.timestamp
;
267 tv
->tv_sec
= ts
.tv_sec
;
268 tv
->tv_usec
= ts
.tv_nsec
/ NSEC_PER_USEC
;
269 vbuf
->vb
.v4l2_buf
.sequence
= fimc
->frame_count
++;
270 vb2_buffer_done(&vbuf
->vb
, VB2_BUF_STATE_DONE
);
272 vbuf
= fimc_lite_pending_queue_pop(fimc
);
273 flite_hw_set_output_addr(fimc
, vbuf
->paddr
);
274 fimc_lite_active_queue_add(fimc
, vbuf
);
277 if (test_bit(ST_FLITE_CONFIG
, &fimc
->state
))
278 fimc_lite_config_update(fimc
);
280 if (list_empty(&fimc
->pending_buf_q
)) {
281 flite_hw_capture_stop(fimc
);
282 clear_bit(ST_FLITE_STREAM
, &fimc
->state
);
285 set_bit(ST_FLITE_RUN
, &fimc
->state
);
286 spin_unlock_irqrestore(&fimc
->slock
, flags
);
290 static int start_streaming(struct vb2_queue
*q
, unsigned int count
)
292 struct fimc_lite
*fimc
= q
->drv_priv
;
295 fimc
->frame_count
= 0;
297 ret
= fimc_lite_hw_init(fimc
);
299 fimc_lite_reinit(fimc
, false);
303 set_bit(ST_FLITE_PENDING
, &fimc
->state
);
305 if (!list_empty(&fimc
->active_buf_q
) &&
306 !test_and_set_bit(ST_FLITE_STREAM
, &fimc
->state
)) {
307 flite_hw_capture_start(fimc
);
309 if (!test_and_set_bit(ST_SENSOR_STREAM
, &fimc
->state
))
310 fimc_pipeline_s_stream(&fimc
->pipeline
, 1);
313 flite_hw_dump_regs(fimc
, __func__
);
318 static int stop_streaming(struct vb2_queue
*q
)
320 struct fimc_lite
*fimc
= q
->drv_priv
;
322 if (!fimc_lite_active(fimc
))
325 return fimc_lite_stop_capture(fimc
, false);
328 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*pfmt
,
329 unsigned int *num_buffers
, unsigned int *num_planes
,
330 unsigned int sizes
[], void *allocators
[])
332 const struct v4l2_pix_format_mplane
*pixm
= NULL
;
333 struct fimc_lite
*fimc
= vq
->drv_priv
;
334 struct flite_frame
*frame
= &fimc
->out_frame
;
335 const struct fimc_fmt
*fmt
= fimc
->fmt
;
340 pixm
= &pfmt
->fmt
.pix_mp
;
341 fmt
= fimc_lite_find_format(&pixm
->pixelformat
, NULL
, -1);
342 wh
= pixm
->width
* pixm
->height
;
344 wh
= frame
->f_width
* frame
->f_height
;
350 *num_planes
= fmt
->memplanes
;
352 for (i
= 0; i
< fmt
->memplanes
; i
++) {
353 unsigned int size
= (wh
* fmt
->depth
[i
]) / 8;
355 sizes
[i
] = max(size
, pixm
->plane_fmt
[i
].sizeimage
);
358 allocators
[i
] = fimc
->alloc_ctx
;
364 static int buffer_prepare(struct vb2_buffer
*vb
)
366 struct vb2_queue
*vq
= vb
->vb2_queue
;
367 struct fimc_lite
*fimc
= vq
->drv_priv
;
370 if (fimc
->fmt
== NULL
)
373 for (i
= 0; i
< fimc
->fmt
->memplanes
; i
++) {
374 unsigned long size
= fimc
->payload
[i
];
376 if (vb2_plane_size(vb
, i
) < size
) {
378 "User buffer too small (%ld < %ld)\n",
379 vb2_plane_size(vb
, i
), size
);
382 vb2_set_plane_payload(vb
, i
, size
);
388 static void buffer_queue(struct vb2_buffer
*vb
)
390 struct flite_buffer
*buf
391 = container_of(vb
, struct flite_buffer
, vb
);
392 struct fimc_lite
*fimc
= vb2_get_drv_priv(vb
->vb2_queue
);
395 spin_lock_irqsave(&fimc
->slock
, flags
);
396 buf
->paddr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
398 if (!test_bit(ST_FLITE_SUSPENDED
, &fimc
->state
) &&
399 !test_bit(ST_FLITE_STREAM
, &fimc
->state
) &&
400 list_empty(&fimc
->active_buf_q
)) {
401 flite_hw_set_output_addr(fimc
, buf
->paddr
);
402 fimc_lite_active_queue_add(fimc
, buf
);
404 fimc_lite_pending_queue_add(fimc
, buf
);
407 if (vb2_is_streaming(&fimc
->vb_queue
) &&
408 !list_empty(&fimc
->pending_buf_q
) &&
409 !test_and_set_bit(ST_FLITE_STREAM
, &fimc
->state
)) {
410 flite_hw_capture_start(fimc
);
411 spin_unlock_irqrestore(&fimc
->slock
, flags
);
413 if (!test_and_set_bit(ST_SENSOR_STREAM
, &fimc
->state
))
414 fimc_pipeline_s_stream(&fimc
->pipeline
, 1);
417 spin_unlock_irqrestore(&fimc
->slock
, flags
);
420 static void fimc_lock(struct vb2_queue
*vq
)
422 struct fimc_lite
*fimc
= vb2_get_drv_priv(vq
);
423 mutex_lock(&fimc
->lock
);
426 static void fimc_unlock(struct vb2_queue
*vq
)
428 struct fimc_lite
*fimc
= vb2_get_drv_priv(vq
);
429 mutex_unlock(&fimc
->lock
);
432 static const struct vb2_ops fimc_lite_qops
= {
433 .queue_setup
= queue_setup
,
434 .buf_prepare
= buffer_prepare
,
435 .buf_queue
= buffer_queue
,
436 .wait_prepare
= fimc_unlock
,
437 .wait_finish
= fimc_lock
,
438 .start_streaming
= start_streaming
,
439 .stop_streaming
= stop_streaming
,
442 static void fimc_lite_clear_event_counters(struct fimc_lite
*fimc
)
446 spin_lock_irqsave(&fimc
->slock
, flags
);
447 memset(&fimc
->events
, 0, sizeof(fimc
->events
));
448 spin_unlock_irqrestore(&fimc
->slock
, flags
);
451 static int fimc_lite_open(struct file
*file
)
453 struct fimc_lite
*fimc
= video_drvdata(file
);
454 int ret
= v4l2_fh_open(file
);
459 set_bit(ST_FLITE_IN_USE
, &fimc
->state
);
460 pm_runtime_get_sync(&fimc
->pdev
->dev
);
462 if (++fimc
->ref_count
!= 1 || fimc
->out_path
!= FIMC_IO_DMA
)
465 ret
= fimc_pipeline_initialize(&fimc
->pipeline
, &fimc
->vfd
->entity
,
468 v4l2_err(fimc
->vfd
, "Video pipeline initialization failed\n");
469 pm_runtime_put_sync(&fimc
->pdev
->dev
);
471 v4l2_fh_release(file
);
472 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
475 fimc_lite_clear_event_counters(fimc
);
479 static int fimc_lite_close(struct file
*file
)
481 struct fimc_lite
*fimc
= video_drvdata(file
);
483 if (--fimc
->ref_count
== 0 && fimc
->out_path
== FIMC_IO_DMA
) {
484 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
485 fimc_lite_stop_capture(fimc
, false);
486 fimc_pipeline_shutdown(&fimc
->pipeline
);
487 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
490 pm_runtime_put(&fimc
->pdev
->dev
);
492 if (fimc
->ref_count
== 0)
493 vb2_queue_release(&fimc
->vb_queue
);
495 return v4l2_fh_release(file
);
498 static unsigned int fimc_lite_poll(struct file
*file
,
499 struct poll_table_struct
*wait
)
501 struct fimc_lite
*fimc
= video_drvdata(file
);
502 return vb2_poll(&fimc
->vb_queue
, file
, wait
);
505 static int fimc_lite_mmap(struct file
*file
, struct vm_area_struct
*vma
)
507 struct fimc_lite
*fimc
= video_drvdata(file
);
508 return vb2_mmap(&fimc
->vb_queue
, vma
);
511 static const struct v4l2_file_operations fimc_lite_fops
= {
512 .owner
= THIS_MODULE
,
513 .open
= fimc_lite_open
,
514 .release
= fimc_lite_close
,
515 .poll
= fimc_lite_poll
,
516 .unlocked_ioctl
= video_ioctl2
,
517 .mmap
= fimc_lite_mmap
,
521 * Format and crop negotiation helpers
524 static const struct fimc_fmt
*fimc_lite_try_format(struct fimc_lite
*fimc
,
525 u32
*width
, u32
*height
,
526 u32
*code
, u32
*fourcc
, int pad
)
528 struct flite_variant
*variant
= fimc
->variant
;
529 const struct fimc_fmt
*fmt
;
531 fmt
= fimc_lite_find_format(fourcc
, code
, 0);
536 *code
= fmt
->mbus_code
;
538 *fourcc
= fmt
->fourcc
;
540 if (pad
== FLITE_SD_PAD_SINK
) {
541 v4l_bound_align_image(width
, 8, variant
->max_width
,
542 ffs(variant
->out_width_align
) - 1,
543 height
, 0, variant
->max_height
, 0, 0);
545 v4l_bound_align_image(width
, 8, fimc
->inp_frame
.rect
.width
,
546 ffs(variant
->out_width_align
) - 1,
547 height
, 0, fimc
->inp_frame
.rect
.height
,
551 v4l2_dbg(1, debug
, &fimc
->subdev
, "code: 0x%x, %dx%d\n",
552 code
? *code
: 0, *width
, *height
);
557 static void fimc_lite_try_crop(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
559 struct flite_frame
*frame
= &fimc
->inp_frame
;
561 v4l_bound_align_image(&r
->width
, 0, frame
->f_width
, 0,
562 &r
->height
, 0, frame
->f_height
, 0, 0);
564 /* Adjust left/top if cropping rectangle got out of bounds */
565 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
566 r
->left
= round_down(r
->left
, fimc
->variant
->win_hor_offs_align
);
567 r
->top
= clamp_t(u32
, r
->top
, 0, frame
->f_height
- r
->height
);
569 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, sink fmt: %dx%d",
570 r
->left
, r
->top
, r
->width
, r
->height
,
571 frame
->f_width
, frame
->f_height
);
574 static void fimc_lite_try_compose(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
576 struct flite_frame
*frame
= &fimc
->out_frame
;
577 struct v4l2_rect
*crop_rect
= &fimc
->inp_frame
.rect
;
579 /* Scaling is not supported so we enforce compose rectangle size
580 same as size of the sink crop rectangle. */
581 r
->width
= crop_rect
->width
;
582 r
->height
= crop_rect
->height
;
584 /* Adjust left/top if the composing rectangle got out of bounds */
585 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
586 r
->left
= round_down(r
->left
, fimc
->variant
->out_hor_offs_align
);
587 r
->top
= clamp_t(u32
, r
->top
, 0, fimc
->out_frame
.f_height
- r
->height
);
589 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, source fmt: %dx%d",
590 r
->left
, r
->top
, r
->width
, r
->height
,
591 frame
->f_width
, frame
->f_height
);
595 * Video node ioctl operations
597 static int fimc_vidioc_querycap_capture(struct file
*file
, void *priv
,
598 struct v4l2_capability
*cap
)
600 strlcpy(cap
->driver
, FIMC_LITE_DRV_NAME
, sizeof(cap
->driver
));
601 cap
->bus_info
[0] = 0;
603 cap
->capabilities
= V4L2_CAP_STREAMING
;
607 static int fimc_lite_enum_fmt_mplane(struct file
*file
, void *priv
,
608 struct v4l2_fmtdesc
*f
)
610 const struct fimc_fmt
*fmt
;
612 if (f
->index
>= ARRAY_SIZE(fimc_lite_formats
))
615 fmt
= &fimc_lite_formats
[f
->index
];
616 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
617 f
->pixelformat
= fmt
->fourcc
;
622 static int fimc_lite_g_fmt_mplane(struct file
*file
, void *fh
,
623 struct v4l2_format
*f
)
625 struct fimc_lite
*fimc
= video_drvdata(file
);
626 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
627 struct v4l2_plane_pix_format
*plane_fmt
= &pixm
->plane_fmt
[0];
628 struct flite_frame
*frame
= &fimc
->out_frame
;
629 const struct fimc_fmt
*fmt
= fimc
->fmt
;
631 plane_fmt
->bytesperline
= (frame
->f_width
* fmt
->depth
[0]) / 8;
632 plane_fmt
->sizeimage
= plane_fmt
->bytesperline
* frame
->f_height
;
634 pixm
->num_planes
= fmt
->memplanes
;
635 pixm
->pixelformat
= fmt
->fourcc
;
636 pixm
->width
= frame
->f_width
;
637 pixm
->height
= frame
->f_height
;
638 pixm
->field
= V4L2_FIELD_NONE
;
639 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
643 static int fimc_lite_try_fmt(struct fimc_lite
*fimc
,
644 struct v4l2_pix_format_mplane
*pixm
,
645 const struct fimc_fmt
**ffmt
)
647 struct flite_variant
*variant
= fimc
->variant
;
648 u32 bpl
= pixm
->plane_fmt
[0].bytesperline
;
649 const struct fimc_fmt
*fmt
;
651 fmt
= fimc_lite_find_format(&pixm
->pixelformat
, NULL
, 0);
652 if (WARN_ON(fmt
== NULL
))
656 v4l_bound_align_image(&pixm
->width
, 8, variant
->max_width
,
657 ffs(variant
->out_width_align
) - 1,
658 &pixm
->height
, 0, variant
->max_height
, 0, 0);
660 if ((bpl
== 0 || ((bpl
* 8) / fmt
->depth
[0]) < pixm
->width
))
661 pixm
->plane_fmt
[0].bytesperline
= (pixm
->width
*
664 if (pixm
->plane_fmt
[0].sizeimage
== 0)
665 pixm
->plane_fmt
[0].sizeimage
= (pixm
->width
* pixm
->height
*
667 pixm
->num_planes
= fmt
->memplanes
;
668 pixm
->pixelformat
= fmt
->fourcc
;
669 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
670 pixm
->field
= V4L2_FIELD_NONE
;
674 static int fimc_lite_try_fmt_mplane(struct file
*file
, void *fh
,
675 struct v4l2_format
*f
)
677 struct fimc_lite
*fimc
= video_drvdata(file
);
679 return fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, NULL
);
682 static int fimc_lite_s_fmt_mplane(struct file
*file
, void *priv
,
683 struct v4l2_format
*f
)
685 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
686 struct fimc_lite
*fimc
= video_drvdata(file
);
687 struct flite_frame
*frame
= &fimc
->out_frame
;
688 const struct fimc_fmt
*fmt
= NULL
;
691 if (vb2_is_busy(&fimc
->vb_queue
))
694 ret
= fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, &fmt
);
699 fimc
->payload
[0] = max((pixm
->width
* pixm
->height
* fmt
->depth
[0]) / 8,
700 pixm
->plane_fmt
[0].sizeimage
);
701 frame
->f_width
= pixm
->width
;
702 frame
->f_height
= pixm
->height
;
707 static int fimc_pipeline_validate(struct fimc_lite
*fimc
)
709 struct v4l2_subdev
*sd
= &fimc
->subdev
;
710 struct v4l2_subdev_format sink_fmt
, src_fmt
;
711 struct media_pad
*pad
;
715 /* Retrieve format at the sink pad */
716 pad
= &sd
->entity
.pads
[0];
717 if (!(pad
->flags
& MEDIA_PAD_FL_SINK
))
719 /* Don't call FIMC subdev operation to avoid nested locking */
720 if (sd
== &fimc
->subdev
) {
721 struct flite_frame
*ff
= &fimc
->out_frame
;
722 sink_fmt
.format
.width
= ff
->f_width
;
723 sink_fmt
.format
.height
= ff
->f_height
;
724 sink_fmt
.format
.code
= fimc
->fmt
->mbus_code
;
726 sink_fmt
.pad
= pad
->index
;
727 sink_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
728 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
,
730 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
733 /* Retrieve format at the source pad */
734 pad
= media_entity_remote_source(pad
);
736 media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
739 sd
= media_entity_to_v4l2_subdev(pad
->entity
);
740 src_fmt
.pad
= pad
->index
;
741 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
742 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &src_fmt
);
743 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
746 if (src_fmt
.format
.width
!= sink_fmt
.format
.width
||
747 src_fmt
.format
.height
!= sink_fmt
.format
.height
||
748 src_fmt
.format
.code
!= sink_fmt
.format
.code
)
754 static int fimc_lite_streamon(struct file
*file
, void *priv
,
755 enum v4l2_buf_type type
)
757 struct fimc_lite
*fimc
= video_drvdata(file
);
758 struct v4l2_subdev
*sensor
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
759 struct fimc_pipeline
*p
= &fimc
->pipeline
;
762 if (fimc_lite_active(fimc
))
765 media_entity_pipeline_start(&sensor
->entity
, p
->m_pipeline
);
767 ret
= fimc_pipeline_validate(fimc
);
769 media_entity_pipeline_stop(&sensor
->entity
);
773 return vb2_streamon(&fimc
->vb_queue
, type
);
776 static int fimc_lite_streamoff(struct file
*file
, void *priv
,
777 enum v4l2_buf_type type
)
779 struct fimc_lite
*fimc
= video_drvdata(file
);
780 struct v4l2_subdev
*sd
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
783 ret
= vb2_streamoff(&fimc
->vb_queue
, type
);
785 media_entity_pipeline_stop(&sd
->entity
);
789 static int fimc_lite_reqbufs(struct file
*file
, void *priv
,
790 struct v4l2_requestbuffers
*reqbufs
)
792 struct fimc_lite
*fimc
= video_drvdata(file
);
795 reqbufs
->count
= max_t(u32
, FLITE_REQ_BUFS_MIN
, reqbufs
->count
);
796 ret
= vb2_reqbufs(&fimc
->vb_queue
, reqbufs
);
798 fimc
->reqbufs_count
= reqbufs
->count
;
803 static int fimc_lite_querybuf(struct file
*file
, void *priv
,
804 struct v4l2_buffer
*buf
)
806 struct fimc_lite
*fimc
= video_drvdata(file
);
808 return vb2_querybuf(&fimc
->vb_queue
, buf
);
811 static int fimc_lite_qbuf(struct file
*file
, void *priv
,
812 struct v4l2_buffer
*buf
)
814 struct fimc_lite
*fimc
= video_drvdata(file
);
816 return vb2_qbuf(&fimc
->vb_queue
, buf
);
819 static int fimc_lite_dqbuf(struct file
*file
, void *priv
,
820 struct v4l2_buffer
*buf
)
822 struct fimc_lite
*fimc
= video_drvdata(file
);
824 return vb2_dqbuf(&fimc
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
827 static int fimc_lite_create_bufs(struct file
*file
, void *priv
,
828 struct v4l2_create_buffers
*create
)
830 struct fimc_lite
*fimc
= video_drvdata(file
);
832 return vb2_create_bufs(&fimc
->vb_queue
, create
);
835 static int fimc_lite_prepare_buf(struct file
*file
, void *priv
,
836 struct v4l2_buffer
*b
)
838 struct fimc_lite
*fimc
= video_drvdata(file
);
840 return vb2_prepare_buf(&fimc
->vb_queue
, b
);
843 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
844 static int enclosed_rectangle(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
846 if (a
->left
< b
->left
|| a
->top
< b
->top
)
848 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
850 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
856 static int fimc_lite_g_selection(struct file
*file
, void *fh
,
857 struct v4l2_selection
*sel
)
859 struct fimc_lite
*fimc
= video_drvdata(file
);
860 struct flite_frame
*f
= &fimc
->out_frame
;
862 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
865 switch (sel
->target
) {
866 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
867 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
870 sel
->r
.width
= f
->f_width
;
871 sel
->r
.height
= f
->f_height
;
874 case V4L2_SEL_TGT_COMPOSE_ACTIVE
:
882 static int fimc_lite_s_selection(struct file
*file
, void *fh
,
883 struct v4l2_selection
*sel
)
885 struct fimc_lite
*fimc
= video_drvdata(file
);
886 struct flite_frame
*f
= &fimc
->out_frame
;
887 struct v4l2_rect rect
= sel
->r
;
890 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
||
891 sel
->target
!= V4L2_SEL_TGT_COMPOSE_ACTIVE
)
894 fimc_lite_try_compose(fimc
, &rect
);
896 if ((sel
->flags
& V4L2_SEL_FLAG_LE
) &&
897 !enclosed_rectangle(&rect
, &sel
->r
))
900 if ((sel
->flags
& V4L2_SEL_FLAG_GE
) &&
901 !enclosed_rectangle(&sel
->r
, &rect
))
905 spin_lock_irqsave(&fimc
->slock
, flags
);
907 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
908 spin_unlock_irqrestore(&fimc
->slock
, flags
);
913 static const struct v4l2_ioctl_ops fimc_lite_ioctl_ops
= {
914 .vidioc_querycap
= fimc_vidioc_querycap_capture
,
915 .vidioc_enum_fmt_vid_cap_mplane
= fimc_lite_enum_fmt_mplane
,
916 .vidioc_try_fmt_vid_cap_mplane
= fimc_lite_try_fmt_mplane
,
917 .vidioc_s_fmt_vid_cap_mplane
= fimc_lite_s_fmt_mplane
,
918 .vidioc_g_fmt_vid_cap_mplane
= fimc_lite_g_fmt_mplane
,
919 .vidioc_g_selection
= fimc_lite_g_selection
,
920 .vidioc_s_selection
= fimc_lite_s_selection
,
921 .vidioc_reqbufs
= fimc_lite_reqbufs
,
922 .vidioc_querybuf
= fimc_lite_querybuf
,
923 .vidioc_prepare_buf
= fimc_lite_prepare_buf
,
924 .vidioc_create_bufs
= fimc_lite_create_bufs
,
925 .vidioc_qbuf
= fimc_lite_qbuf
,
926 .vidioc_dqbuf
= fimc_lite_dqbuf
,
927 .vidioc_streamon
= fimc_lite_streamon
,
928 .vidioc_streamoff
= fimc_lite_streamoff
,
931 /* Capture subdev media entity operations */
932 static int fimc_lite_link_setup(struct media_entity
*entity
,
933 const struct media_pad
*local
,
934 const struct media_pad
*remote
, u32 flags
)
936 struct v4l2_subdev
*sd
= media_entity_to_v4l2_subdev(entity
);
937 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
938 unsigned int remote_ent_type
= media_entity_type(remote
->entity
);
940 if (WARN_ON(fimc
== NULL
))
943 v4l2_dbg(1, debug
, sd
, "%s: %s --> %s, flags: 0x%x. source_id: 0x%x",
944 __func__
, local
->entity
->name
, remote
->entity
->name
,
945 flags
, fimc
->source_subdev_grp_id
);
947 switch (local
->index
) {
948 case FIMC_SD_PAD_SINK
:
949 if (remote_ent_type
!= MEDIA_ENT_T_V4L2_SUBDEV
)
952 if (flags
& MEDIA_LNK_FL_ENABLED
) {
953 if (fimc
->source_subdev_grp_id
!= 0)
955 fimc
->source_subdev_grp_id
= sd
->grp_id
;
959 fimc
->source_subdev_grp_id
= 0;
962 case FIMC_SD_PAD_SOURCE
:
963 if (!(flags
& MEDIA_LNK_FL_ENABLED
)) {
964 fimc
->out_path
= FIMC_IO_NONE
;
967 if (remote_ent_type
== MEDIA_ENT_T_V4L2_SUBDEV
)
968 fimc
->out_path
= FIMC_IO_ISP
;
970 fimc
->out_path
= FIMC_IO_DMA
;
974 v4l2_err(sd
, "Invalid pad index\n");
981 static const struct media_entity_operations fimc_lite_subdev_media_ops
= {
982 .link_setup
= fimc_lite_link_setup
,
985 static int fimc_lite_subdev_enum_mbus_code(struct v4l2_subdev
*sd
,
986 struct v4l2_subdev_fh
*fh
,
987 struct v4l2_subdev_mbus_code_enum
*code
)
989 const struct fimc_fmt
*fmt
;
991 fmt
= fimc_lite_find_format(NULL
, NULL
, code
->index
);
994 code
->code
= fmt
->mbus_code
;
998 static int fimc_lite_subdev_get_fmt(struct v4l2_subdev
*sd
,
999 struct v4l2_subdev_fh
*fh
,
1000 struct v4l2_subdev_format
*fmt
)
1002 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1003 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1004 struct flite_frame
*f
= &fimc
->out_frame
;
1006 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1007 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1011 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1013 mutex_lock(&fimc
->lock
);
1014 mf
->code
= fimc
->fmt
->mbus_code
;
1016 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1017 /* full camera input frame size */
1018 mf
->width
= f
->f_width
;
1019 mf
->height
= f
->f_height
;
1022 mf
->width
= f
->rect
.width
;
1023 mf
->height
= f
->rect
.height
;
1025 mutex_unlock(&fimc
->lock
);
1029 static int fimc_lite_subdev_set_fmt(struct v4l2_subdev
*sd
,
1030 struct v4l2_subdev_fh
*fh
,
1031 struct v4l2_subdev_format
*fmt
)
1033 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1034 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1035 struct flite_frame
*sink
= &fimc
->inp_frame
;
1036 const struct fimc_fmt
*ffmt
;
1038 v4l2_dbg(1, debug
, sd
, "pad%d: code: 0x%x, %dx%d",
1039 fmt
->pad
, mf
->code
, mf
->width
, mf
->height
);
1041 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1042 mutex_lock(&fimc
->lock
);
1044 if ((fimc
->out_path
== FIMC_IO_ISP
&& sd
->entity
.stream_count
> 0) ||
1045 (fimc
->out_path
== FIMC_IO_DMA
&& vb2_is_busy(&fimc
->vb_queue
))) {
1046 mutex_unlock(&fimc
->lock
);
1050 ffmt
= fimc_lite_try_format(fimc
, &mf
->width
, &mf
->height
,
1051 &mf
->code
, NULL
, fmt
->pad
);
1053 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1054 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1056 mutex_unlock(&fimc
->lock
);
1060 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1061 sink
->f_width
= mf
->width
;
1062 sink
->f_height
= mf
->height
;
1064 /* Set sink crop rectangle */
1065 sink
->rect
.width
= mf
->width
;
1066 sink
->rect
.height
= mf
->height
;
1067 sink
->rect
.left
= 0;
1069 /* Reset source crop rectangle */
1070 fimc
->out_frame
.rect
= sink
->rect
;
1072 /* Allow changing format only on sink pad */
1073 mf
->code
= fimc
->fmt
->mbus_code
;
1074 mf
->width
= sink
->rect
.width
;
1075 mf
->height
= sink
->rect
.height
;
1078 mutex_unlock(&fimc
->lock
);
1082 static int fimc_lite_subdev_get_selection(struct v4l2_subdev
*sd
,
1083 struct v4l2_subdev_fh
*fh
,
1084 struct v4l2_subdev_selection
*sel
)
1086 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1087 struct flite_frame
*f
= &fimc
->inp_frame
;
1089 if ((sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
&&
1090 sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_BOUNDS
) ||
1091 sel
->pad
!= FLITE_SD_PAD_SINK
)
1094 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1095 sel
->r
= *v4l2_subdev_get_try_crop(fh
, sel
->pad
);
1099 mutex_lock(&fimc
->lock
);
1100 if (sel
->target
== V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
) {
1105 sel
->r
.width
= f
->f_width
;
1106 sel
->r
.height
= f
->f_height
;
1108 mutex_unlock(&fimc
->lock
);
1110 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1111 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1112 f
->rect
.height
, f
->f_width
, f
->f_height
);
1117 static int fimc_lite_subdev_set_selection(struct v4l2_subdev
*sd
,
1118 struct v4l2_subdev_fh
*fh
,
1119 struct v4l2_subdev_selection
*sel
)
1121 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1122 struct flite_frame
*f
= &fimc
->inp_frame
;
1125 if (sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
||
1126 sel
->pad
!= FLITE_SD_PAD_SINK
)
1129 mutex_lock(&fimc
->lock
);
1130 fimc_lite_try_crop(fimc
, &sel
->r
);
1132 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1133 *v4l2_subdev_get_try_crop(fh
, sel
->pad
) = sel
->r
;
1135 unsigned long flags
;
1136 spin_lock_irqsave(&fimc
->slock
, flags
);
1138 /* Same crop rectangle on the source pad */
1139 fimc
->out_frame
.rect
= sel
->r
;
1140 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1141 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1143 mutex_unlock(&fimc
->lock
);
1145 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1146 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1147 f
->rect
.height
, f
->f_width
, f
->f_height
);
1152 static int fimc_lite_subdev_s_stream(struct v4l2_subdev
*sd
, int on
)
1154 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1156 if (fimc
->out_path
== FIMC_IO_DMA
)
1157 return -ENOIOCTLCMD
;
1164 static int fimc_lite_subdev_s_power(struct v4l2_subdev
*sd
, int on
)
1166 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1168 if (fimc
->out_path
== FIMC_IO_DMA
)
1169 return -ENOIOCTLCMD
;
1176 static int fimc_lite_log_status(struct v4l2_subdev
*sd
)
1178 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1180 flite_hw_dump_regs(fimc
, __func__
);
1184 static int fimc_lite_subdev_registered(struct v4l2_subdev
*sd
)
1186 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1187 struct vb2_queue
*q
= &fimc
->vb_queue
;
1188 struct video_device
*vfd
;
1191 fimc
->fmt
= &fimc_lite_formats
[0];
1192 fimc
->out_path
= FIMC_IO_DMA
;
1194 vfd
= video_device_alloc();
1196 v4l2_err(sd
->v4l2_dev
, "Failed to allocate video device\n");
1200 snprintf(vfd
->name
, sizeof(vfd
->name
), "fimc-lite.%d.capture",
1203 vfd
->fops
= &fimc_lite_fops
;
1204 vfd
->ioctl_ops
= &fimc_lite_ioctl_ops
;
1205 vfd
->v4l2_dev
= sd
->v4l2_dev
;
1207 vfd
->release
= video_device_release
;
1208 vfd
->lock
= &fimc
->lock
;
1210 fimc
->ref_count
= 0;
1211 fimc
->reqbufs_count
= 0;
1213 INIT_LIST_HEAD(&fimc
->pending_buf_q
);
1214 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1216 memset(q
, 0, sizeof(*q
));
1217 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
;
1218 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1219 q
->ops
= &fimc_lite_qops
;
1220 q
->mem_ops
= &vb2_dma_contig_memops
;
1221 q
->buf_struct_size
= sizeof(struct flite_buffer
);
1226 fimc
->vd_pad
.flags
= MEDIA_PAD_FL_SINK
;
1227 ret
= media_entity_init(&vfd
->entity
, 1, &fimc
->vd_pad
, 0);
1231 video_set_drvdata(vfd
, fimc
);
1233 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, -1);
1237 v4l2_info(sd
->v4l2_dev
, "Registered %s as /dev/%s\n",
1238 vfd
->name
, video_device_node_name(vfd
));
1242 media_entity_cleanup(&vfd
->entity
);
1244 video_device_release(vfd
);
1248 static void fimc_lite_subdev_unregistered(struct v4l2_subdev
*sd
)
1250 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1256 video_unregister_device(fimc
->vfd
);
1257 media_entity_cleanup(&fimc
->vfd
->entity
);
1262 static const struct v4l2_subdev_internal_ops fimc_lite_subdev_internal_ops
= {
1263 .registered
= fimc_lite_subdev_registered
,
1264 .unregistered
= fimc_lite_subdev_unregistered
,
1267 static const struct v4l2_subdev_pad_ops fimc_lite_subdev_pad_ops
= {
1268 .enum_mbus_code
= fimc_lite_subdev_enum_mbus_code
,
1269 .get_selection
= fimc_lite_subdev_get_selection
,
1270 .set_selection
= fimc_lite_subdev_set_selection
,
1271 .get_fmt
= fimc_lite_subdev_get_fmt
,
1272 .set_fmt
= fimc_lite_subdev_set_fmt
,
1275 static const struct v4l2_subdev_video_ops fimc_lite_subdev_video_ops
= {
1276 .s_stream
= fimc_lite_subdev_s_stream
,
1279 static const struct v4l2_subdev_core_ops fimc_lite_core_ops
= {
1280 .s_power
= fimc_lite_subdev_s_power
,
1281 .log_status
= fimc_lite_log_status
,
1284 static struct v4l2_subdev_ops fimc_lite_subdev_ops
= {
1285 .core
= &fimc_lite_core_ops
,
1286 .video
= &fimc_lite_subdev_video_ops
,
1287 .pad
= &fimc_lite_subdev_pad_ops
,
1290 static int fimc_lite_s_ctrl(struct v4l2_ctrl
*ctrl
)
1292 struct fimc_lite
*fimc
= container_of(ctrl
->handler
, struct fimc_lite
,
1294 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1298 static const struct v4l2_ctrl_ops fimc_lite_ctrl_ops
= {
1299 .s_ctrl
= fimc_lite_s_ctrl
,
1302 static const struct v4l2_ctrl_config fimc_lite_ctrl
= {
1303 .ops
= &fimc_lite_ctrl_ops
,
1304 .id
= V4L2_CTRL_CLASS_USER
| 0x1001,
1305 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1306 .name
= "Test Pattern 640x480",
1309 static int fimc_lite_create_capture_subdev(struct fimc_lite
*fimc
)
1311 struct v4l2_ctrl_handler
*handler
= &fimc
->ctrl_handler
;
1312 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1315 v4l2_subdev_init(sd
, &fimc_lite_subdev_ops
);
1316 sd
->flags
= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1317 snprintf(sd
->name
, sizeof(sd
->name
), "FIMC-LITE.%d", fimc
->index
);
1319 fimc
->subdev_pads
[FIMC_SD_PAD_SINK
].flags
= MEDIA_PAD_FL_SINK
;
1320 fimc
->subdev_pads
[FIMC_SD_PAD_SOURCE
].flags
= MEDIA_PAD_FL_SOURCE
;
1321 ret
= media_entity_init(&sd
->entity
, FIMC_SD_PADS_NUM
,
1322 fimc
->subdev_pads
, 0);
1326 v4l2_ctrl_handler_init(handler
, 1);
1327 fimc
->test_pattern
= v4l2_ctrl_new_custom(handler
, &fimc_lite_ctrl
,
1329 if (handler
->error
) {
1330 media_entity_cleanup(&sd
->entity
);
1331 return handler
->error
;
1334 sd
->ctrl_handler
= handler
;
1335 sd
->internal_ops
= &fimc_lite_subdev_internal_ops
;
1336 sd
->entity
.ops
= &fimc_lite_subdev_media_ops
;
1337 v4l2_set_subdevdata(sd
, fimc
);
1342 static void fimc_lite_unregister_capture_subdev(struct fimc_lite
*fimc
)
1344 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1346 v4l2_device_unregister_subdev(sd
);
1347 media_entity_cleanup(&sd
->entity
);
1348 v4l2_ctrl_handler_free(&fimc
->ctrl_handler
);
1349 v4l2_set_subdevdata(sd
, NULL
);
1352 static void fimc_lite_clk_put(struct fimc_lite
*fimc
)
1354 if (IS_ERR_OR_NULL(fimc
->clock
))
1357 clk_unprepare(fimc
->clock
);
1358 clk_put(fimc
->clock
);
1362 static int fimc_lite_clk_get(struct fimc_lite
*fimc
)
1366 fimc
->clock
= clk_get(&fimc
->pdev
->dev
, FLITE_CLK_NAME
);
1367 if (IS_ERR(fimc
->clock
))
1368 return PTR_ERR(fimc
->clock
);
1370 ret
= clk_prepare(fimc
->clock
);
1372 clk_put(fimc
->clock
);
1378 static int __devinit
fimc_lite_probe(struct platform_device
*pdev
)
1380 struct flite_drvdata
*drv_data
= fimc_lite_get_drvdata(pdev
);
1381 struct fimc_lite
*fimc
;
1382 struct resource
*res
;
1385 fimc
= devm_kzalloc(&pdev
->dev
, sizeof(*fimc
), GFP_KERNEL
);
1389 fimc
->index
= pdev
->id
;
1390 fimc
->variant
= drv_data
->variant
[fimc
->index
];
1393 init_waitqueue_head(&fimc
->irq_queue
);
1394 spin_lock_init(&fimc
->slock
);
1395 mutex_init(&fimc
->lock
);
1397 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1398 fimc
->regs
= devm_request_and_ioremap(&pdev
->dev
, res
);
1399 if (fimc
->regs
== NULL
) {
1400 dev_err(&pdev
->dev
, "Failed to obtain io memory\n");
1404 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1406 dev_err(&pdev
->dev
, "Failed to get IRQ resource\n");
1410 ret
= fimc_lite_clk_get(fimc
);
1414 ret
= devm_request_irq(&pdev
->dev
, res
->start
, flite_irq_handler
,
1415 0, dev_name(&pdev
->dev
), fimc
);
1417 dev_err(&pdev
->dev
, "Failed to install irq (%d)\n", ret
);
1421 /* The video node will be created within the subdev's registered() op */
1422 ret
= fimc_lite_create_capture_subdev(fimc
);
1426 platform_set_drvdata(pdev
, fimc
);
1427 pm_runtime_enable(&pdev
->dev
);
1428 ret
= pm_runtime_get_sync(&pdev
->dev
);
1432 fimc
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1433 if (IS_ERR(fimc
->alloc_ctx
)) {
1434 ret
= PTR_ERR(fimc
->alloc_ctx
);
1437 pm_runtime_put(&pdev
->dev
);
1439 dev_dbg(&pdev
->dev
, "FIMC-LITE.%d registered successfully\n",
1443 pm_runtime_put(&pdev
->dev
);
1445 fimc_lite_unregister_capture_subdev(fimc
);
1447 fimc_lite_clk_put(fimc
);
1451 static int fimc_lite_runtime_resume(struct device
*dev
)
1453 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1455 clk_enable(fimc
->clock
);
1459 static int fimc_lite_runtime_suspend(struct device
*dev
)
1461 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1463 clk_disable(fimc
->clock
);
1467 #ifdef CONFIG_PM_SLEEP
1468 static int fimc_lite_resume(struct device
*dev
)
1470 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1471 struct flite_buffer
*buf
;
1472 unsigned long flags
;
1475 spin_lock_irqsave(&fimc
->slock
, flags
);
1476 if (!test_and_clear_bit(ST_LPM
, &fimc
->state
) ||
1477 !test_bit(ST_FLITE_IN_USE
, &fimc
->state
)) {
1478 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1481 flite_hw_reset(fimc
);
1482 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1484 if (!test_and_clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
))
1487 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1488 fimc_pipeline_initialize(&fimc
->pipeline
, &fimc
->vfd
->entity
, false);
1489 fimc_lite_hw_init(fimc
);
1490 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
1492 for (i
= 0; i
< fimc
->reqbufs_count
; i
++) {
1493 if (list_empty(&fimc
->pending_buf_q
))
1495 buf
= fimc_lite_pending_queue_pop(fimc
);
1496 buffer_queue(&buf
->vb
);
1501 static int fimc_lite_suspend(struct device
*dev
)
1503 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1504 bool suspend
= test_bit(ST_FLITE_IN_USE
, &fimc
->state
);
1507 if (test_and_set_bit(ST_LPM
, &fimc
->state
))
1510 ret
= fimc_lite_stop_capture(fimc
, suspend
);
1514 return fimc_pipeline_shutdown(&fimc
->pipeline
);
1516 #endif /* CONFIG_PM_SLEEP */
1518 static int __devexit
fimc_lite_remove(struct platform_device
*pdev
)
1520 struct fimc_lite
*fimc
= platform_get_drvdata(pdev
);
1521 struct device
*dev
= &pdev
->dev
;
1523 pm_runtime_disable(dev
);
1524 pm_runtime_set_suspended(dev
);
1525 fimc_lite_unregister_capture_subdev(fimc
);
1526 vb2_dma_contig_cleanup_ctx(fimc
->alloc_ctx
);
1527 fimc_lite_clk_put(fimc
);
1529 dev_info(dev
, "Driver unloaded\n");
1533 static struct flite_variant fimc_lite0_variant_exynos4
= {
1536 .out_width_align
= 8,
1537 .win_hor_offs_align
= 2,
1538 .out_hor_offs_align
= 8,
1541 /* EXYNOS4212, EXYNOS4412 */
1542 static struct flite_drvdata fimc_lite_drvdata_exynos4
= {
1544 [0] = &fimc_lite0_variant_exynos4
,
1545 [1] = &fimc_lite0_variant_exynos4
,
1549 static struct platform_device_id fimc_lite_driver_ids
[] = {
1551 .name
= "exynos-fimc-lite",
1552 .driver_data
= (unsigned long)&fimc_lite_drvdata_exynos4
,
1556 MODULE_DEVICE_TABLE(platform
, fimc_lite_driver_ids
);
1558 static const struct dev_pm_ops fimc_lite_pm_ops
= {
1559 SET_SYSTEM_SLEEP_PM_OPS(fimc_lite_suspend
, fimc_lite_resume
)
1560 SET_RUNTIME_PM_OPS(fimc_lite_runtime_suspend
, fimc_lite_runtime_resume
,
1564 static struct platform_driver fimc_lite_driver
= {
1565 .probe
= fimc_lite_probe
,
1566 .remove
= __devexit_p(fimc_lite_remove
),
1567 .id_table
= fimc_lite_driver_ids
,
1569 .name
= FIMC_LITE_DRV_NAME
,
1570 .owner
= THIS_MODULE
,
1571 .pm
= &fimc_lite_pm_ops
,
1574 module_platform_driver(fimc_lite_driver
);
1575 MODULE_LICENSE("GPL");
1576 MODULE_ALIAS("platform:" FIMC_LITE_DRV_NAME
);