2 * s3c24xx/s3c64xx SoC series Camera Interface (CAMIF) driver
4 * Copyright (C) 2012 Sylwester Nawrocki <sylvester.nawrocki@gmail.com>
5 * Copyright (C) 2012 Tomasz Figa <tomasz.figa@gmail.com>
7 * Based on drivers/media/platform/s5p-fimc,
8 * Copyright (C) 2010 - 2012 Samsung Electronics Co., Ltd.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
14 #define pr_fmt(fmt) "%s:%d " fmt, __func__, __LINE__
16 #include <linux/bug.h>
17 #include <linux/clk.h>
18 #include <linux/device.h>
19 #include <linux/errno.h>
20 #include <linux/i2c.h>
21 #include <linux/interrupt.h>
23 #include <linux/kernel.h>
24 #include <linux/list.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/ratelimit.h>
29 #include <linux/slab.h>
30 #include <linux/types.h>
31 #include <linux/videodev2.h>
33 #include <media/media-device.h>
34 #include <media/v4l2-ctrls.h>
35 #include <media/v4l2-event.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/videobuf2-v4l2.h>
38 #include <media/videobuf2-dma-contig.h>
40 #include "camif-core.h"
41 #include "camif-regs.h"
44 module_param(debug
, int, 0644);
46 /* Locking: called with vp->camif->slock spinlock held */
47 static void camif_cfg_video_path(struct camif_vp
*vp
)
49 WARN_ON(s3c_camif_get_scaler_config(vp
, &vp
->scaler
));
50 camif_hw_set_scaler(vp
);
51 camif_hw_set_flip(vp
);
52 camif_hw_set_target_format(vp
);
53 camif_hw_set_output_dma(vp
);
56 static void camif_prepare_dma_offset(struct camif_vp
*vp
)
58 struct camif_frame
*f
= &vp
->out_frame
;
60 f
->dma_offset
.initial
= f
->rect
.top
* f
->f_width
+ f
->rect
.left
;
61 f
->dma_offset
.line
= f
->f_width
- (f
->rect
.left
+ f
->rect
.width
);
63 pr_debug("dma_offset: initial: %d, line: %d\n",
64 f
->dma_offset
.initial
, f
->dma_offset
.line
);
67 /* Locking: called with camif->slock spinlock held */
68 static int s3c_camif_hw_init(struct camif_dev
*camif
, struct camif_vp
*vp
)
70 const struct s3c_camif_variant
*variant
= camif
->variant
;
72 if (camif
->sensor
.sd
== NULL
|| vp
->out_fmt
== NULL
)
75 if (variant
->ip_revision
== S3C244X_CAMIF_IP_REV
)
76 camif_hw_clear_fifo_overflow(vp
);
77 camif_hw_set_camera_bus(camif
);
78 camif_hw_set_source_format(camif
);
79 camif_hw_set_camera_crop(camif
);
80 camif_hw_set_test_pattern(camif
, camif
->test_pattern
);
81 if (variant
->has_img_effect
)
82 camif_hw_set_effect(camif
, camif
->colorfx
,
83 camif
->colorfx_cb
, camif
->colorfx_cr
);
84 if (variant
->ip_revision
== S3C6410_CAMIF_IP_REV
)
85 camif_hw_set_input_path(vp
);
86 camif_cfg_video_path(vp
);
87 vp
->state
&= ~ST_VP_CONFIG
;
93 * Initialize the video path, only up from the scaler stage. The camera
94 * input interface set up is skipped. This is useful to enable one of the
95 * video paths when the other is already running.
96 * Locking: called with camif->slock spinlock held.
98 static int s3c_camif_hw_vp_init(struct camif_dev
*camif
, struct camif_vp
*vp
)
100 unsigned int ip_rev
= camif
->variant
->ip_revision
;
102 if (vp
->out_fmt
== NULL
)
105 camif_prepare_dma_offset(vp
);
106 if (ip_rev
== S3C244X_CAMIF_IP_REV
)
107 camif_hw_clear_fifo_overflow(vp
);
108 camif_cfg_video_path(vp
);
109 vp
->state
&= ~ST_VP_CONFIG
;
113 static int sensor_set_power(struct camif_dev
*camif
, int on
)
115 struct cam_sensor
*sensor
= &camif
->sensor
;
118 if (camif
->sensor
.power_count
== !on
)
119 err
= v4l2_subdev_call(sensor
->sd
, core
, s_power
, on
);
121 sensor
->power_count
+= on
? 1 : -1;
123 pr_debug("on: %d, power_count: %d, err: %d\n",
124 on
, sensor
->power_count
, err
);
129 static int sensor_set_streaming(struct camif_dev
*camif
, int on
)
131 struct cam_sensor
*sensor
= &camif
->sensor
;
134 if (camif
->sensor
.stream_count
== !on
)
135 err
= v4l2_subdev_call(sensor
->sd
, video
, s_stream
, on
);
137 sensor
->stream_count
+= on
? 1 : -1;
139 pr_debug("on: %d, stream_count: %d, err: %d\n",
140 on
, sensor
->stream_count
, err
);
146 * Reinitialize the driver so it is ready to start streaming again.
147 * Return any buffers to vb2, perform CAMIF software reset and
148 * turn off streaming at the data pipeline (sensor) if required.
150 static int camif_reinitialize(struct camif_vp
*vp
)
152 struct camif_dev
*camif
= vp
->camif
;
153 struct camif_buffer
*buf
;
157 spin_lock_irqsave(&camif
->slock
, flags
);
158 streaming
= vp
->state
& ST_VP_SENSOR_STREAMING
;
160 vp
->state
&= ~(ST_VP_PENDING
| ST_VP_RUNNING
| ST_VP_OFF
|
161 ST_VP_ABORTING
| ST_VP_STREAMING
|
162 ST_VP_SENSOR_STREAMING
| ST_VP_LASTIRQ
);
164 /* Release unused buffers */
165 while (!list_empty(&vp
->pending_buf_q
)) {
166 buf
= camif_pending_queue_pop(vp
);
167 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
170 while (!list_empty(&vp
->active_buf_q
)) {
171 buf
= camif_active_queue_pop(vp
);
172 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
175 spin_unlock_irqrestore(&camif
->slock
, flags
);
180 return sensor_set_streaming(camif
, 0);
183 static bool s3c_vp_active(struct camif_vp
*vp
)
185 struct camif_dev
*camif
= vp
->camif
;
189 spin_lock_irqsave(&camif
->slock
, flags
);
190 ret
= (vp
->state
& ST_VP_RUNNING
) || (vp
->state
& ST_VP_PENDING
);
191 spin_unlock_irqrestore(&camif
->slock
, flags
);
196 static bool camif_is_streaming(struct camif_dev
*camif
)
201 spin_lock_irqsave(&camif
->slock
, flags
);
202 status
= camif
->stream_count
> 0;
203 spin_unlock_irqrestore(&camif
->slock
, flags
);
208 static int camif_stop_capture(struct camif_vp
*vp
)
210 struct camif_dev
*camif
= vp
->camif
;
214 if (!s3c_vp_active(vp
))
217 spin_lock_irqsave(&camif
->slock
, flags
);
218 vp
->state
&= ~(ST_VP_OFF
| ST_VP_LASTIRQ
);
219 vp
->state
|= ST_VP_ABORTING
;
220 spin_unlock_irqrestore(&camif
->slock
, flags
);
222 ret
= wait_event_timeout(vp
->irq_queue
,
223 !(vp
->state
& ST_VP_ABORTING
),
224 msecs_to_jiffies(CAMIF_STOP_TIMEOUT
));
226 spin_lock_irqsave(&camif
->slock
, flags
);
228 if (ret
== 0 && !(vp
->state
& ST_VP_OFF
)) {
229 /* Timed out, forcibly stop capture */
230 vp
->state
&= ~(ST_VP_OFF
| ST_VP_ABORTING
|
233 camif_hw_disable_capture(vp
);
234 camif_hw_enable_scaler(vp
, false);
237 spin_unlock_irqrestore(&camif
->slock
, flags
);
239 return camif_reinitialize(vp
);
242 static int camif_prepare_addr(struct camif_vp
*vp
, struct vb2_buffer
*vb
,
243 struct camif_addr
*paddr
)
245 struct camif_frame
*frame
= &vp
->out_frame
;
248 if (vb
== NULL
|| frame
== NULL
)
251 pix_size
= frame
->rect
.width
* frame
->rect
.height
;
253 pr_debug("colplanes: %d, pix_size: %u\n",
254 vp
->out_fmt
->colplanes
, pix_size
);
256 paddr
->y
= vb2_dma_contig_plane_dma_addr(vb
, 0);
258 switch (vp
->out_fmt
->colplanes
) {
264 /* decompose Y into Y/Cb */
265 paddr
->cb
= (u32
)(paddr
->y
+ pix_size
);
269 paddr
->cb
= (u32
)(paddr
->y
+ pix_size
);
270 /* decompose Y into Y/Cb/Cr */
271 if (vp
->out_fmt
->color
== IMG_FMT_YCBCR422P
)
272 paddr
->cr
= (u32
)(paddr
->cb
+ (pix_size
>> 1));
274 paddr
->cr
= (u32
)(paddr
->cb
+ (pix_size
>> 2));
276 if (vp
->out_fmt
->color
== IMG_FMT_YCRCB420
)
277 swap(paddr
->cb
, paddr
->cr
);
283 pr_debug("DMA address: y: %pad cb: %pad cr: %pad\n",
284 &paddr
->y
, &paddr
->cb
, &paddr
->cr
);
289 irqreturn_t
s3c_camif_irq_handler(int irq
, void *priv
)
291 struct camif_vp
*vp
= priv
;
292 struct camif_dev
*camif
= vp
->camif
;
293 unsigned int ip_rev
= camif
->variant
->ip_revision
;
296 spin_lock(&camif
->slock
);
298 if (ip_rev
== S3C6410_CAMIF_IP_REV
)
299 camif_hw_clear_pending_irq(vp
);
301 status
= camif_hw_get_status(vp
);
303 if (ip_rev
== S3C244X_CAMIF_IP_REV
&& (status
& CISTATUS_OVF_MASK
)) {
304 camif_hw_clear_fifo_overflow(vp
);
308 if (vp
->state
& ST_VP_ABORTING
) {
309 if (vp
->state
& ST_VP_OFF
) {
311 vp
->state
&= ~(ST_VP_OFF
| ST_VP_ABORTING
|
313 wake_up(&vp
->irq_queue
);
315 } else if (vp
->state
& ST_VP_LASTIRQ
) {
316 camif_hw_disable_capture(vp
);
317 camif_hw_enable_scaler(vp
, false);
318 camif_hw_set_lastirq(vp
, false);
319 vp
->state
|= ST_VP_OFF
;
321 /* Disable capture, enable last IRQ */
322 camif_hw_set_lastirq(vp
, true);
323 vp
->state
|= ST_VP_LASTIRQ
;
327 if (!list_empty(&vp
->pending_buf_q
) && (vp
->state
& ST_VP_RUNNING
) &&
328 !list_empty(&vp
->active_buf_q
)) {
330 struct camif_buffer
*vbuf
;
332 * Get previous DMA write buffer index:
333 * 0 => DMA buffer 0, 2;
334 * 1 => DMA buffer 1, 3.
336 index
= (CISTATUS_FRAMECNT(status
) + 2) & 1;
337 vbuf
= camif_active_queue_peek(vp
, index
);
339 if (!WARN_ON(vbuf
== NULL
)) {
340 /* Dequeue a filled buffer */
341 v4l2_get_timestamp(&vbuf
->vb
.v4l2_buf
.timestamp
);
342 vbuf
->vb
.v4l2_buf
.sequence
= vp
->frame_sequence
++;
343 vb2_buffer_done(&vbuf
->vb
, VB2_BUF_STATE_DONE
);
345 /* Set up an empty buffer at the DMA engine */
346 vbuf
= camif_pending_queue_pop(vp
);
348 camif_hw_set_output_addr(vp
, &vbuf
->paddr
, index
);
349 camif_hw_set_output_addr(vp
, &vbuf
->paddr
, index
+ 2);
351 /* Scheduled in H/W, add to the queue */
352 camif_active_queue_add(vp
, vbuf
);
354 } else if (!(vp
->state
& ST_VP_ABORTING
) &&
355 (vp
->state
& ST_VP_PENDING
)) {
356 vp
->state
|= ST_VP_RUNNING
;
359 if (vp
->state
& ST_VP_CONFIG
) {
360 camif_prepare_dma_offset(vp
);
361 camif_hw_set_camera_crop(camif
);
362 camif_hw_set_scaler(vp
);
363 camif_hw_set_flip(vp
);
364 camif_hw_set_test_pattern(camif
, camif
->test_pattern
);
365 if (camif
->variant
->has_img_effect
)
366 camif_hw_set_effect(camif
, camif
->colorfx
,
367 camif
->colorfx_cb
, camif
->colorfx_cr
);
368 vp
->state
&= ~ST_VP_CONFIG
;
371 spin_unlock(&camif
->slock
);
375 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
377 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
378 struct camif_dev
*camif
= vp
->camif
;
383 * We assume the codec capture path is always activated
384 * first, before the preview path starts streaming.
385 * This is required to avoid internal FIFO overflow and
386 * a need for CAMIF software reset.
388 spin_lock_irqsave(&camif
->slock
, flags
);
390 if (camif
->stream_count
== 0) {
391 camif_hw_reset(camif
);
392 ret
= s3c_camif_hw_init(camif
, vp
);
394 ret
= s3c_camif_hw_vp_init(camif
, vp
);
396 spin_unlock_irqrestore(&camif
->slock
, flags
);
399 camif_reinitialize(vp
);
403 spin_lock_irqsave(&camif
->slock
, flags
);
404 vp
->frame_sequence
= 0;
405 vp
->state
|= ST_VP_PENDING
;
407 if (!list_empty(&vp
->pending_buf_q
) &&
408 (!(vp
->state
& ST_VP_STREAMING
) ||
409 !(vp
->state
& ST_VP_SENSOR_STREAMING
))) {
411 camif_hw_enable_scaler(vp
, vp
->scaler
.enable
);
412 camif_hw_enable_capture(vp
);
413 vp
->state
|= ST_VP_STREAMING
;
415 if (!(vp
->state
& ST_VP_SENSOR_STREAMING
)) {
416 vp
->state
|= ST_VP_SENSOR_STREAMING
;
417 spin_unlock_irqrestore(&camif
->slock
, flags
);
418 ret
= sensor_set_streaming(camif
, 1);
420 v4l2_err(&vp
->vdev
, "Sensor s_stream failed\n");
422 camif_hw_dump_regs(camif
, __func__
);
428 spin_unlock_irqrestore(&camif
->slock
, flags
);
432 static void stop_streaming(struct vb2_queue
*vq
)
434 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
435 camif_stop_capture(vp
);
438 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*pfmt
,
439 unsigned int *num_buffers
, unsigned int *num_planes
,
440 unsigned int sizes
[], void *allocators
[])
442 const struct v4l2_pix_format
*pix
= NULL
;
443 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
444 struct camif_dev
*camif
= vp
->camif
;
445 struct camif_frame
*frame
= &vp
->out_frame
;
446 const struct camif_fmt
*fmt
;
450 pix
= &pfmt
->fmt
.pix
;
451 fmt
= s3c_camif_find_format(vp
, &pix
->pixelformat
, -1);
454 size
= (pix
->width
* pix
->height
* fmt
->depth
) / 8;
459 size
= (frame
->f_width
* frame
->f_height
* fmt
->depth
) / 8;
465 sizes
[0] = max(size
, pix
->sizeimage
);
468 allocators
[0] = camif
->alloc_ctx
;
470 pr_debug("size: %u\n", sizes
[0]);
474 static int buffer_prepare(struct vb2_buffer
*vb
)
476 struct camif_vp
*vp
= vb2_get_drv_priv(vb
->vb2_queue
);
478 if (vp
->out_fmt
== NULL
)
481 if (vb2_plane_size(vb
, 0) < vp
->payload
) {
482 v4l2_err(&vp
->vdev
, "buffer too small: %lu, required: %u\n",
483 vb2_plane_size(vb
, 0), vp
->payload
);
486 vb2_set_plane_payload(vb
, 0, vp
->payload
);
491 static void buffer_queue(struct vb2_buffer
*vb
)
493 struct camif_buffer
*buf
= container_of(vb
, struct camif_buffer
, vb
);
494 struct camif_vp
*vp
= vb2_get_drv_priv(vb
->vb2_queue
);
495 struct camif_dev
*camif
= vp
->camif
;
498 spin_lock_irqsave(&camif
->slock
, flags
);
499 WARN_ON(camif_prepare_addr(vp
, &buf
->vb
, &buf
->paddr
));
501 if (!(vp
->state
& ST_VP_STREAMING
) && vp
->active_buffers
< 2) {
502 /* Schedule an empty buffer in H/W */
503 buf
->index
= vp
->buf_index
;
505 camif_hw_set_output_addr(vp
, &buf
->paddr
, buf
->index
);
506 camif_hw_set_output_addr(vp
, &buf
->paddr
, buf
->index
+ 2);
508 camif_active_queue_add(vp
, buf
);
509 vp
->buf_index
= !vp
->buf_index
;
511 camif_pending_queue_add(vp
, buf
);
514 if (vb2_is_streaming(&vp
->vb_queue
) && !list_empty(&vp
->pending_buf_q
)
515 && !(vp
->state
& ST_VP_STREAMING
)) {
517 vp
->state
|= ST_VP_STREAMING
;
518 camif_hw_enable_scaler(vp
, vp
->scaler
.enable
);
519 camif_hw_enable_capture(vp
);
520 spin_unlock_irqrestore(&camif
->slock
, flags
);
522 if (!(vp
->state
& ST_VP_SENSOR_STREAMING
)) {
523 if (sensor_set_streaming(camif
, 1) == 0)
524 vp
->state
|= ST_VP_SENSOR_STREAMING
;
526 v4l2_err(&vp
->vdev
, "Sensor s_stream failed\n");
529 camif_hw_dump_regs(camif
, __func__
);
533 spin_unlock_irqrestore(&camif
->slock
, flags
);
536 static const struct vb2_ops s3c_camif_qops
= {
537 .queue_setup
= queue_setup
,
538 .buf_prepare
= buffer_prepare
,
539 .buf_queue
= buffer_queue
,
540 .wait_prepare
= vb2_ops_wait_prepare
,
541 .wait_finish
= vb2_ops_wait_finish
,
542 .start_streaming
= start_streaming
,
543 .stop_streaming
= stop_streaming
,
546 static int s3c_camif_open(struct file
*file
)
548 struct camif_vp
*vp
= video_drvdata(file
);
549 struct camif_dev
*camif
= vp
->camif
;
552 pr_debug("[vp%d] state: %#x, owner: %p, pid: %d\n", vp
->id
,
553 vp
->state
, vp
->owner
, task_pid_nr(current
));
555 if (mutex_lock_interruptible(&camif
->lock
))
558 ret
= v4l2_fh_open(file
);
562 ret
= pm_runtime_get_sync(camif
->dev
);
566 ret
= sensor_set_power(camif
, 1);
570 pm_runtime_put(camif
->dev
);
572 v4l2_fh_release(file
);
574 mutex_unlock(&camif
->lock
);
578 static int s3c_camif_close(struct file
*file
)
580 struct camif_vp
*vp
= video_drvdata(file
);
581 struct camif_dev
*camif
= vp
->camif
;
584 pr_debug("[vp%d] state: %#x, owner: %p, pid: %d\n", vp
->id
,
585 vp
->state
, vp
->owner
, task_pid_nr(current
));
587 mutex_lock(&camif
->lock
);
589 if (vp
->owner
== file
->private_data
) {
590 camif_stop_capture(vp
);
591 vb2_queue_release(&vp
->vb_queue
);
595 sensor_set_power(camif
, 0);
597 pm_runtime_put(camif
->dev
);
598 ret
= v4l2_fh_release(file
);
600 mutex_unlock(&camif
->lock
);
604 static unsigned int s3c_camif_poll(struct file
*file
,
605 struct poll_table_struct
*wait
)
607 struct camif_vp
*vp
= video_drvdata(file
);
608 struct camif_dev
*camif
= vp
->camif
;
611 mutex_lock(&camif
->lock
);
612 if (vp
->owner
&& vp
->owner
!= file
->private_data
)
615 ret
= vb2_poll(&vp
->vb_queue
, file
, wait
);
617 mutex_unlock(&camif
->lock
);
621 static int s3c_camif_mmap(struct file
*file
, struct vm_area_struct
*vma
)
623 struct camif_vp
*vp
= video_drvdata(file
);
626 if (vp
->owner
&& vp
->owner
!= file
->private_data
)
629 ret
= vb2_mmap(&vp
->vb_queue
, vma
);
634 static const struct v4l2_file_operations s3c_camif_fops
= {
635 .owner
= THIS_MODULE
,
636 .open
= s3c_camif_open
,
637 .release
= s3c_camif_close
,
638 .poll
= s3c_camif_poll
,
639 .unlocked_ioctl
= video_ioctl2
,
640 .mmap
= s3c_camif_mmap
,
647 static int s3c_camif_vidioc_querycap(struct file
*file
, void *priv
,
648 struct v4l2_capability
*cap
)
650 struct camif_vp
*vp
= video_drvdata(file
);
652 strlcpy(cap
->driver
, S3C_CAMIF_DRIVER_NAME
, sizeof(cap
->driver
));
653 strlcpy(cap
->card
, S3C_CAMIF_DRIVER_NAME
, sizeof(cap
->card
));
654 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "platform:%s.%d",
655 dev_name(vp
->camif
->dev
), vp
->id
);
657 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_CAPTURE
;
658 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
663 static int s3c_camif_vidioc_enum_input(struct file
*file
, void *priv
,
664 struct v4l2_input
*input
)
666 struct camif_vp
*vp
= video_drvdata(file
);
667 struct v4l2_subdev
*sensor
= vp
->camif
->sensor
.sd
;
669 if (input
->index
|| sensor
== NULL
)
672 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
673 strlcpy(input
->name
, sensor
->name
, sizeof(input
->name
));
677 static int s3c_camif_vidioc_s_input(struct file
*file
, void *priv
,
680 return i
== 0 ? 0 : -EINVAL
;
683 static int s3c_camif_vidioc_g_input(struct file
*file
, void *priv
,
690 static int s3c_camif_vidioc_enum_fmt(struct file
*file
, void *priv
,
691 struct v4l2_fmtdesc
*f
)
693 struct camif_vp
*vp
= video_drvdata(file
);
694 const struct camif_fmt
*fmt
;
696 fmt
= s3c_camif_find_format(vp
, NULL
, f
->index
);
700 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
701 f
->pixelformat
= fmt
->fourcc
;
703 pr_debug("fmt(%d): %s\n", f
->index
, f
->description
);
707 static int s3c_camif_vidioc_g_fmt(struct file
*file
, void *priv
,
708 struct v4l2_format
*f
)
710 struct camif_vp
*vp
= video_drvdata(file
);
711 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
712 struct camif_frame
*frame
= &vp
->out_frame
;
713 const struct camif_fmt
*fmt
= vp
->out_fmt
;
715 pix
->bytesperline
= frame
->f_width
* fmt
->ybpp
;
716 pix
->sizeimage
= vp
->payload
;
718 pix
->pixelformat
= fmt
->fourcc
;
719 pix
->width
= frame
->f_width
;
720 pix
->height
= frame
->f_height
;
721 pix
->field
= V4L2_FIELD_NONE
;
722 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
727 static int __camif_video_try_format(struct camif_vp
*vp
,
728 struct v4l2_pix_format
*pix
,
729 const struct camif_fmt
**ffmt
)
731 struct camif_dev
*camif
= vp
->camif
;
732 struct v4l2_rect
*crop
= &camif
->camif_crop
;
733 unsigned int wmin
, hmin
, sc_hrmax
, sc_vrmax
;
734 const struct vp_pix_limits
*pix_lim
;
735 const struct camif_fmt
*fmt
;
737 fmt
= s3c_camif_find_format(vp
, &pix
->pixelformat
, 0);
739 if (WARN_ON(fmt
== NULL
))
745 pix_lim
= &camif
->variant
->vp_pix_limits
[vp
->id
];
747 pr_debug("fmt: %ux%u, crop: %ux%u, bytesperline: %u\n",
748 pix
->width
, pix
->height
, crop
->width
, crop
->height
,
751 * Calculate minimum width and height according to the configured
752 * camera input interface crop rectangle and the resizer's capabilities.
754 sc_hrmax
= min(SCALER_MAX_RATIO
, 1 << (ffs(crop
->width
) - 3));
755 sc_vrmax
= min(SCALER_MAX_RATIO
, 1 << (ffs(crop
->height
) - 1));
757 wmin
= max_t(u32
, pix_lim
->min_out_width
, crop
->width
/ sc_hrmax
);
758 wmin
= round_up(wmin
, pix_lim
->out_width_align
);
759 hmin
= max_t(u32
, 8, crop
->height
/ sc_vrmax
);
760 hmin
= round_up(hmin
, 8);
762 v4l_bound_align_image(&pix
->width
, wmin
, pix_lim
->max_sc_out_width
,
763 ffs(pix_lim
->out_width_align
) - 1,
764 &pix
->height
, hmin
, pix_lim
->max_height
, 0, 0);
766 pix
->bytesperline
= pix
->width
* fmt
->ybpp
;
767 pix
->sizeimage
= (pix
->width
* pix
->height
* fmt
->depth
) / 8;
768 pix
->pixelformat
= fmt
->fourcc
;
769 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
770 pix
->field
= V4L2_FIELD_NONE
;
772 pr_debug("%ux%u, wmin: %d, hmin: %d, sc_hrmax: %d, sc_vrmax: %d\n",
773 pix
->width
, pix
->height
, wmin
, hmin
, sc_hrmax
, sc_vrmax
);
778 static int s3c_camif_vidioc_try_fmt(struct file
*file
, void *priv
,
779 struct v4l2_format
*f
)
781 struct camif_vp
*vp
= video_drvdata(file
);
782 return __camif_video_try_format(vp
, &f
->fmt
.pix
, NULL
);
785 static int s3c_camif_vidioc_s_fmt(struct file
*file
, void *priv
,
786 struct v4l2_format
*f
)
788 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
789 struct camif_vp
*vp
= video_drvdata(file
);
790 struct camif_frame
*out_frame
= &vp
->out_frame
;
791 const struct camif_fmt
*fmt
= NULL
;
794 pr_debug("[vp%d]\n", vp
->id
);
796 if (vb2_is_busy(&vp
->vb_queue
))
799 ret
= __camif_video_try_format(vp
, &f
->fmt
.pix
, &fmt
);
804 vp
->payload
= pix
->sizeimage
;
805 out_frame
->f_width
= pix
->width
;
806 out_frame
->f_height
= pix
->height
;
808 /* Reset composition rectangle */
809 out_frame
->rect
.width
= pix
->width
;
810 out_frame
->rect
.height
= pix
->height
;
811 out_frame
->rect
.left
= 0;
812 out_frame
->rect
.top
= 0;
814 if (vp
->owner
== NULL
)
817 pr_debug("%ux%u. payload: %u. fmt: %s. %d %d. sizeimage: %d. bpl: %d\n",
818 out_frame
->f_width
, out_frame
->f_height
, vp
->payload
, fmt
->name
,
819 pix
->width
* pix
->height
* fmt
->depth
, fmt
->depth
,
820 pix
->sizeimage
, pix
->bytesperline
);
825 /* Only check pixel formats at the sensor and the camif subdev pads */
826 static int camif_pipeline_validate(struct camif_dev
*camif
)
828 struct v4l2_subdev_format src_fmt
;
829 struct media_pad
*pad
;
832 /* Retrieve format at the sensor subdev source pad */
833 pad
= media_entity_remote_pad(&camif
->pads
[0]);
834 if (!pad
|| media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
837 src_fmt
.pad
= pad
->index
;
838 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
839 ret
= v4l2_subdev_call(camif
->sensor
.sd
, pad
, get_fmt
, NULL
, &src_fmt
);
840 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
843 if (src_fmt
.format
.width
!= camif
->mbus_fmt
.width
||
844 src_fmt
.format
.height
!= camif
->mbus_fmt
.height
||
845 src_fmt
.format
.code
!= camif
->mbus_fmt
.code
)
851 static int s3c_camif_streamon(struct file
*file
, void *priv
,
852 enum v4l2_buf_type type
)
854 struct camif_vp
*vp
= video_drvdata(file
);
855 struct camif_dev
*camif
= vp
->camif
;
856 struct media_entity
*sensor
= &camif
->sensor
.sd
->entity
;
859 pr_debug("[vp%d]\n", vp
->id
);
861 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
864 if (vp
->owner
&& vp
->owner
!= priv
)
867 if (s3c_vp_active(vp
))
870 ret
= media_entity_pipeline_start(sensor
, camif
->m_pipeline
);
874 ret
= camif_pipeline_validate(camif
);
876 media_entity_pipeline_stop(sensor
);
880 return vb2_streamon(&vp
->vb_queue
, type
);
883 static int s3c_camif_streamoff(struct file
*file
, void *priv
,
884 enum v4l2_buf_type type
)
886 struct camif_vp
*vp
= video_drvdata(file
);
887 struct camif_dev
*camif
= vp
->camif
;
890 pr_debug("[vp%d]\n", vp
->id
);
892 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
895 if (vp
->owner
&& vp
->owner
!= priv
)
898 ret
= vb2_streamoff(&vp
->vb_queue
, type
);
900 media_entity_pipeline_stop(&camif
->sensor
.sd
->entity
);
904 static int s3c_camif_reqbufs(struct file
*file
, void *priv
,
905 struct v4l2_requestbuffers
*rb
)
907 struct camif_vp
*vp
= video_drvdata(file
);
910 pr_debug("[vp%d] rb count: %d, owner: %p, priv: %p\n",
911 vp
->id
, rb
->count
, vp
->owner
, priv
);
913 if (vp
->owner
&& vp
->owner
!= priv
)
917 rb
->count
= max_t(u32
, CAMIF_REQ_BUFS_MIN
, rb
->count
);
921 ret
= vb2_reqbufs(&vp
->vb_queue
, rb
);
925 if (rb
->count
&& rb
->count
< CAMIF_REQ_BUFS_MIN
) {
927 vb2_reqbufs(&vp
->vb_queue
, rb
);
931 vp
->reqbufs_count
= rb
->count
;
932 if (vp
->owner
== NULL
&& rb
->count
> 0)
938 static int s3c_camif_querybuf(struct file
*file
, void *priv
,
939 struct v4l2_buffer
*buf
)
941 struct camif_vp
*vp
= video_drvdata(file
);
942 return vb2_querybuf(&vp
->vb_queue
, buf
);
945 static int s3c_camif_qbuf(struct file
*file
, void *priv
,
946 struct v4l2_buffer
*buf
)
948 struct camif_vp
*vp
= video_drvdata(file
);
950 pr_debug("[vp%d]\n", vp
->id
);
952 if (vp
->owner
&& vp
->owner
!= priv
)
955 return vb2_qbuf(&vp
->vb_queue
, buf
);
958 static int s3c_camif_dqbuf(struct file
*file
, void *priv
,
959 struct v4l2_buffer
*buf
)
961 struct camif_vp
*vp
= video_drvdata(file
);
963 pr_debug("[vp%d] sequence: %d\n", vp
->id
, vp
->frame_sequence
);
965 if (vp
->owner
&& vp
->owner
!= priv
)
968 return vb2_dqbuf(&vp
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
971 static int s3c_camif_create_bufs(struct file
*file
, void *priv
,
972 struct v4l2_create_buffers
*create
)
974 struct camif_vp
*vp
= video_drvdata(file
);
977 if (vp
->owner
&& vp
->owner
!= priv
)
980 create
->count
= max_t(u32
, 1, create
->count
);
981 ret
= vb2_create_bufs(&vp
->vb_queue
, create
);
983 if (!ret
&& vp
->owner
== NULL
)
989 static int s3c_camif_prepare_buf(struct file
*file
, void *priv
,
990 struct v4l2_buffer
*b
)
992 struct camif_vp
*vp
= video_drvdata(file
);
993 return vb2_prepare_buf(&vp
->vb_queue
, b
);
996 static int s3c_camif_g_selection(struct file
*file
, void *priv
,
997 struct v4l2_selection
*sel
)
999 struct camif_vp
*vp
= video_drvdata(file
);
1001 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1004 switch (sel
->target
) {
1005 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
1006 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
1009 sel
->r
.width
= vp
->out_frame
.f_width
;
1010 sel
->r
.height
= vp
->out_frame
.f_height
;
1013 case V4L2_SEL_TGT_COMPOSE
:
1014 sel
->r
= vp
->out_frame
.rect
;
1021 static void __camif_try_compose(struct camif_dev
*camif
, struct camif_vp
*vp
,
1022 struct v4l2_rect
*r
)
1024 /* s3c244x doesn't support composition */
1025 if (camif
->variant
->ip_revision
== S3C244X_CAMIF_IP_REV
) {
1026 *r
= vp
->out_frame
.rect
;
1033 static int s3c_camif_s_selection(struct file
*file
, void *priv
,
1034 struct v4l2_selection
*sel
)
1036 struct camif_vp
*vp
= video_drvdata(file
);
1037 struct camif_dev
*camif
= vp
->camif
;
1038 struct v4l2_rect rect
= sel
->r
;
1039 unsigned long flags
;
1041 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1042 sel
->target
!= V4L2_SEL_TGT_COMPOSE
)
1045 __camif_try_compose(camif
, vp
, &rect
);
1048 spin_lock_irqsave(&camif
->slock
, flags
);
1049 vp
->out_frame
.rect
= rect
;
1050 vp
->state
|= ST_VP_CONFIG
;
1051 spin_unlock_irqrestore(&camif
->slock
, flags
);
1053 pr_debug("type: %#x, target: %#x, flags: %#x, (%d,%d)/%dx%d\n",
1054 sel
->type
, sel
->target
, sel
->flags
,
1055 sel
->r
.left
, sel
->r
.top
, sel
->r
.width
, sel
->r
.height
);
1060 static const struct v4l2_ioctl_ops s3c_camif_ioctl_ops
= {
1061 .vidioc_querycap
= s3c_camif_vidioc_querycap
,
1062 .vidioc_enum_input
= s3c_camif_vidioc_enum_input
,
1063 .vidioc_g_input
= s3c_camif_vidioc_g_input
,
1064 .vidioc_s_input
= s3c_camif_vidioc_s_input
,
1065 .vidioc_enum_fmt_vid_cap
= s3c_camif_vidioc_enum_fmt
,
1066 .vidioc_try_fmt_vid_cap
= s3c_camif_vidioc_try_fmt
,
1067 .vidioc_s_fmt_vid_cap
= s3c_camif_vidioc_s_fmt
,
1068 .vidioc_g_fmt_vid_cap
= s3c_camif_vidioc_g_fmt
,
1069 .vidioc_g_selection
= s3c_camif_g_selection
,
1070 .vidioc_s_selection
= s3c_camif_s_selection
,
1071 .vidioc_reqbufs
= s3c_camif_reqbufs
,
1072 .vidioc_querybuf
= s3c_camif_querybuf
,
1073 .vidioc_prepare_buf
= s3c_camif_prepare_buf
,
1074 .vidioc_create_bufs
= s3c_camif_create_bufs
,
1075 .vidioc_qbuf
= s3c_camif_qbuf
,
1076 .vidioc_dqbuf
= s3c_camif_dqbuf
,
1077 .vidioc_streamon
= s3c_camif_streamon
,
1078 .vidioc_streamoff
= s3c_camif_streamoff
,
1079 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1080 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1081 .vidioc_log_status
= v4l2_ctrl_log_status
,
1085 * Video node controls
1087 static int s3c_camif_video_s_ctrl(struct v4l2_ctrl
*ctrl
)
1089 struct camif_vp
*vp
= ctrl
->priv
;
1090 struct camif_dev
*camif
= vp
->camif
;
1091 unsigned long flags
;
1093 pr_debug("[vp%d] ctrl: %s, value: %d\n", vp
->id
,
1094 ctrl
->name
, ctrl
->val
);
1096 spin_lock_irqsave(&camif
->slock
, flags
);
1099 case V4L2_CID_HFLIP
:
1100 vp
->hflip
= ctrl
->val
;
1103 case V4L2_CID_VFLIP
:
1104 vp
->vflip
= ctrl
->val
;
1108 vp
->state
|= ST_VP_CONFIG
;
1109 spin_unlock_irqrestore(&camif
->slock
, flags
);
1113 /* Codec and preview video node control ops */
1114 static const struct v4l2_ctrl_ops s3c_camif_video_ctrl_ops
= {
1115 .s_ctrl
= s3c_camif_video_s_ctrl
,
1118 int s3c_camif_register_video_node(struct camif_dev
*camif
, int idx
)
1120 struct camif_vp
*vp
= &camif
->vp
[idx
];
1121 struct vb2_queue
*q
= &vp
->vb_queue
;
1122 struct video_device
*vfd
= &vp
->vdev
;
1123 struct v4l2_ctrl
*ctrl
;
1126 memset(vfd
, 0, sizeof(*vfd
));
1127 snprintf(vfd
->name
, sizeof(vfd
->name
), "camif-%s",
1128 vp
->id
== 0 ? "codec" : "preview");
1130 vfd
->fops
= &s3c_camif_fops
;
1131 vfd
->ioctl_ops
= &s3c_camif_ioctl_ops
;
1132 vfd
->v4l2_dev
= &camif
->v4l2_dev
;
1134 vfd
->release
= video_device_release_empty
;
1135 vfd
->lock
= &camif
->lock
;
1136 vp
->reqbufs_count
= 0;
1138 INIT_LIST_HEAD(&vp
->pending_buf_q
);
1139 INIT_LIST_HEAD(&vp
->active_buf_q
);
1141 memset(q
, 0, sizeof(*q
));
1142 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1143 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1144 q
->ops
= &s3c_camif_qops
;
1145 q
->mem_ops
= &vb2_dma_contig_memops
;
1146 q
->buf_struct_size
= sizeof(struct camif_buffer
);
1148 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1149 q
->lock
= &vp
->camif
->lock
;
1151 ret
= vb2_queue_init(q
);
1155 vp
->pad
.flags
= MEDIA_PAD_FL_SINK
;
1156 ret
= media_entity_init(&vfd
->entity
, 1, &vp
->pad
, 0);
1160 video_set_drvdata(vfd
, vp
);
1162 v4l2_ctrl_handler_init(&vp
->ctrl_handler
, 1);
1163 ctrl
= v4l2_ctrl_new_std(&vp
->ctrl_handler
, &s3c_camif_video_ctrl_ops
,
1164 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1167 ctrl
= v4l2_ctrl_new_std(&vp
->ctrl_handler
, &s3c_camif_video_ctrl_ops
,
1168 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1172 ret
= vp
->ctrl_handler
.error
;
1174 goto err_me_cleanup
;
1176 vfd
->ctrl_handler
= &vp
->ctrl_handler
;
1178 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, -1);
1180 goto err_ctrlh_free
;
1182 v4l2_info(&camif
->v4l2_dev
, "registered %s as /dev/%s\n",
1183 vfd
->name
, video_device_node_name(vfd
));
1187 v4l2_ctrl_handler_free(&vp
->ctrl_handler
);
1189 media_entity_cleanup(&vfd
->entity
);
1191 video_device_release(vfd
);
1195 void s3c_camif_unregister_video_node(struct camif_dev
*camif
, int idx
)
1197 struct video_device
*vfd
= &camif
->vp
[idx
].vdev
;
1199 if (video_is_registered(vfd
)) {
1200 video_unregister_device(vfd
);
1201 media_entity_cleanup(&vfd
->entity
);
1202 v4l2_ctrl_handler_free(vfd
->ctrl_handler
);
1206 /* Media bus pixel formats supported at the camif input */
1207 static const u32 camif_mbus_formats
[] = {
1208 MEDIA_BUS_FMT_YUYV8_2X8
,
1209 MEDIA_BUS_FMT_YVYU8_2X8
,
1210 MEDIA_BUS_FMT_UYVY8_2X8
,
1211 MEDIA_BUS_FMT_VYUY8_2X8
,
1215 * Camera input interface subdev operations
1218 static int s3c_camif_subdev_enum_mbus_code(struct v4l2_subdev
*sd
,
1219 struct v4l2_subdev_pad_config
*cfg
,
1220 struct v4l2_subdev_mbus_code_enum
*code
)
1222 if (code
->index
>= ARRAY_SIZE(camif_mbus_formats
))
1225 code
->code
= camif_mbus_formats
[code
->index
];
1229 static int s3c_camif_subdev_get_fmt(struct v4l2_subdev
*sd
,
1230 struct v4l2_subdev_pad_config
*cfg
,
1231 struct v4l2_subdev_format
*fmt
)
1233 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1234 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1236 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1237 mf
= v4l2_subdev_get_try_format(sd
, cfg
, fmt
->pad
);
1242 mutex_lock(&camif
->lock
);
1245 case CAMIF_SD_PAD_SINK
:
1246 /* full camera input pixel size */
1247 *mf
= camif
->mbus_fmt
;
1250 case CAMIF_SD_PAD_SOURCE_C
...CAMIF_SD_PAD_SOURCE_P
:
1251 /* crop rectangle at camera interface input */
1252 mf
->width
= camif
->camif_crop
.width
;
1253 mf
->height
= camif
->camif_crop
.height
;
1254 mf
->code
= camif
->mbus_fmt
.code
;
1258 mutex_unlock(&camif
->lock
);
1259 mf
->field
= V4L2_FIELD_NONE
;
1260 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1264 static void __camif_subdev_try_format(struct camif_dev
*camif
,
1265 struct v4l2_mbus_framefmt
*mf
, int pad
)
1267 const struct s3c_camif_variant
*variant
= camif
->variant
;
1268 const struct vp_pix_limits
*pix_lim
;
1269 int i
= ARRAY_SIZE(camif_mbus_formats
);
1271 /* FIXME: constraints against codec or preview path ? */
1272 pix_lim
= &variant
->vp_pix_limits
[VP_CODEC
];
1275 if (camif_mbus_formats
[i
] == mf
->code
)
1278 mf
->code
= camif_mbus_formats
[i
];
1280 if (pad
== CAMIF_SD_PAD_SINK
) {
1281 v4l_bound_align_image(&mf
->width
, 8, CAMIF_MAX_PIX_WIDTH
,
1282 ffs(pix_lim
->out_width_align
) - 1,
1283 &mf
->height
, 8, CAMIF_MAX_PIX_HEIGHT
, 0,
1286 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1287 v4l_bound_align_image(&mf
->width
, 8, crop
->width
,
1288 ffs(pix_lim
->out_width_align
) - 1,
1289 &mf
->height
, 8, crop
->height
,
1293 v4l2_dbg(1, debug
, &camif
->subdev
, "%ux%u\n", mf
->width
, mf
->height
);
1296 static int s3c_camif_subdev_set_fmt(struct v4l2_subdev
*sd
,
1297 struct v4l2_subdev_pad_config
*cfg
,
1298 struct v4l2_subdev_format
*fmt
)
1300 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1301 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1302 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1305 v4l2_dbg(1, debug
, sd
, "pad%d: code: 0x%x, %ux%u\n",
1306 fmt
->pad
, mf
->code
, mf
->width
, mf
->height
);
1308 mf
->field
= V4L2_FIELD_NONE
;
1309 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1310 mutex_lock(&camif
->lock
);
1313 * No pixel format change at the camera input is allowed
1316 if (vb2_is_busy(&camif
->vp
[VP_CODEC
].vb_queue
) ||
1317 vb2_is_busy(&camif
->vp
[VP_PREVIEW
].vb_queue
)) {
1318 mutex_unlock(&camif
->lock
);
1322 __camif_subdev_try_format(camif
, mf
, fmt
->pad
);
1324 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1325 mf
= v4l2_subdev_get_try_format(sd
, cfg
, fmt
->pad
);
1327 mutex_unlock(&camif
->lock
);
1332 case CAMIF_SD_PAD_SINK
:
1333 camif
->mbus_fmt
= *mf
;
1334 /* Reset sink crop rectangle. */
1335 crop
->width
= mf
->width
;
1336 crop
->height
= mf
->height
;
1340 * Reset source format (the camif's crop rectangle)
1341 * and the video output resolution.
1343 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1344 struct camif_frame
*frame
= &camif
->vp
[i
].out_frame
;
1345 frame
->rect
= *crop
;
1346 frame
->f_width
= mf
->width
;
1347 frame
->f_height
= mf
->height
;
1351 case CAMIF_SD_PAD_SOURCE_C
...CAMIF_SD_PAD_SOURCE_P
:
1352 /* Pixel format can be only changed on the sink pad. */
1353 mf
->code
= camif
->mbus_fmt
.code
;
1354 mf
->width
= crop
->width
;
1355 mf
->height
= crop
->height
;
1359 mutex_unlock(&camif
->lock
);
1363 static int s3c_camif_subdev_get_selection(struct v4l2_subdev
*sd
,
1364 struct v4l2_subdev_pad_config
*cfg
,
1365 struct v4l2_subdev_selection
*sel
)
1367 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1368 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1369 struct v4l2_mbus_framefmt
*mf
= &camif
->mbus_fmt
;
1371 if ((sel
->target
!= V4L2_SEL_TGT_CROP
&&
1372 sel
->target
!= V4L2_SEL_TGT_CROP_BOUNDS
) ||
1373 sel
->pad
!= CAMIF_SD_PAD_SINK
)
1376 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1377 sel
->r
= *v4l2_subdev_get_try_crop(sd
, cfg
, sel
->pad
);
1381 mutex_lock(&camif
->lock
);
1383 if (sel
->target
== V4L2_SEL_TGT_CROP
) {
1385 } else { /* crop bounds */
1386 sel
->r
.width
= mf
->width
;
1387 sel
->r
.height
= mf
->height
;
1392 mutex_unlock(&camif
->lock
);
1394 v4l2_dbg(1, debug
, sd
, "%s: crop: (%d,%d) %dx%d, size: %ux%u\n",
1395 __func__
, crop
->left
, crop
->top
, crop
->width
,
1396 crop
->height
, mf
->width
, mf
->height
);
1401 static void __camif_try_crop(struct camif_dev
*camif
, struct v4l2_rect
*r
)
1403 struct v4l2_mbus_framefmt
*mf
= &camif
->mbus_fmt
;
1404 const struct camif_pix_limits
*pix_lim
= &camif
->variant
->pix_limits
;
1405 unsigned int left
= 2 * r
->left
;
1406 unsigned int top
= 2 * r
->top
;
1409 * Following constraints must be met:
1410 * - r->width + 2 * r->left = mf->width;
1411 * - r->height + 2 * r->top = mf->height;
1412 * - crop rectangle size and position must be aligned
1413 * to 8 or 2 pixels, depending on SoC version.
1415 v4l_bound_align_image(&r
->width
, 0, mf
->width
,
1416 ffs(pix_lim
->win_hor_offset_align
) - 1,
1417 &r
->height
, 0, mf
->height
, 1, 0);
1419 v4l_bound_align_image(&left
, 0, mf
->width
- r
->width
,
1420 ffs(pix_lim
->win_hor_offset_align
),
1421 &top
, 0, mf
->height
- r
->height
, 2, 0);
1425 r
->width
= mf
->width
- left
;
1426 r
->height
= mf
->height
- top
;
1428 * Make sure we either downscale or upscale both the pixel
1429 * width and height. Just return current crop rectangle if
1430 * this scaler constraint is not met.
1432 if (camif
->variant
->ip_revision
== S3C244X_CAMIF_IP_REV
&&
1433 camif_is_streaming(camif
)) {
1436 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1437 struct v4l2_rect
*or = &camif
->vp
[i
].out_frame
.rect
;
1438 if ((or->width
> r
->width
) == (or->height
> r
->height
))
1440 *r
= camif
->camif_crop
;
1441 pr_debug("Width/height scaling direction limitation\n");
1446 v4l2_dbg(1, debug
, &camif
->v4l2_dev
, "crop: (%d,%d)/%dx%d, fmt: %ux%u\n",
1447 r
->left
, r
->top
, r
->width
, r
->height
, mf
->width
, mf
->height
);
1450 static int s3c_camif_subdev_set_selection(struct v4l2_subdev
*sd
,
1451 struct v4l2_subdev_pad_config
*cfg
,
1452 struct v4l2_subdev_selection
*sel
)
1454 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1455 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1456 struct camif_scaler scaler
;
1458 if (sel
->target
!= V4L2_SEL_TGT_CROP
|| sel
->pad
!= CAMIF_SD_PAD_SINK
)
1461 mutex_lock(&camif
->lock
);
1462 __camif_try_crop(camif
, &sel
->r
);
1464 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1465 *v4l2_subdev_get_try_crop(sd
, cfg
, sel
->pad
) = sel
->r
;
1467 unsigned long flags
;
1470 spin_lock_irqsave(&camif
->slock
, flags
);
1473 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1474 struct camif_vp
*vp
= &camif
->vp
[i
];
1475 scaler
= vp
->scaler
;
1476 if (s3c_camif_get_scaler_config(vp
, &scaler
))
1478 vp
->scaler
= scaler
;
1479 vp
->state
|= ST_VP_CONFIG
;
1482 spin_unlock_irqrestore(&camif
->slock
, flags
);
1484 mutex_unlock(&camif
->lock
);
1486 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %u, f_h: %u\n",
1487 __func__
, crop
->left
, crop
->top
, crop
->width
, crop
->height
,
1488 camif
->mbus_fmt
.width
, camif
->mbus_fmt
.height
);
1493 static const struct v4l2_subdev_pad_ops s3c_camif_subdev_pad_ops
= {
1494 .enum_mbus_code
= s3c_camif_subdev_enum_mbus_code
,
1495 .get_selection
= s3c_camif_subdev_get_selection
,
1496 .set_selection
= s3c_camif_subdev_set_selection
,
1497 .get_fmt
= s3c_camif_subdev_get_fmt
,
1498 .set_fmt
= s3c_camif_subdev_set_fmt
,
1501 static struct v4l2_subdev_ops s3c_camif_subdev_ops
= {
1502 .pad
= &s3c_camif_subdev_pad_ops
,
1505 static int s3c_camif_subdev_s_ctrl(struct v4l2_ctrl
*ctrl
)
1507 struct camif_dev
*camif
= container_of(ctrl
->handler
, struct camif_dev
,
1509 unsigned long flags
;
1511 spin_lock_irqsave(&camif
->slock
, flags
);
1514 case V4L2_CID_COLORFX
:
1515 camif
->colorfx
= camif
->ctrl_colorfx
->val
;
1517 switch (ctrl
->val
) {
1518 case V4L2_COLORFX_SEPIA
:
1519 camif
->colorfx_cb
= 115;
1520 camif
->colorfx_cr
= 145;
1522 case V4L2_COLORFX_SET_CBCR
:
1523 camif
->colorfx_cb
= camif
->ctrl_colorfx_cbcr
->val
>> 8;
1524 camif
->colorfx_cr
= camif
->ctrl_colorfx_cbcr
->val
& 0xff;
1527 /* for V4L2_COLORFX_BW and others */
1528 camif
->colorfx_cb
= 128;
1529 camif
->colorfx_cr
= 128;
1532 case V4L2_CID_TEST_PATTERN
:
1533 camif
->test_pattern
= camif
->ctrl_test_pattern
->val
;
1539 camif
->vp
[VP_CODEC
].state
|= ST_VP_CONFIG
;
1540 camif
->vp
[VP_PREVIEW
].state
|= ST_VP_CONFIG
;
1541 spin_unlock_irqrestore(&camif
->slock
, flags
);
1546 static const struct v4l2_ctrl_ops s3c_camif_subdev_ctrl_ops
= {
1547 .s_ctrl
= s3c_camif_subdev_s_ctrl
,
1550 static const char * const s3c_camif_test_pattern_menu
[] = {
1553 "Horizontal increment",
1554 "Vertical increment",
1557 int s3c_camif_create_subdev(struct camif_dev
*camif
)
1559 struct v4l2_ctrl_handler
*handler
= &camif
->ctrl_handler
;
1560 struct v4l2_subdev
*sd
= &camif
->subdev
;
1563 v4l2_subdev_init(sd
, &s3c_camif_subdev_ops
);
1564 sd
->flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1565 strlcpy(sd
->name
, "S3C-CAMIF", sizeof(sd
->name
));
1567 camif
->pads
[CAMIF_SD_PAD_SINK
].flags
= MEDIA_PAD_FL_SINK
;
1568 camif
->pads
[CAMIF_SD_PAD_SOURCE_C
].flags
= MEDIA_PAD_FL_SOURCE
;
1569 camif
->pads
[CAMIF_SD_PAD_SOURCE_P
].flags
= MEDIA_PAD_FL_SOURCE
;
1571 ret
= media_entity_init(&sd
->entity
, CAMIF_SD_PADS_NUM
,
1576 v4l2_ctrl_handler_init(handler
, 3);
1577 camif
->ctrl_test_pattern
= v4l2_ctrl_new_std_menu_items(handler
,
1578 &s3c_camif_subdev_ctrl_ops
, V4L2_CID_TEST_PATTERN
,
1579 ARRAY_SIZE(s3c_camif_test_pattern_menu
) - 1, 0, 0,
1580 s3c_camif_test_pattern_menu
);
1582 if (camif
->variant
->has_img_effect
) {
1583 camif
->ctrl_colorfx
= v4l2_ctrl_new_std_menu(handler
,
1584 &s3c_camif_subdev_ctrl_ops
,
1585 V4L2_CID_COLORFX
, V4L2_COLORFX_SET_CBCR
,
1586 ~0x981f, V4L2_COLORFX_NONE
);
1588 camif
->ctrl_colorfx_cbcr
= v4l2_ctrl_new_std(handler
,
1589 &s3c_camif_subdev_ctrl_ops
,
1590 V4L2_CID_COLORFX_CBCR
, 0, 0xffff, 1, 0);
1593 if (handler
->error
) {
1594 v4l2_ctrl_handler_free(handler
);
1595 media_entity_cleanup(&sd
->entity
);
1596 return handler
->error
;
1599 if (camif
->variant
->has_img_effect
)
1600 v4l2_ctrl_auto_cluster(2, &camif
->ctrl_colorfx
,
1601 V4L2_COLORFX_SET_CBCR
, false);
1603 sd
->ctrl_handler
= handler
;
1604 v4l2_set_subdevdata(sd
, camif
);
1609 void s3c_camif_unregister_subdev(struct camif_dev
*camif
)
1611 struct v4l2_subdev
*sd
= &camif
->subdev
;
1613 /* Return if not registered */
1614 if (v4l2_get_subdevdata(sd
) == NULL
)
1617 v4l2_device_unregister_subdev(sd
);
1618 media_entity_cleanup(&sd
->entity
);
1619 v4l2_ctrl_handler_free(&camif
->ctrl_handler
);
1620 v4l2_set_subdevdata(sd
, NULL
);
1623 int s3c_camif_set_defaults(struct camif_dev
*camif
)
1625 unsigned int ip_rev
= camif
->variant
->ip_revision
;
1628 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1629 struct camif_vp
*vp
= &camif
->vp
[i
];
1630 struct camif_frame
*f
= &vp
->out_frame
;
1634 vp
->offset
= camif
->variant
->vp_offset
;
1636 if (ip_rev
== S3C244X_CAMIF_IP_REV
)
1637 vp
->fmt_flags
= i
? FMT_FL_S3C24XX_PREVIEW
:
1638 FMT_FL_S3C24XX_CODEC
;
1640 vp
->fmt_flags
= FMT_FL_S3C64XX
;
1642 vp
->out_fmt
= s3c_camif_find_format(vp
, NULL
, 0);
1643 BUG_ON(vp
->out_fmt
== NULL
);
1645 memset(f
, 0, sizeof(*f
));
1646 f
->f_width
= CAMIF_DEF_WIDTH
;
1647 f
->f_height
= CAMIF_DEF_HEIGHT
;
1648 f
->rect
.width
= CAMIF_DEF_WIDTH
;
1649 f
->rect
.height
= CAMIF_DEF_HEIGHT
;
1651 /* Scaler is always enabled */
1652 vp
->scaler
.enable
= 1;
1654 vp
->payload
= (f
->f_width
* f
->f_height
*
1655 vp
->out_fmt
->depth
) / 8;
1658 memset(&camif
->mbus_fmt
, 0, sizeof(camif
->mbus_fmt
));
1659 camif
->mbus_fmt
.width
= CAMIF_DEF_WIDTH
;
1660 camif
->mbus_fmt
.height
= CAMIF_DEF_HEIGHT
;
1661 camif
->mbus_fmt
.code
= camif_mbus_formats
[0];
1663 memset(&camif
->camif_crop
, 0, sizeof(camif
->camif_crop
));
1664 camif
->camif_crop
.width
= CAMIF_DEF_WIDTH
;
1665 camif
->camif_crop
.height
= CAMIF_DEF_HEIGHT
;