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
);
456 set_bit(ST_FLITE_IN_USE
, &fimc
->state
);
457 ret
= pm_runtime_get_sync(&fimc
->pdev
->dev
);
461 if (++fimc
->ref_count
!= 1 || fimc
->out_path
!= FIMC_IO_DMA
)
464 ret
= v4l2_fh_open(file
);
468 ret
= fimc_pipeline_initialize(&fimc
->pipeline
, &fimc
->vfd
->entity
,
471 pm_runtime_put_sync(&fimc
->pdev
->dev
);
473 v4l2_fh_release(file
);
474 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
477 fimc_lite_clear_event_counters(fimc
);
481 static int fimc_lite_close(struct file
*file
)
483 struct fimc_lite
*fimc
= video_drvdata(file
);
485 if (--fimc
->ref_count
== 0 && fimc
->out_path
== FIMC_IO_DMA
) {
486 clear_bit(ST_FLITE_IN_USE
, &fimc
->state
);
487 fimc_lite_stop_capture(fimc
, false);
488 fimc_pipeline_shutdown(&fimc
->pipeline
);
489 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
492 pm_runtime_put(&fimc
->pdev
->dev
);
494 if (fimc
->ref_count
== 0)
495 vb2_queue_release(&fimc
->vb_queue
);
497 return v4l2_fh_release(file
);
500 static unsigned int fimc_lite_poll(struct file
*file
,
501 struct poll_table_struct
*wait
)
503 struct fimc_lite
*fimc
= video_drvdata(file
);
504 return vb2_poll(&fimc
->vb_queue
, file
, wait
);
507 static int fimc_lite_mmap(struct file
*file
, struct vm_area_struct
*vma
)
509 struct fimc_lite
*fimc
= video_drvdata(file
);
510 return vb2_mmap(&fimc
->vb_queue
, vma
);
513 static const struct v4l2_file_operations fimc_lite_fops
= {
514 .owner
= THIS_MODULE
,
515 .open
= fimc_lite_open
,
516 .release
= fimc_lite_close
,
517 .poll
= fimc_lite_poll
,
518 .unlocked_ioctl
= video_ioctl2
,
519 .mmap
= fimc_lite_mmap
,
523 * Format and crop negotiation helpers
526 static const struct fimc_fmt
*fimc_lite_try_format(struct fimc_lite
*fimc
,
527 u32
*width
, u32
*height
,
528 u32
*code
, u32
*fourcc
, int pad
)
530 struct flite_variant
*variant
= fimc
->variant
;
531 const struct fimc_fmt
*fmt
;
533 fmt
= fimc_lite_find_format(fourcc
, code
, 0);
538 *code
= fmt
->mbus_code
;
540 *fourcc
= fmt
->fourcc
;
542 if (pad
== FLITE_SD_PAD_SINK
) {
543 v4l_bound_align_image(width
, 8, variant
->max_width
,
544 ffs(variant
->out_width_align
) - 1,
545 height
, 0, variant
->max_height
, 0, 0);
547 v4l_bound_align_image(width
, 8, fimc
->inp_frame
.rect
.width
,
548 ffs(variant
->out_width_align
) - 1,
549 height
, 0, fimc
->inp_frame
.rect
.height
,
553 v4l2_dbg(1, debug
, &fimc
->subdev
, "code: 0x%x, %dx%d\n",
554 code
? *code
: 0, *width
, *height
);
559 static void fimc_lite_try_crop(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
561 struct flite_frame
*frame
= &fimc
->inp_frame
;
563 v4l_bound_align_image(&r
->width
, 0, frame
->f_width
, 0,
564 &r
->height
, 0, frame
->f_height
, 0, 0);
566 /* Adjust left/top if cropping rectangle got out of bounds */
567 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
568 r
->left
= round_down(r
->left
, fimc
->variant
->win_hor_offs_align
);
569 r
->top
= clamp_t(u32
, r
->top
, 0, frame
->f_height
- r
->height
);
571 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, sink fmt: %dx%d",
572 r
->left
, r
->top
, r
->width
, r
->height
,
573 frame
->f_width
, frame
->f_height
);
576 static void fimc_lite_try_compose(struct fimc_lite
*fimc
, struct v4l2_rect
*r
)
578 struct flite_frame
*frame
= &fimc
->out_frame
;
579 struct v4l2_rect
*crop_rect
= &fimc
->inp_frame
.rect
;
581 /* Scaling is not supported so we enforce compose rectangle size
582 same as size of the sink crop rectangle. */
583 r
->width
= crop_rect
->width
;
584 r
->height
= crop_rect
->height
;
586 /* Adjust left/top if the composing rectangle got out of bounds */
587 r
->left
= clamp_t(u32
, r
->left
, 0, frame
->f_width
- r
->width
);
588 r
->left
= round_down(r
->left
, fimc
->variant
->out_hor_offs_align
);
589 r
->top
= clamp_t(u32
, r
->top
, 0, fimc
->out_frame
.f_height
- r
->height
);
591 v4l2_dbg(1, debug
, &fimc
->subdev
, "(%d,%d)/%dx%d, source fmt: %dx%d",
592 r
->left
, r
->top
, r
->width
, r
->height
,
593 frame
->f_width
, frame
->f_height
);
597 * Video node ioctl operations
599 static int fimc_vidioc_querycap_capture(struct file
*file
, void *priv
,
600 struct v4l2_capability
*cap
)
602 strlcpy(cap
->driver
, FIMC_LITE_DRV_NAME
, sizeof(cap
->driver
));
603 cap
->bus_info
[0] = 0;
605 cap
->capabilities
= V4L2_CAP_STREAMING
;
609 static int fimc_lite_enum_fmt_mplane(struct file
*file
, void *priv
,
610 struct v4l2_fmtdesc
*f
)
612 const struct fimc_fmt
*fmt
;
614 if (f
->index
>= ARRAY_SIZE(fimc_lite_formats
))
617 fmt
= &fimc_lite_formats
[f
->index
];
618 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
619 f
->pixelformat
= fmt
->fourcc
;
624 static int fimc_lite_g_fmt_mplane(struct file
*file
, void *fh
,
625 struct v4l2_format
*f
)
627 struct fimc_lite
*fimc
= video_drvdata(file
);
628 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
629 struct v4l2_plane_pix_format
*plane_fmt
= &pixm
->plane_fmt
[0];
630 struct flite_frame
*frame
= &fimc
->out_frame
;
631 const struct fimc_fmt
*fmt
= fimc
->fmt
;
633 plane_fmt
->bytesperline
= (frame
->f_width
* fmt
->depth
[0]) / 8;
634 plane_fmt
->sizeimage
= plane_fmt
->bytesperline
* frame
->f_height
;
636 pixm
->num_planes
= fmt
->memplanes
;
637 pixm
->pixelformat
= fmt
->fourcc
;
638 pixm
->width
= frame
->f_width
;
639 pixm
->height
= frame
->f_height
;
640 pixm
->field
= V4L2_FIELD_NONE
;
641 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
645 static int fimc_lite_try_fmt(struct fimc_lite
*fimc
,
646 struct v4l2_pix_format_mplane
*pixm
,
647 const struct fimc_fmt
**ffmt
)
649 struct flite_variant
*variant
= fimc
->variant
;
650 u32 bpl
= pixm
->plane_fmt
[0].bytesperline
;
651 const struct fimc_fmt
*fmt
;
653 fmt
= fimc_lite_find_format(&pixm
->pixelformat
, NULL
, 0);
654 if (WARN_ON(fmt
== NULL
))
658 v4l_bound_align_image(&pixm
->width
, 8, variant
->max_width
,
659 ffs(variant
->out_width_align
) - 1,
660 &pixm
->height
, 0, variant
->max_height
, 0, 0);
662 if ((bpl
== 0 || ((bpl
* 8) / fmt
->depth
[0]) < pixm
->width
))
663 pixm
->plane_fmt
[0].bytesperline
= (pixm
->width
*
666 if (pixm
->plane_fmt
[0].sizeimage
== 0)
667 pixm
->plane_fmt
[0].sizeimage
= (pixm
->width
* pixm
->height
*
669 pixm
->num_planes
= fmt
->memplanes
;
670 pixm
->pixelformat
= fmt
->fourcc
;
671 pixm
->colorspace
= V4L2_COLORSPACE_JPEG
;
672 pixm
->field
= V4L2_FIELD_NONE
;
676 static int fimc_lite_try_fmt_mplane(struct file
*file
, void *fh
,
677 struct v4l2_format
*f
)
679 struct fimc_lite
*fimc
= video_drvdata(file
);
681 return fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, NULL
);
684 static int fimc_lite_s_fmt_mplane(struct file
*file
, void *priv
,
685 struct v4l2_format
*f
)
687 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
688 struct fimc_lite
*fimc
= video_drvdata(file
);
689 struct flite_frame
*frame
= &fimc
->out_frame
;
690 const struct fimc_fmt
*fmt
= NULL
;
693 if (vb2_is_busy(&fimc
->vb_queue
))
696 ret
= fimc_lite_try_fmt(fimc
, &f
->fmt
.pix_mp
, &fmt
);
701 fimc
->payload
[0] = max((pixm
->width
* pixm
->height
* fmt
->depth
[0]) / 8,
702 pixm
->plane_fmt
[0].sizeimage
);
703 frame
->f_width
= pixm
->width
;
704 frame
->f_height
= pixm
->height
;
709 static int fimc_pipeline_validate(struct fimc_lite
*fimc
)
711 struct v4l2_subdev
*sd
= &fimc
->subdev
;
712 struct v4l2_subdev_format sink_fmt
, src_fmt
;
713 struct media_pad
*pad
;
717 /* Retrieve format at the sink pad */
718 pad
= &sd
->entity
.pads
[0];
719 if (!(pad
->flags
& MEDIA_PAD_FL_SINK
))
721 /* Don't call FIMC subdev operation to avoid nested locking */
722 if (sd
== &fimc
->subdev
) {
723 struct flite_frame
*ff
= &fimc
->out_frame
;
724 sink_fmt
.format
.width
= ff
->f_width
;
725 sink_fmt
.format
.height
= ff
->f_height
;
726 sink_fmt
.format
.code
= fimc
->fmt
->mbus_code
;
728 sink_fmt
.pad
= pad
->index
;
729 sink_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
730 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
,
732 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
735 /* Retrieve format at the source pad */
736 pad
= media_entity_remote_source(pad
);
738 media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
741 sd
= media_entity_to_v4l2_subdev(pad
->entity
);
742 src_fmt
.pad
= pad
->index
;
743 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
744 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &src_fmt
);
745 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
748 if (src_fmt
.format
.width
!= sink_fmt
.format
.width
||
749 src_fmt
.format
.height
!= sink_fmt
.format
.height
||
750 src_fmt
.format
.code
!= sink_fmt
.format
.code
)
756 static int fimc_lite_streamon(struct file
*file
, void *priv
,
757 enum v4l2_buf_type type
)
759 struct fimc_lite
*fimc
= video_drvdata(file
);
760 struct v4l2_subdev
*sensor
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
761 struct fimc_pipeline
*p
= &fimc
->pipeline
;
764 if (fimc_lite_active(fimc
))
767 ret
= media_entity_pipeline_start(&sensor
->entity
, p
->m_pipeline
);
771 ret
= fimc_pipeline_validate(fimc
);
773 media_entity_pipeline_stop(&sensor
->entity
);
777 return vb2_streamon(&fimc
->vb_queue
, type
);
780 static int fimc_lite_streamoff(struct file
*file
, void *priv
,
781 enum v4l2_buf_type type
)
783 struct fimc_lite
*fimc
= video_drvdata(file
);
784 struct v4l2_subdev
*sd
= fimc
->pipeline
.subdevs
[IDX_SENSOR
];
787 ret
= vb2_streamoff(&fimc
->vb_queue
, type
);
789 media_entity_pipeline_stop(&sd
->entity
);
793 static int fimc_lite_reqbufs(struct file
*file
, void *priv
,
794 struct v4l2_requestbuffers
*reqbufs
)
796 struct fimc_lite
*fimc
= video_drvdata(file
);
799 reqbufs
->count
= max_t(u32
, FLITE_REQ_BUFS_MIN
, reqbufs
->count
);
800 ret
= vb2_reqbufs(&fimc
->vb_queue
, reqbufs
);
802 fimc
->reqbufs_count
= reqbufs
->count
;
807 static int fimc_lite_querybuf(struct file
*file
, void *priv
,
808 struct v4l2_buffer
*buf
)
810 struct fimc_lite
*fimc
= video_drvdata(file
);
812 return vb2_querybuf(&fimc
->vb_queue
, buf
);
815 static int fimc_lite_qbuf(struct file
*file
, void *priv
,
816 struct v4l2_buffer
*buf
)
818 struct fimc_lite
*fimc
= video_drvdata(file
);
820 return vb2_qbuf(&fimc
->vb_queue
, buf
);
823 static int fimc_lite_dqbuf(struct file
*file
, void *priv
,
824 struct v4l2_buffer
*buf
)
826 struct fimc_lite
*fimc
= video_drvdata(file
);
828 return vb2_dqbuf(&fimc
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
831 static int fimc_lite_create_bufs(struct file
*file
, void *priv
,
832 struct v4l2_create_buffers
*create
)
834 struct fimc_lite
*fimc
= video_drvdata(file
);
836 return vb2_create_bufs(&fimc
->vb_queue
, create
);
839 static int fimc_lite_prepare_buf(struct file
*file
, void *priv
,
840 struct v4l2_buffer
*b
)
842 struct fimc_lite
*fimc
= video_drvdata(file
);
844 return vb2_prepare_buf(&fimc
->vb_queue
, b
);
847 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
848 static int enclosed_rectangle(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
850 if (a
->left
< b
->left
|| a
->top
< b
->top
)
852 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
854 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
860 static int fimc_lite_g_selection(struct file
*file
, void *fh
,
861 struct v4l2_selection
*sel
)
863 struct fimc_lite
*fimc
= video_drvdata(file
);
864 struct flite_frame
*f
= &fimc
->out_frame
;
866 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
869 switch (sel
->target
) {
870 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
871 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
874 sel
->r
.width
= f
->f_width
;
875 sel
->r
.height
= f
->f_height
;
878 case V4L2_SEL_TGT_COMPOSE_ACTIVE
:
886 static int fimc_lite_s_selection(struct file
*file
, void *fh
,
887 struct v4l2_selection
*sel
)
889 struct fimc_lite
*fimc
= video_drvdata(file
);
890 struct flite_frame
*f
= &fimc
->out_frame
;
891 struct v4l2_rect rect
= sel
->r
;
894 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
||
895 sel
->target
!= V4L2_SEL_TGT_COMPOSE_ACTIVE
)
898 fimc_lite_try_compose(fimc
, &rect
);
900 if ((sel
->flags
& V4L2_SEL_FLAG_LE
) &&
901 !enclosed_rectangle(&rect
, &sel
->r
))
904 if ((sel
->flags
& V4L2_SEL_FLAG_GE
) &&
905 !enclosed_rectangle(&sel
->r
, &rect
))
909 spin_lock_irqsave(&fimc
->slock
, flags
);
911 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
912 spin_unlock_irqrestore(&fimc
->slock
, flags
);
917 static const struct v4l2_ioctl_ops fimc_lite_ioctl_ops
= {
918 .vidioc_querycap
= fimc_vidioc_querycap_capture
,
919 .vidioc_enum_fmt_vid_cap_mplane
= fimc_lite_enum_fmt_mplane
,
920 .vidioc_try_fmt_vid_cap_mplane
= fimc_lite_try_fmt_mplane
,
921 .vidioc_s_fmt_vid_cap_mplane
= fimc_lite_s_fmt_mplane
,
922 .vidioc_g_fmt_vid_cap_mplane
= fimc_lite_g_fmt_mplane
,
923 .vidioc_g_selection
= fimc_lite_g_selection
,
924 .vidioc_s_selection
= fimc_lite_s_selection
,
925 .vidioc_reqbufs
= fimc_lite_reqbufs
,
926 .vidioc_querybuf
= fimc_lite_querybuf
,
927 .vidioc_prepare_buf
= fimc_lite_prepare_buf
,
928 .vidioc_create_bufs
= fimc_lite_create_bufs
,
929 .vidioc_qbuf
= fimc_lite_qbuf
,
930 .vidioc_dqbuf
= fimc_lite_dqbuf
,
931 .vidioc_streamon
= fimc_lite_streamon
,
932 .vidioc_streamoff
= fimc_lite_streamoff
,
935 /* Capture subdev media entity operations */
936 static int fimc_lite_link_setup(struct media_entity
*entity
,
937 const struct media_pad
*local
,
938 const struct media_pad
*remote
, u32 flags
)
940 struct v4l2_subdev
*sd
= media_entity_to_v4l2_subdev(entity
);
941 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
942 unsigned int remote_ent_type
= media_entity_type(remote
->entity
);
944 if (WARN_ON(fimc
== NULL
))
947 v4l2_dbg(1, debug
, sd
, "%s: %s --> %s, flags: 0x%x. source_id: 0x%x",
948 __func__
, local
->entity
->name
, remote
->entity
->name
,
949 flags
, fimc
->source_subdev_grp_id
);
951 switch (local
->index
) {
952 case FIMC_SD_PAD_SINK
:
953 if (remote_ent_type
!= MEDIA_ENT_T_V4L2_SUBDEV
)
956 if (flags
& MEDIA_LNK_FL_ENABLED
) {
957 if (fimc
->source_subdev_grp_id
!= 0)
959 fimc
->source_subdev_grp_id
= sd
->grp_id
;
963 fimc
->source_subdev_grp_id
= 0;
966 case FIMC_SD_PAD_SOURCE
:
967 if (!(flags
& MEDIA_LNK_FL_ENABLED
)) {
968 fimc
->out_path
= FIMC_IO_NONE
;
971 if (remote_ent_type
== MEDIA_ENT_T_V4L2_SUBDEV
)
972 fimc
->out_path
= FIMC_IO_ISP
;
974 fimc
->out_path
= FIMC_IO_DMA
;
978 v4l2_err(sd
, "Invalid pad index\n");
985 static const struct media_entity_operations fimc_lite_subdev_media_ops
= {
986 .link_setup
= fimc_lite_link_setup
,
989 static int fimc_lite_subdev_enum_mbus_code(struct v4l2_subdev
*sd
,
990 struct v4l2_subdev_fh
*fh
,
991 struct v4l2_subdev_mbus_code_enum
*code
)
993 const struct fimc_fmt
*fmt
;
995 fmt
= fimc_lite_find_format(NULL
, NULL
, code
->index
);
998 code
->code
= fmt
->mbus_code
;
1002 static int fimc_lite_subdev_get_fmt(struct v4l2_subdev
*sd
,
1003 struct v4l2_subdev_fh
*fh
,
1004 struct v4l2_subdev_format
*fmt
)
1006 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1007 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1008 struct flite_frame
*f
= &fimc
->out_frame
;
1010 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1011 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1015 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1017 mutex_lock(&fimc
->lock
);
1018 mf
->code
= fimc
->fmt
->mbus_code
;
1020 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1021 /* full camera input frame size */
1022 mf
->width
= f
->f_width
;
1023 mf
->height
= f
->f_height
;
1026 mf
->width
= f
->rect
.width
;
1027 mf
->height
= f
->rect
.height
;
1029 mutex_unlock(&fimc
->lock
);
1033 static int fimc_lite_subdev_set_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
*sink
= &fimc
->inp_frame
;
1040 const struct fimc_fmt
*ffmt
;
1042 v4l2_dbg(1, debug
, sd
, "pad%d: code: 0x%x, %dx%d",
1043 fmt
->pad
, mf
->code
, mf
->width
, mf
->height
);
1045 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1046 mutex_lock(&fimc
->lock
);
1048 if ((fimc
->out_path
== FIMC_IO_ISP
&& sd
->entity
.stream_count
> 0) ||
1049 (fimc
->out_path
== FIMC_IO_DMA
&& vb2_is_busy(&fimc
->vb_queue
))) {
1050 mutex_unlock(&fimc
->lock
);
1054 ffmt
= fimc_lite_try_format(fimc
, &mf
->width
, &mf
->height
,
1055 &mf
->code
, NULL
, fmt
->pad
);
1057 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1058 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1060 mutex_unlock(&fimc
->lock
);
1064 if (fmt
->pad
== FLITE_SD_PAD_SINK
) {
1065 sink
->f_width
= mf
->width
;
1066 sink
->f_height
= mf
->height
;
1068 /* Set sink crop rectangle */
1069 sink
->rect
.width
= mf
->width
;
1070 sink
->rect
.height
= mf
->height
;
1071 sink
->rect
.left
= 0;
1073 /* Reset source crop rectangle */
1074 fimc
->out_frame
.rect
= sink
->rect
;
1076 /* Allow changing format only on sink pad */
1077 mf
->code
= fimc
->fmt
->mbus_code
;
1078 mf
->width
= sink
->rect
.width
;
1079 mf
->height
= sink
->rect
.height
;
1082 mutex_unlock(&fimc
->lock
);
1086 static int fimc_lite_subdev_get_selection(struct v4l2_subdev
*sd
,
1087 struct v4l2_subdev_fh
*fh
,
1088 struct v4l2_subdev_selection
*sel
)
1090 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1091 struct flite_frame
*f
= &fimc
->inp_frame
;
1093 if ((sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
&&
1094 sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_BOUNDS
) ||
1095 sel
->pad
!= FLITE_SD_PAD_SINK
)
1098 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1099 sel
->r
= *v4l2_subdev_get_try_crop(fh
, sel
->pad
);
1103 mutex_lock(&fimc
->lock
);
1104 if (sel
->target
== V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
) {
1109 sel
->r
.width
= f
->f_width
;
1110 sel
->r
.height
= f
->f_height
;
1112 mutex_unlock(&fimc
->lock
);
1114 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1115 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1116 f
->rect
.height
, f
->f_width
, f
->f_height
);
1121 static int fimc_lite_subdev_set_selection(struct v4l2_subdev
*sd
,
1122 struct v4l2_subdev_fh
*fh
,
1123 struct v4l2_subdev_selection
*sel
)
1125 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1126 struct flite_frame
*f
= &fimc
->inp_frame
;
1129 if (sel
->target
!= V4L2_SUBDEV_SEL_TGT_CROP_ACTUAL
||
1130 sel
->pad
!= FLITE_SD_PAD_SINK
)
1133 mutex_lock(&fimc
->lock
);
1134 fimc_lite_try_crop(fimc
, &sel
->r
);
1136 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1137 *v4l2_subdev_get_try_crop(fh
, sel
->pad
) = sel
->r
;
1139 unsigned long flags
;
1140 spin_lock_irqsave(&fimc
->slock
, flags
);
1142 /* Same crop rectangle on the source pad */
1143 fimc
->out_frame
.rect
= sel
->r
;
1144 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1145 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1147 mutex_unlock(&fimc
->lock
);
1149 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
1150 __func__
, f
->rect
.left
, f
->rect
.top
, f
->rect
.width
,
1151 f
->rect
.height
, f
->f_width
, f
->f_height
);
1156 static int fimc_lite_subdev_s_stream(struct v4l2_subdev
*sd
, int on
)
1158 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1160 if (fimc
->out_path
== FIMC_IO_DMA
)
1161 return -ENOIOCTLCMD
;
1168 static int fimc_lite_subdev_s_power(struct v4l2_subdev
*sd
, int on
)
1170 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1172 if (fimc
->out_path
== FIMC_IO_DMA
)
1173 return -ENOIOCTLCMD
;
1180 static int fimc_lite_log_status(struct v4l2_subdev
*sd
)
1182 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1184 flite_hw_dump_regs(fimc
, __func__
);
1188 static int fimc_lite_subdev_registered(struct v4l2_subdev
*sd
)
1190 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1191 struct vb2_queue
*q
= &fimc
->vb_queue
;
1192 struct video_device
*vfd
;
1195 fimc
->fmt
= &fimc_lite_formats
[0];
1196 fimc
->out_path
= FIMC_IO_DMA
;
1198 vfd
= video_device_alloc();
1200 v4l2_err(sd
->v4l2_dev
, "Failed to allocate video device\n");
1204 snprintf(vfd
->name
, sizeof(vfd
->name
), "fimc-lite.%d.capture",
1207 vfd
->fops
= &fimc_lite_fops
;
1208 vfd
->ioctl_ops
= &fimc_lite_ioctl_ops
;
1209 vfd
->v4l2_dev
= sd
->v4l2_dev
;
1211 vfd
->release
= video_device_release
;
1212 vfd
->lock
= &fimc
->lock
;
1214 fimc
->ref_count
= 0;
1215 fimc
->reqbufs_count
= 0;
1217 INIT_LIST_HEAD(&fimc
->pending_buf_q
);
1218 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1220 memset(q
, 0, sizeof(*q
));
1221 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
;
1222 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1223 q
->ops
= &fimc_lite_qops
;
1224 q
->mem_ops
= &vb2_dma_contig_memops
;
1225 q
->buf_struct_size
= sizeof(struct flite_buffer
);
1230 fimc
->vd_pad
.flags
= MEDIA_PAD_FL_SINK
;
1231 ret
= media_entity_init(&vfd
->entity
, 1, &fimc
->vd_pad
, 0);
1235 video_set_drvdata(vfd
, fimc
);
1237 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, -1);
1241 v4l2_info(sd
->v4l2_dev
, "Registered %s as /dev/%s\n",
1242 vfd
->name
, video_device_node_name(vfd
));
1246 media_entity_cleanup(&vfd
->entity
);
1248 video_device_release(vfd
);
1252 static void fimc_lite_subdev_unregistered(struct v4l2_subdev
*sd
)
1254 struct fimc_lite
*fimc
= v4l2_get_subdevdata(sd
);
1260 video_unregister_device(fimc
->vfd
);
1261 media_entity_cleanup(&fimc
->vfd
->entity
);
1266 static const struct v4l2_subdev_internal_ops fimc_lite_subdev_internal_ops
= {
1267 .registered
= fimc_lite_subdev_registered
,
1268 .unregistered
= fimc_lite_subdev_unregistered
,
1271 static const struct v4l2_subdev_pad_ops fimc_lite_subdev_pad_ops
= {
1272 .enum_mbus_code
= fimc_lite_subdev_enum_mbus_code
,
1273 .get_selection
= fimc_lite_subdev_get_selection
,
1274 .set_selection
= fimc_lite_subdev_set_selection
,
1275 .get_fmt
= fimc_lite_subdev_get_fmt
,
1276 .set_fmt
= fimc_lite_subdev_set_fmt
,
1279 static const struct v4l2_subdev_video_ops fimc_lite_subdev_video_ops
= {
1280 .s_stream
= fimc_lite_subdev_s_stream
,
1283 static const struct v4l2_subdev_core_ops fimc_lite_core_ops
= {
1284 .s_power
= fimc_lite_subdev_s_power
,
1285 .log_status
= fimc_lite_log_status
,
1288 static struct v4l2_subdev_ops fimc_lite_subdev_ops
= {
1289 .core
= &fimc_lite_core_ops
,
1290 .video
= &fimc_lite_subdev_video_ops
,
1291 .pad
= &fimc_lite_subdev_pad_ops
,
1294 static int fimc_lite_s_ctrl(struct v4l2_ctrl
*ctrl
)
1296 struct fimc_lite
*fimc
= container_of(ctrl
->handler
, struct fimc_lite
,
1298 set_bit(ST_FLITE_CONFIG
, &fimc
->state
);
1302 static const struct v4l2_ctrl_ops fimc_lite_ctrl_ops
= {
1303 .s_ctrl
= fimc_lite_s_ctrl
,
1306 static const struct v4l2_ctrl_config fimc_lite_ctrl
= {
1307 .ops
= &fimc_lite_ctrl_ops
,
1308 .id
= V4L2_CTRL_CLASS_USER
| 0x1001,
1309 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1310 .name
= "Test Pattern 640x480",
1313 static int fimc_lite_create_capture_subdev(struct fimc_lite
*fimc
)
1315 struct v4l2_ctrl_handler
*handler
= &fimc
->ctrl_handler
;
1316 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1319 v4l2_subdev_init(sd
, &fimc_lite_subdev_ops
);
1320 sd
->flags
= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1321 snprintf(sd
->name
, sizeof(sd
->name
), "FIMC-LITE.%d", fimc
->index
);
1323 fimc
->subdev_pads
[FIMC_SD_PAD_SINK
].flags
= MEDIA_PAD_FL_SINK
;
1324 fimc
->subdev_pads
[FIMC_SD_PAD_SOURCE
].flags
= MEDIA_PAD_FL_SOURCE
;
1325 ret
= media_entity_init(&sd
->entity
, FIMC_SD_PADS_NUM
,
1326 fimc
->subdev_pads
, 0);
1330 v4l2_ctrl_handler_init(handler
, 1);
1331 fimc
->test_pattern
= v4l2_ctrl_new_custom(handler
, &fimc_lite_ctrl
,
1333 if (handler
->error
) {
1334 media_entity_cleanup(&sd
->entity
);
1335 return handler
->error
;
1338 sd
->ctrl_handler
= handler
;
1339 sd
->internal_ops
= &fimc_lite_subdev_internal_ops
;
1340 sd
->entity
.ops
= &fimc_lite_subdev_media_ops
;
1341 v4l2_set_subdevdata(sd
, fimc
);
1346 static void fimc_lite_unregister_capture_subdev(struct fimc_lite
*fimc
)
1348 struct v4l2_subdev
*sd
= &fimc
->subdev
;
1350 v4l2_device_unregister_subdev(sd
);
1351 media_entity_cleanup(&sd
->entity
);
1352 v4l2_ctrl_handler_free(&fimc
->ctrl_handler
);
1353 v4l2_set_subdevdata(sd
, NULL
);
1356 static void fimc_lite_clk_put(struct fimc_lite
*fimc
)
1358 if (IS_ERR_OR_NULL(fimc
->clock
))
1361 clk_unprepare(fimc
->clock
);
1362 clk_put(fimc
->clock
);
1366 static int fimc_lite_clk_get(struct fimc_lite
*fimc
)
1370 fimc
->clock
= clk_get(&fimc
->pdev
->dev
, FLITE_CLK_NAME
);
1371 if (IS_ERR(fimc
->clock
))
1372 return PTR_ERR(fimc
->clock
);
1374 ret
= clk_prepare(fimc
->clock
);
1376 clk_put(fimc
->clock
);
1382 static int __devinit
fimc_lite_probe(struct platform_device
*pdev
)
1384 struct flite_drvdata
*drv_data
= fimc_lite_get_drvdata(pdev
);
1385 struct fimc_lite
*fimc
;
1386 struct resource
*res
;
1389 fimc
= devm_kzalloc(&pdev
->dev
, sizeof(*fimc
), GFP_KERNEL
);
1393 fimc
->index
= pdev
->id
;
1394 fimc
->variant
= drv_data
->variant
[fimc
->index
];
1397 init_waitqueue_head(&fimc
->irq_queue
);
1398 spin_lock_init(&fimc
->slock
);
1399 mutex_init(&fimc
->lock
);
1401 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1402 fimc
->regs
= devm_request_and_ioremap(&pdev
->dev
, res
);
1403 if (fimc
->regs
== NULL
) {
1404 dev_err(&pdev
->dev
, "Failed to obtain io memory\n");
1408 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1410 dev_err(&pdev
->dev
, "Failed to get IRQ resource\n");
1414 ret
= fimc_lite_clk_get(fimc
);
1418 ret
= devm_request_irq(&pdev
->dev
, res
->start
, flite_irq_handler
,
1419 0, dev_name(&pdev
->dev
), fimc
);
1421 dev_err(&pdev
->dev
, "Failed to install irq (%d)\n", ret
);
1425 /* The video node will be created within the subdev's registered() op */
1426 ret
= fimc_lite_create_capture_subdev(fimc
);
1430 platform_set_drvdata(pdev
, fimc
);
1431 pm_runtime_enable(&pdev
->dev
);
1432 ret
= pm_runtime_get_sync(&pdev
->dev
);
1436 fimc
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1437 if (IS_ERR(fimc
->alloc_ctx
)) {
1438 ret
= PTR_ERR(fimc
->alloc_ctx
);
1441 pm_runtime_put(&pdev
->dev
);
1443 dev_dbg(&pdev
->dev
, "FIMC-LITE.%d registered successfully\n",
1447 pm_runtime_put(&pdev
->dev
);
1449 fimc_lite_unregister_capture_subdev(fimc
);
1451 fimc_lite_clk_put(fimc
);
1455 static int fimc_lite_runtime_resume(struct device
*dev
)
1457 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1459 clk_enable(fimc
->clock
);
1463 static int fimc_lite_runtime_suspend(struct device
*dev
)
1465 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1467 clk_disable(fimc
->clock
);
1471 #ifdef CONFIG_PM_SLEEP
1472 static int fimc_lite_resume(struct device
*dev
)
1474 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1475 struct flite_buffer
*buf
;
1476 unsigned long flags
;
1479 spin_lock_irqsave(&fimc
->slock
, flags
);
1480 if (!test_and_clear_bit(ST_LPM
, &fimc
->state
) ||
1481 !test_bit(ST_FLITE_IN_USE
, &fimc
->state
)) {
1482 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1485 flite_hw_reset(fimc
);
1486 spin_unlock_irqrestore(&fimc
->slock
, flags
);
1488 if (!test_and_clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
))
1491 INIT_LIST_HEAD(&fimc
->active_buf_q
);
1492 fimc_pipeline_initialize(&fimc
->pipeline
, &fimc
->vfd
->entity
, false);
1493 fimc_lite_hw_init(fimc
);
1494 clear_bit(ST_FLITE_SUSPENDED
, &fimc
->state
);
1496 for (i
= 0; i
< fimc
->reqbufs_count
; i
++) {
1497 if (list_empty(&fimc
->pending_buf_q
))
1499 buf
= fimc_lite_pending_queue_pop(fimc
);
1500 buffer_queue(&buf
->vb
);
1505 static int fimc_lite_suspend(struct device
*dev
)
1507 struct fimc_lite
*fimc
= dev_get_drvdata(dev
);
1508 bool suspend
= test_bit(ST_FLITE_IN_USE
, &fimc
->state
);
1511 if (test_and_set_bit(ST_LPM
, &fimc
->state
))
1514 ret
= fimc_lite_stop_capture(fimc
, suspend
);
1515 if (ret
< 0 || !fimc_lite_active(fimc
))
1518 return fimc_pipeline_shutdown(&fimc
->pipeline
);
1520 #endif /* CONFIG_PM_SLEEP */
1522 static int __devexit
fimc_lite_remove(struct platform_device
*pdev
)
1524 struct fimc_lite
*fimc
= platform_get_drvdata(pdev
);
1525 struct device
*dev
= &pdev
->dev
;
1527 pm_runtime_disable(dev
);
1528 pm_runtime_set_suspended(dev
);
1529 fimc_lite_unregister_capture_subdev(fimc
);
1530 vb2_dma_contig_cleanup_ctx(fimc
->alloc_ctx
);
1531 fimc_lite_clk_put(fimc
);
1533 dev_info(dev
, "Driver unloaded\n");
1537 static struct flite_variant fimc_lite0_variant_exynos4
= {
1540 .out_width_align
= 8,
1541 .win_hor_offs_align
= 2,
1542 .out_hor_offs_align
= 8,
1545 /* EXYNOS4212, EXYNOS4412 */
1546 static struct flite_drvdata fimc_lite_drvdata_exynos4
= {
1548 [0] = &fimc_lite0_variant_exynos4
,
1549 [1] = &fimc_lite0_variant_exynos4
,
1553 static struct platform_device_id fimc_lite_driver_ids
[] = {
1555 .name
= "exynos-fimc-lite",
1556 .driver_data
= (unsigned long)&fimc_lite_drvdata_exynos4
,
1560 MODULE_DEVICE_TABLE(platform
, fimc_lite_driver_ids
);
1562 static const struct dev_pm_ops fimc_lite_pm_ops
= {
1563 SET_SYSTEM_SLEEP_PM_OPS(fimc_lite_suspend
, fimc_lite_resume
)
1564 SET_RUNTIME_PM_OPS(fimc_lite_runtime_suspend
, fimc_lite_runtime_resume
,
1568 static struct platform_driver fimc_lite_driver
= {
1569 .probe
= fimc_lite_probe
,
1570 .remove
= __devexit_p(fimc_lite_remove
),
1571 .id_table
= fimc_lite_driver_ids
,
1573 .name
= FIMC_LITE_DRV_NAME
,
1574 .owner
= THIS_MODULE
,
1575 .pm
= &fimc_lite_pm_ops
,
1578 module_platform_driver(fimc_lite_driver
);
1579 MODULE_LICENSE("GPL");
1580 MODULE_ALIAS("platform:" FIMC_LITE_DRV_NAME
);