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-core.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 (!on
== camif
->sensor
.power_count
)
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 (!on
== camif
->sensor
.stream_count
)
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
;
334 * Get previous DMA write buffer index:
335 * 0 => DMA buffer 0, 2;
336 * 1 => DMA buffer 1, 3.
338 index
= (CISTATUS_FRAMECNT(status
) + 2) & 1;
341 vbuf
= camif_active_queue_peek(vp
, index
);
343 if (!WARN_ON(vbuf
== NULL
)) {
344 /* Dequeue a filled buffer */
345 tv
= &vbuf
->vb
.v4l2_buf
.timestamp
;
346 tv
->tv_sec
= ts
.tv_sec
;
347 tv
->tv_usec
= ts
.tv_nsec
/ NSEC_PER_USEC
;
348 vbuf
->vb
.v4l2_buf
.sequence
= vp
->frame_sequence
++;
349 vb2_buffer_done(&vbuf
->vb
, VB2_BUF_STATE_DONE
);
351 /* Set up an empty buffer at the DMA engine */
352 vbuf
= camif_pending_queue_pop(vp
);
354 camif_hw_set_output_addr(vp
, &vbuf
->paddr
, index
);
355 camif_hw_set_output_addr(vp
, &vbuf
->paddr
, index
+ 2);
357 /* Scheduled in H/W, add to the queue */
358 camif_active_queue_add(vp
, vbuf
);
360 } else if (!(vp
->state
& ST_VP_ABORTING
) &&
361 (vp
->state
& ST_VP_PENDING
)) {
362 vp
->state
|= ST_VP_RUNNING
;
365 if (vp
->state
& ST_VP_CONFIG
) {
366 camif_prepare_dma_offset(vp
);
367 camif_hw_set_camera_crop(camif
);
368 camif_hw_set_scaler(vp
);
369 camif_hw_set_flip(vp
);
370 camif_hw_set_test_pattern(camif
, camif
->test_pattern
);
371 if (camif
->variant
->has_img_effect
)
372 camif_hw_set_effect(camif
, camif
->colorfx
,
373 camif
->colorfx_cb
, camif
->colorfx_cr
);
374 vp
->state
&= ~ST_VP_CONFIG
;
377 spin_unlock(&camif
->slock
);
381 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
383 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
384 struct camif_dev
*camif
= vp
->camif
;
389 * We assume the codec capture path is always activated
390 * first, before the preview path starts streaming.
391 * This is required to avoid internal FIFO overflow and
392 * a need for CAMIF software reset.
394 spin_lock_irqsave(&camif
->slock
, flags
);
396 if (camif
->stream_count
== 0) {
397 camif_hw_reset(camif
);
398 ret
= s3c_camif_hw_init(camif
, vp
);
400 ret
= s3c_camif_hw_vp_init(camif
, vp
);
402 spin_unlock_irqrestore(&camif
->slock
, flags
);
405 camif_reinitialize(vp
);
409 spin_lock_irqsave(&camif
->slock
, flags
);
410 vp
->frame_sequence
= 0;
411 vp
->state
|= ST_VP_PENDING
;
413 if (!list_empty(&vp
->pending_buf_q
) &&
414 (!(vp
->state
& ST_VP_STREAMING
) ||
415 !(vp
->state
& ST_VP_SENSOR_STREAMING
))) {
417 camif_hw_enable_scaler(vp
, vp
->scaler
.enable
);
418 camif_hw_enable_capture(vp
);
419 vp
->state
|= ST_VP_STREAMING
;
421 if (!(vp
->state
& ST_VP_SENSOR_STREAMING
)) {
422 vp
->state
|= ST_VP_SENSOR_STREAMING
;
423 spin_unlock_irqrestore(&camif
->slock
, flags
);
424 ret
= sensor_set_streaming(camif
, 1);
426 v4l2_err(&vp
->vdev
, "Sensor s_stream failed\n");
428 camif_hw_dump_regs(camif
, __func__
);
434 spin_unlock_irqrestore(&camif
->slock
, flags
);
438 static void stop_streaming(struct vb2_queue
*vq
)
440 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
441 camif_stop_capture(vp
);
444 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*pfmt
,
445 unsigned int *num_buffers
, unsigned int *num_planes
,
446 unsigned int sizes
[], void *allocators
[])
448 const struct v4l2_pix_format
*pix
= NULL
;
449 struct camif_vp
*vp
= vb2_get_drv_priv(vq
);
450 struct camif_dev
*camif
= vp
->camif
;
451 struct camif_frame
*frame
= &vp
->out_frame
;
452 const struct camif_fmt
*fmt
= vp
->out_fmt
;
456 pix
= &pfmt
->fmt
.pix
;
457 fmt
= s3c_camif_find_format(vp
, &pix
->pixelformat
, -1);
458 size
= (pix
->width
* pix
->height
* fmt
->depth
) / 8;
460 size
= (frame
->f_width
* frame
->f_height
* fmt
->depth
) / 8;
468 sizes
[0] = max(size
, pix
->sizeimage
);
471 allocators
[0] = camif
->alloc_ctx
;
473 pr_debug("size: %u\n", sizes
[0]);
477 static int buffer_prepare(struct vb2_buffer
*vb
)
479 struct camif_vp
*vp
= vb2_get_drv_priv(vb
->vb2_queue
);
481 if (vp
->out_fmt
== NULL
)
484 if (vb2_plane_size(vb
, 0) < vp
->payload
) {
485 v4l2_err(&vp
->vdev
, "buffer too small: %lu, required: %u\n",
486 vb2_plane_size(vb
, 0), vp
->payload
);
489 vb2_set_plane_payload(vb
, 0, vp
->payload
);
494 static void buffer_queue(struct vb2_buffer
*vb
)
496 struct camif_buffer
*buf
= container_of(vb
, struct camif_buffer
, vb
);
497 struct camif_vp
*vp
= vb2_get_drv_priv(vb
->vb2_queue
);
498 struct camif_dev
*camif
= vp
->camif
;
501 spin_lock_irqsave(&camif
->slock
, flags
);
502 WARN_ON(camif_prepare_addr(vp
, &buf
->vb
, &buf
->paddr
));
504 if (!(vp
->state
& ST_VP_STREAMING
) && vp
->active_buffers
< 2) {
505 /* Schedule an empty buffer in H/W */
506 buf
->index
= vp
->buf_index
;
508 camif_hw_set_output_addr(vp
, &buf
->paddr
, buf
->index
);
509 camif_hw_set_output_addr(vp
, &buf
->paddr
, buf
->index
+ 2);
511 camif_active_queue_add(vp
, buf
);
512 vp
->buf_index
= !vp
->buf_index
;
514 camif_pending_queue_add(vp
, buf
);
517 if (vb2_is_streaming(&vp
->vb_queue
) && !list_empty(&vp
->pending_buf_q
)
518 && !(vp
->state
& ST_VP_STREAMING
)) {
520 vp
->state
|= ST_VP_STREAMING
;
521 camif_hw_enable_scaler(vp
, vp
->scaler
.enable
);
522 camif_hw_enable_capture(vp
);
523 spin_unlock_irqrestore(&camif
->slock
, flags
);
525 if (!(vp
->state
& ST_VP_SENSOR_STREAMING
)) {
526 if (sensor_set_streaming(camif
, 1) == 0)
527 vp
->state
|= ST_VP_SENSOR_STREAMING
;
529 v4l2_err(&vp
->vdev
, "Sensor s_stream failed\n");
532 camif_hw_dump_regs(camif
, __func__
);
536 spin_unlock_irqrestore(&camif
->slock
, flags
);
539 static const struct vb2_ops s3c_camif_qops
= {
540 .queue_setup
= queue_setup
,
541 .buf_prepare
= buffer_prepare
,
542 .buf_queue
= buffer_queue
,
543 .wait_prepare
= vb2_ops_wait_prepare
,
544 .wait_finish
= vb2_ops_wait_finish
,
545 .start_streaming
= start_streaming
,
546 .stop_streaming
= stop_streaming
,
549 static int s3c_camif_open(struct file
*file
)
551 struct camif_vp
*vp
= video_drvdata(file
);
552 struct camif_dev
*camif
= vp
->camif
;
555 pr_debug("[vp%d] state: %#x, owner: %p, pid: %d\n", vp
->id
,
556 vp
->state
, vp
->owner
, task_pid_nr(current
));
558 if (mutex_lock_interruptible(&camif
->lock
))
561 ret
= v4l2_fh_open(file
);
565 ret
= pm_runtime_get_sync(camif
->dev
);
569 ret
= sensor_set_power(camif
, 1);
573 pm_runtime_put(camif
->dev
);
575 v4l2_fh_release(file
);
577 mutex_unlock(&camif
->lock
);
581 static int s3c_camif_close(struct file
*file
)
583 struct camif_vp
*vp
= video_drvdata(file
);
584 struct camif_dev
*camif
= vp
->camif
;
587 pr_debug("[vp%d] state: %#x, owner: %p, pid: %d\n", vp
->id
,
588 vp
->state
, vp
->owner
, task_pid_nr(current
));
590 mutex_lock(&camif
->lock
);
592 if (vp
->owner
== file
->private_data
) {
593 camif_stop_capture(vp
);
594 vb2_queue_release(&vp
->vb_queue
);
598 sensor_set_power(camif
, 0);
600 pm_runtime_put(camif
->dev
);
601 ret
= v4l2_fh_release(file
);
603 mutex_unlock(&camif
->lock
);
607 static unsigned int s3c_camif_poll(struct file
*file
,
608 struct poll_table_struct
*wait
)
610 struct camif_vp
*vp
= video_drvdata(file
);
611 struct camif_dev
*camif
= vp
->camif
;
614 mutex_lock(&camif
->lock
);
615 if (vp
->owner
&& vp
->owner
!= file
->private_data
)
618 ret
= vb2_poll(&vp
->vb_queue
, file
, wait
);
620 mutex_unlock(&camif
->lock
);
624 static int s3c_camif_mmap(struct file
*file
, struct vm_area_struct
*vma
)
626 struct camif_vp
*vp
= video_drvdata(file
);
629 if (vp
->owner
&& vp
->owner
!= file
->private_data
)
632 ret
= vb2_mmap(&vp
->vb_queue
, vma
);
637 static const struct v4l2_file_operations s3c_camif_fops
= {
638 .owner
= THIS_MODULE
,
639 .open
= s3c_camif_open
,
640 .release
= s3c_camif_close
,
641 .poll
= s3c_camif_poll
,
642 .unlocked_ioctl
= video_ioctl2
,
643 .mmap
= s3c_camif_mmap
,
650 static int s3c_camif_vidioc_querycap(struct file
*file
, void *priv
,
651 struct v4l2_capability
*cap
)
653 struct camif_vp
*vp
= video_drvdata(file
);
655 strlcpy(cap
->driver
, S3C_CAMIF_DRIVER_NAME
, sizeof(cap
->driver
));
656 strlcpy(cap
->card
, S3C_CAMIF_DRIVER_NAME
, sizeof(cap
->card
));
657 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "platform:%s.%d",
658 dev_name(vp
->camif
->dev
), vp
->id
);
660 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_CAPTURE
;
661 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
666 static int s3c_camif_vidioc_enum_input(struct file
*file
, void *priv
,
667 struct v4l2_input
*input
)
669 struct camif_vp
*vp
= video_drvdata(file
);
670 struct v4l2_subdev
*sensor
= vp
->camif
->sensor
.sd
;
672 if (input
->index
|| sensor
== NULL
)
675 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
676 strlcpy(input
->name
, sensor
->name
, sizeof(input
->name
));
680 static int s3c_camif_vidioc_s_input(struct file
*file
, void *priv
,
683 return i
== 0 ? 0 : -EINVAL
;
686 static int s3c_camif_vidioc_g_input(struct file
*file
, void *priv
,
693 static int s3c_camif_vidioc_enum_fmt(struct file
*file
, void *priv
,
694 struct v4l2_fmtdesc
*f
)
696 struct camif_vp
*vp
= video_drvdata(file
);
697 const struct camif_fmt
*fmt
;
699 fmt
= s3c_camif_find_format(vp
, NULL
, f
->index
);
703 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
704 f
->pixelformat
= fmt
->fourcc
;
706 pr_debug("fmt(%d): %s\n", f
->index
, f
->description
);
710 static int s3c_camif_vidioc_g_fmt(struct file
*file
, void *priv
,
711 struct v4l2_format
*f
)
713 struct camif_vp
*vp
= video_drvdata(file
);
714 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
715 struct camif_frame
*frame
= &vp
->out_frame
;
716 const struct camif_fmt
*fmt
= vp
->out_fmt
;
718 pix
->bytesperline
= frame
->f_width
* fmt
->ybpp
;
719 pix
->sizeimage
= vp
->payload
;
721 pix
->pixelformat
= fmt
->fourcc
;
722 pix
->width
= frame
->f_width
;
723 pix
->height
= frame
->f_height
;
724 pix
->field
= V4L2_FIELD_NONE
;
725 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
730 static int __camif_video_try_format(struct camif_vp
*vp
,
731 struct v4l2_pix_format
*pix
,
732 const struct camif_fmt
**ffmt
)
734 struct camif_dev
*camif
= vp
->camif
;
735 struct v4l2_rect
*crop
= &camif
->camif_crop
;
736 unsigned int wmin
, hmin
, sc_hrmax
, sc_vrmax
;
737 const struct vp_pix_limits
*pix_lim
;
738 const struct camif_fmt
*fmt
;
740 fmt
= s3c_camif_find_format(vp
, &pix
->pixelformat
, 0);
742 if (WARN_ON(fmt
== NULL
))
748 pix_lim
= &camif
->variant
->vp_pix_limits
[vp
->id
];
750 pr_debug("fmt: %ux%u, crop: %ux%u, bytesperline: %u\n",
751 pix
->width
, pix
->height
, crop
->width
, crop
->height
,
754 * Calculate minimum width and height according to the configured
755 * camera input interface crop rectangle and the resizer's capabilities.
757 sc_hrmax
= min(SCALER_MAX_RATIO
, 1 << (ffs(crop
->width
) - 3));
758 sc_vrmax
= min(SCALER_MAX_RATIO
, 1 << (ffs(crop
->height
) - 1));
760 wmin
= max_t(u32
, pix_lim
->min_out_width
, crop
->width
/ sc_hrmax
);
761 wmin
= round_up(wmin
, pix_lim
->out_width_align
);
762 hmin
= max_t(u32
, 8, crop
->height
/ sc_vrmax
);
763 hmin
= round_up(hmin
, 8);
765 v4l_bound_align_image(&pix
->width
, wmin
, pix_lim
->max_sc_out_width
,
766 ffs(pix_lim
->out_width_align
) - 1,
767 &pix
->height
, hmin
, pix_lim
->max_height
, 0, 0);
769 pix
->bytesperline
= pix
->width
* fmt
->ybpp
;
770 pix
->sizeimage
= (pix
->width
* pix
->height
* fmt
->depth
) / 8;
771 pix
->pixelformat
= fmt
->fourcc
;
772 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
773 pix
->field
= V4L2_FIELD_NONE
;
775 pr_debug("%ux%u, wmin: %d, hmin: %d, sc_hrmax: %d, sc_vrmax: %d\n",
776 pix
->width
, pix
->height
, wmin
, hmin
, sc_hrmax
, sc_vrmax
);
781 static int s3c_camif_vidioc_try_fmt(struct file
*file
, void *priv
,
782 struct v4l2_format
*f
)
784 struct camif_vp
*vp
= video_drvdata(file
);
785 return __camif_video_try_format(vp
, &f
->fmt
.pix
, NULL
);
788 static int s3c_camif_vidioc_s_fmt(struct file
*file
, void *priv
,
789 struct v4l2_format
*f
)
791 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
792 struct camif_vp
*vp
= video_drvdata(file
);
793 struct camif_frame
*out_frame
= &vp
->out_frame
;
794 const struct camif_fmt
*fmt
= NULL
;
797 pr_debug("[vp%d]\n", vp
->id
);
799 if (vb2_is_busy(&vp
->vb_queue
))
802 ret
= __camif_video_try_format(vp
, &f
->fmt
.pix
, &fmt
);
807 vp
->payload
= pix
->sizeimage
;
808 out_frame
->f_width
= pix
->width
;
809 out_frame
->f_height
= pix
->height
;
811 /* Reset composition rectangle */
812 out_frame
->rect
.width
= pix
->width
;
813 out_frame
->rect
.height
= pix
->height
;
814 out_frame
->rect
.left
= 0;
815 out_frame
->rect
.top
= 0;
817 if (vp
->owner
== NULL
)
820 pr_debug("%ux%u. payload: %u. fmt: %s. %d %d. sizeimage: %d. bpl: %d\n",
821 out_frame
->f_width
, out_frame
->f_height
, vp
->payload
, fmt
->name
,
822 pix
->width
* pix
->height
* fmt
->depth
, fmt
->depth
,
823 pix
->sizeimage
, pix
->bytesperline
);
828 /* Only check pixel formats at the sensor and the camif subdev pads */
829 static int camif_pipeline_validate(struct camif_dev
*camif
)
831 struct v4l2_subdev_format src_fmt
;
832 struct media_pad
*pad
;
835 /* Retrieve format at the sensor subdev source pad */
836 pad
= media_entity_remote_pad(&camif
->pads
[0]);
837 if (!pad
|| media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
840 src_fmt
.pad
= pad
->index
;
841 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
842 ret
= v4l2_subdev_call(camif
->sensor
.sd
, pad
, get_fmt
, NULL
, &src_fmt
);
843 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
846 if (src_fmt
.format
.width
!= camif
->mbus_fmt
.width
||
847 src_fmt
.format
.height
!= camif
->mbus_fmt
.height
||
848 src_fmt
.format
.code
!= camif
->mbus_fmt
.code
)
854 static int s3c_camif_streamon(struct file
*file
, void *priv
,
855 enum v4l2_buf_type type
)
857 struct camif_vp
*vp
= video_drvdata(file
);
858 struct camif_dev
*camif
= vp
->camif
;
859 struct media_entity
*sensor
= &camif
->sensor
.sd
->entity
;
862 pr_debug("[vp%d]\n", vp
->id
);
864 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
867 if (vp
->owner
&& vp
->owner
!= priv
)
870 if (s3c_vp_active(vp
))
873 ret
= media_entity_pipeline_start(sensor
, camif
->m_pipeline
);
877 ret
= camif_pipeline_validate(camif
);
879 media_entity_pipeline_stop(sensor
);
883 return vb2_streamon(&vp
->vb_queue
, type
);
886 static int s3c_camif_streamoff(struct file
*file
, void *priv
,
887 enum v4l2_buf_type type
)
889 struct camif_vp
*vp
= video_drvdata(file
);
890 struct camif_dev
*camif
= vp
->camif
;
893 pr_debug("[vp%d]\n", vp
->id
);
895 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
898 if (vp
->owner
&& vp
->owner
!= priv
)
901 ret
= vb2_streamoff(&vp
->vb_queue
, type
);
903 media_entity_pipeline_stop(&camif
->sensor
.sd
->entity
);
907 static int s3c_camif_reqbufs(struct file
*file
, void *priv
,
908 struct v4l2_requestbuffers
*rb
)
910 struct camif_vp
*vp
= video_drvdata(file
);
913 pr_debug("[vp%d] rb count: %d, owner: %p, priv: %p\n",
914 vp
->id
, rb
->count
, vp
->owner
, priv
);
916 if (vp
->owner
&& vp
->owner
!= priv
)
920 rb
->count
= max_t(u32
, CAMIF_REQ_BUFS_MIN
, rb
->count
);
924 ret
= vb2_reqbufs(&vp
->vb_queue
, rb
);
928 if (rb
->count
&& rb
->count
< CAMIF_REQ_BUFS_MIN
) {
930 vb2_reqbufs(&vp
->vb_queue
, rb
);
934 vp
->reqbufs_count
= rb
->count
;
935 if (vp
->owner
== NULL
&& rb
->count
> 0)
941 static int s3c_camif_querybuf(struct file
*file
, void *priv
,
942 struct v4l2_buffer
*buf
)
944 struct camif_vp
*vp
= video_drvdata(file
);
945 return vb2_querybuf(&vp
->vb_queue
, buf
);
948 static int s3c_camif_qbuf(struct file
*file
, void *priv
,
949 struct v4l2_buffer
*buf
)
951 struct camif_vp
*vp
= video_drvdata(file
);
953 pr_debug("[vp%d]\n", vp
->id
);
955 if (vp
->owner
&& vp
->owner
!= priv
)
958 return vb2_qbuf(&vp
->vb_queue
, buf
);
961 static int s3c_camif_dqbuf(struct file
*file
, void *priv
,
962 struct v4l2_buffer
*buf
)
964 struct camif_vp
*vp
= video_drvdata(file
);
966 pr_debug("[vp%d] sequence: %d\n", vp
->id
, vp
->frame_sequence
);
968 if (vp
->owner
&& vp
->owner
!= priv
)
971 return vb2_dqbuf(&vp
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
974 static int s3c_camif_create_bufs(struct file
*file
, void *priv
,
975 struct v4l2_create_buffers
*create
)
977 struct camif_vp
*vp
= video_drvdata(file
);
980 if (vp
->owner
&& vp
->owner
!= priv
)
983 create
->count
= max_t(u32
, 1, create
->count
);
984 ret
= vb2_create_bufs(&vp
->vb_queue
, create
);
986 if (!ret
&& vp
->owner
== NULL
)
992 static int s3c_camif_prepare_buf(struct file
*file
, void *priv
,
993 struct v4l2_buffer
*b
)
995 struct camif_vp
*vp
= video_drvdata(file
);
996 return vb2_prepare_buf(&vp
->vb_queue
, b
);
999 static int s3c_camif_g_selection(struct file
*file
, void *priv
,
1000 struct v4l2_selection
*sel
)
1002 struct camif_vp
*vp
= video_drvdata(file
);
1004 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1007 switch (sel
->target
) {
1008 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
1009 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
1012 sel
->r
.width
= vp
->out_frame
.f_width
;
1013 sel
->r
.height
= vp
->out_frame
.f_height
;
1016 case V4L2_SEL_TGT_COMPOSE
:
1017 sel
->r
= vp
->out_frame
.rect
;
1024 static void __camif_try_compose(struct camif_dev
*camif
, struct camif_vp
*vp
,
1025 struct v4l2_rect
*r
)
1027 /* s3c244x doesn't support composition */
1028 if (camif
->variant
->ip_revision
== S3C244X_CAMIF_IP_REV
) {
1029 *r
= vp
->out_frame
.rect
;
1036 static int s3c_camif_s_selection(struct file
*file
, void *priv
,
1037 struct v4l2_selection
*sel
)
1039 struct camif_vp
*vp
= video_drvdata(file
);
1040 struct camif_dev
*camif
= vp
->camif
;
1041 struct v4l2_rect rect
= sel
->r
;
1042 unsigned long flags
;
1044 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1045 sel
->target
!= V4L2_SEL_TGT_COMPOSE
)
1048 __camif_try_compose(camif
, vp
, &rect
);
1051 spin_lock_irqsave(&camif
->slock
, flags
);
1052 vp
->out_frame
.rect
= rect
;
1053 vp
->state
|= ST_VP_CONFIG
;
1054 spin_unlock_irqrestore(&camif
->slock
, flags
);
1056 pr_debug("type: %#x, target: %#x, flags: %#x, (%d,%d)/%dx%d\n",
1057 sel
->type
, sel
->target
, sel
->flags
,
1058 sel
->r
.left
, sel
->r
.top
, sel
->r
.width
, sel
->r
.height
);
1063 static const struct v4l2_ioctl_ops s3c_camif_ioctl_ops
= {
1064 .vidioc_querycap
= s3c_camif_vidioc_querycap
,
1065 .vidioc_enum_input
= s3c_camif_vidioc_enum_input
,
1066 .vidioc_g_input
= s3c_camif_vidioc_g_input
,
1067 .vidioc_s_input
= s3c_camif_vidioc_s_input
,
1068 .vidioc_enum_fmt_vid_cap
= s3c_camif_vidioc_enum_fmt
,
1069 .vidioc_try_fmt_vid_cap
= s3c_camif_vidioc_try_fmt
,
1070 .vidioc_s_fmt_vid_cap
= s3c_camif_vidioc_s_fmt
,
1071 .vidioc_g_fmt_vid_cap
= s3c_camif_vidioc_g_fmt
,
1072 .vidioc_g_selection
= s3c_camif_g_selection
,
1073 .vidioc_s_selection
= s3c_camif_s_selection
,
1074 .vidioc_reqbufs
= s3c_camif_reqbufs
,
1075 .vidioc_querybuf
= s3c_camif_querybuf
,
1076 .vidioc_prepare_buf
= s3c_camif_prepare_buf
,
1077 .vidioc_create_bufs
= s3c_camif_create_bufs
,
1078 .vidioc_qbuf
= s3c_camif_qbuf
,
1079 .vidioc_dqbuf
= s3c_camif_dqbuf
,
1080 .vidioc_streamon
= s3c_camif_streamon
,
1081 .vidioc_streamoff
= s3c_camif_streamoff
,
1082 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1083 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1084 .vidioc_log_status
= v4l2_ctrl_log_status
,
1088 * Video node controls
1090 static int s3c_camif_video_s_ctrl(struct v4l2_ctrl
*ctrl
)
1092 struct camif_vp
*vp
= ctrl
->priv
;
1093 struct camif_dev
*camif
= vp
->camif
;
1094 unsigned long flags
;
1096 pr_debug("[vp%d] ctrl: %s, value: %d\n", vp
->id
,
1097 ctrl
->name
, ctrl
->val
);
1099 spin_lock_irqsave(&camif
->slock
, flags
);
1102 case V4L2_CID_HFLIP
:
1103 vp
->hflip
= ctrl
->val
;
1106 case V4L2_CID_VFLIP
:
1107 vp
->vflip
= ctrl
->val
;
1111 vp
->state
|= ST_VP_CONFIG
;
1112 spin_unlock_irqrestore(&camif
->slock
, flags
);
1116 /* Codec and preview video node control ops */
1117 static const struct v4l2_ctrl_ops s3c_camif_video_ctrl_ops
= {
1118 .s_ctrl
= s3c_camif_video_s_ctrl
,
1121 int s3c_camif_register_video_node(struct camif_dev
*camif
, int idx
)
1123 struct camif_vp
*vp
= &camif
->vp
[idx
];
1124 struct vb2_queue
*q
= &vp
->vb_queue
;
1125 struct video_device
*vfd
= &vp
->vdev
;
1126 struct v4l2_ctrl
*ctrl
;
1129 memset(vfd
, 0, sizeof(*vfd
));
1130 snprintf(vfd
->name
, sizeof(vfd
->name
), "camif-%s",
1131 vp
->id
== 0 ? "codec" : "preview");
1133 vfd
->fops
= &s3c_camif_fops
;
1134 vfd
->ioctl_ops
= &s3c_camif_ioctl_ops
;
1135 vfd
->v4l2_dev
= &camif
->v4l2_dev
;
1137 vfd
->release
= video_device_release_empty
;
1138 vfd
->lock
= &camif
->lock
;
1139 vp
->reqbufs_count
= 0;
1141 INIT_LIST_HEAD(&vp
->pending_buf_q
);
1142 INIT_LIST_HEAD(&vp
->active_buf_q
);
1144 memset(q
, 0, sizeof(*q
));
1145 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1146 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1147 q
->ops
= &s3c_camif_qops
;
1148 q
->mem_ops
= &vb2_dma_contig_memops
;
1149 q
->buf_struct_size
= sizeof(struct camif_buffer
);
1151 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1152 q
->lock
= &vp
->camif
->lock
;
1154 ret
= vb2_queue_init(q
);
1158 vp
->pad
.flags
= MEDIA_PAD_FL_SINK
;
1159 ret
= media_entity_init(&vfd
->entity
, 1, &vp
->pad
, 0);
1163 video_set_drvdata(vfd
, vp
);
1165 v4l2_ctrl_handler_init(&vp
->ctrl_handler
, 1);
1166 ctrl
= v4l2_ctrl_new_std(&vp
->ctrl_handler
, &s3c_camif_video_ctrl_ops
,
1167 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1170 ctrl
= v4l2_ctrl_new_std(&vp
->ctrl_handler
, &s3c_camif_video_ctrl_ops
,
1171 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1175 ret
= vp
->ctrl_handler
.error
;
1177 goto err_me_cleanup
;
1179 vfd
->ctrl_handler
= &vp
->ctrl_handler
;
1181 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, -1);
1183 goto err_ctrlh_free
;
1185 v4l2_info(&camif
->v4l2_dev
, "registered %s as /dev/%s\n",
1186 vfd
->name
, video_device_node_name(vfd
));
1190 v4l2_ctrl_handler_free(&vp
->ctrl_handler
);
1192 media_entity_cleanup(&vfd
->entity
);
1194 video_device_release(vfd
);
1198 void s3c_camif_unregister_video_node(struct camif_dev
*camif
, int idx
)
1200 struct video_device
*vfd
= &camif
->vp
[idx
].vdev
;
1202 if (video_is_registered(vfd
)) {
1203 video_unregister_device(vfd
);
1204 media_entity_cleanup(&vfd
->entity
);
1205 v4l2_ctrl_handler_free(vfd
->ctrl_handler
);
1209 /* Media bus pixel formats supported at the camif input */
1210 static const u32 camif_mbus_formats
[] = {
1211 MEDIA_BUS_FMT_YUYV8_2X8
,
1212 MEDIA_BUS_FMT_YVYU8_2X8
,
1213 MEDIA_BUS_FMT_UYVY8_2X8
,
1214 MEDIA_BUS_FMT_VYUY8_2X8
,
1218 * Camera input interface subdev operations
1221 static int s3c_camif_subdev_enum_mbus_code(struct v4l2_subdev
*sd
,
1222 struct v4l2_subdev_fh
*fh
,
1223 struct v4l2_subdev_mbus_code_enum
*code
)
1225 if (code
->index
>= ARRAY_SIZE(camif_mbus_formats
))
1228 code
->code
= camif_mbus_formats
[code
->index
];
1232 static int s3c_camif_subdev_get_fmt(struct v4l2_subdev
*sd
,
1233 struct v4l2_subdev_fh
*fh
,
1234 struct v4l2_subdev_format
*fmt
)
1236 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1237 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1239 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1240 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1245 mutex_lock(&camif
->lock
);
1248 case CAMIF_SD_PAD_SINK
:
1249 /* full camera input pixel size */
1250 *mf
= camif
->mbus_fmt
;
1253 case CAMIF_SD_PAD_SOURCE_C
...CAMIF_SD_PAD_SOURCE_P
:
1254 /* crop rectangle at camera interface input */
1255 mf
->width
= camif
->camif_crop
.width
;
1256 mf
->height
= camif
->camif_crop
.height
;
1257 mf
->code
= camif
->mbus_fmt
.code
;
1261 mutex_unlock(&camif
->lock
);
1262 mf
->field
= V4L2_FIELD_NONE
;
1263 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1267 static void __camif_subdev_try_format(struct camif_dev
*camif
,
1268 struct v4l2_mbus_framefmt
*mf
, int pad
)
1270 const struct s3c_camif_variant
*variant
= camif
->variant
;
1271 const struct vp_pix_limits
*pix_lim
;
1272 int i
= ARRAY_SIZE(camif_mbus_formats
);
1274 /* FIXME: constraints against codec or preview path ? */
1275 pix_lim
= &variant
->vp_pix_limits
[VP_CODEC
];
1278 if (camif_mbus_formats
[i
] == mf
->code
)
1281 mf
->code
= camif_mbus_formats
[i
];
1283 if (pad
== CAMIF_SD_PAD_SINK
) {
1284 v4l_bound_align_image(&mf
->width
, 8, CAMIF_MAX_PIX_WIDTH
,
1285 ffs(pix_lim
->out_width_align
) - 1,
1286 &mf
->height
, 8, CAMIF_MAX_PIX_HEIGHT
, 0,
1289 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1290 v4l_bound_align_image(&mf
->width
, 8, crop
->width
,
1291 ffs(pix_lim
->out_width_align
) - 1,
1292 &mf
->height
, 8, crop
->height
,
1296 v4l2_dbg(1, debug
, &camif
->subdev
, "%ux%u\n", mf
->width
, mf
->height
);
1299 static int s3c_camif_subdev_set_fmt(struct v4l2_subdev
*sd
,
1300 struct v4l2_subdev_fh
*fh
,
1301 struct v4l2_subdev_format
*fmt
)
1303 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1304 struct v4l2_mbus_framefmt
*mf
= &fmt
->format
;
1305 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1308 v4l2_dbg(1, debug
, sd
, "pad%d: code: 0x%x, %ux%u\n",
1309 fmt
->pad
, mf
->code
, mf
->width
, mf
->height
);
1311 mf
->field
= V4L2_FIELD_NONE
;
1312 mf
->colorspace
= V4L2_COLORSPACE_JPEG
;
1313 mutex_lock(&camif
->lock
);
1316 * No pixel format change at the camera input is allowed
1319 if (vb2_is_busy(&camif
->vp
[VP_CODEC
].vb_queue
) ||
1320 vb2_is_busy(&camif
->vp
[VP_PREVIEW
].vb_queue
)) {
1321 mutex_unlock(&camif
->lock
);
1325 __camif_subdev_try_format(camif
, mf
, fmt
->pad
);
1327 if (fmt
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1328 mf
= v4l2_subdev_get_try_format(fh
, fmt
->pad
);
1330 mutex_unlock(&camif
->lock
);
1335 case CAMIF_SD_PAD_SINK
:
1336 camif
->mbus_fmt
= *mf
;
1337 /* Reset sink crop rectangle. */
1338 crop
->width
= mf
->width
;
1339 crop
->height
= mf
->height
;
1343 * Reset source format (the camif's crop rectangle)
1344 * and the video output resolution.
1346 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1347 struct camif_frame
*frame
= &camif
->vp
[i
].out_frame
;
1348 frame
->rect
= *crop
;
1349 frame
->f_width
= mf
->width
;
1350 frame
->f_height
= mf
->height
;
1354 case CAMIF_SD_PAD_SOURCE_C
...CAMIF_SD_PAD_SOURCE_P
:
1355 /* Pixel format can be only changed on the sink pad. */
1356 mf
->code
= camif
->mbus_fmt
.code
;
1357 mf
->width
= crop
->width
;
1358 mf
->height
= crop
->height
;
1362 mutex_unlock(&camif
->lock
);
1366 static int s3c_camif_subdev_get_selection(struct v4l2_subdev
*sd
,
1367 struct v4l2_subdev_fh
*fh
,
1368 struct v4l2_subdev_selection
*sel
)
1370 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1371 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1372 struct v4l2_mbus_framefmt
*mf
= &camif
->mbus_fmt
;
1374 if ((sel
->target
!= V4L2_SEL_TGT_CROP
&&
1375 sel
->target
!= V4L2_SEL_TGT_CROP_BOUNDS
) ||
1376 sel
->pad
!= CAMIF_SD_PAD_SINK
)
1379 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1380 sel
->r
= *v4l2_subdev_get_try_crop(fh
, sel
->pad
);
1384 mutex_lock(&camif
->lock
);
1386 if (sel
->target
== V4L2_SEL_TGT_CROP
) {
1388 } else { /* crop bounds */
1389 sel
->r
.width
= mf
->width
;
1390 sel
->r
.height
= mf
->height
;
1395 mutex_unlock(&camif
->lock
);
1397 v4l2_dbg(1, debug
, sd
, "%s: crop: (%d,%d) %dx%d, size: %ux%u\n",
1398 __func__
, crop
->left
, crop
->top
, crop
->width
,
1399 crop
->height
, mf
->width
, mf
->height
);
1404 static void __camif_try_crop(struct camif_dev
*camif
, struct v4l2_rect
*r
)
1406 struct v4l2_mbus_framefmt
*mf
= &camif
->mbus_fmt
;
1407 const struct camif_pix_limits
*pix_lim
= &camif
->variant
->pix_limits
;
1408 unsigned int left
= 2 * r
->left
;
1409 unsigned int top
= 2 * r
->top
;
1412 * Following constraints must be met:
1413 * - r->width + 2 * r->left = mf->width;
1414 * - r->height + 2 * r->top = mf->height;
1415 * - crop rectangle size and position must be aligned
1416 * to 8 or 2 pixels, depending on SoC version.
1418 v4l_bound_align_image(&r
->width
, 0, mf
->width
,
1419 ffs(pix_lim
->win_hor_offset_align
) - 1,
1420 &r
->height
, 0, mf
->height
, 1, 0);
1422 v4l_bound_align_image(&left
, 0, mf
->width
- r
->width
,
1423 ffs(pix_lim
->win_hor_offset_align
),
1424 &top
, 0, mf
->height
- r
->height
, 2, 0);
1428 r
->width
= mf
->width
- left
;
1429 r
->height
= mf
->height
- top
;
1431 * Make sure we either downscale or upscale both the pixel
1432 * width and height. Just return current crop rectangle if
1433 * this scaler constraint is not met.
1435 if (camif
->variant
->ip_revision
== S3C244X_CAMIF_IP_REV
&&
1436 camif_is_streaming(camif
)) {
1439 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1440 struct v4l2_rect
*or = &camif
->vp
[i
].out_frame
.rect
;
1441 if ((or->width
> r
->width
) == (or->height
> r
->height
))
1443 *r
= camif
->camif_crop
;
1444 pr_debug("Width/height scaling direction limitation\n");
1449 v4l2_dbg(1, debug
, &camif
->v4l2_dev
, "crop: (%d,%d)/%dx%d, fmt: %ux%u\n",
1450 r
->left
, r
->top
, r
->width
, r
->height
, mf
->width
, mf
->height
);
1453 static int s3c_camif_subdev_set_selection(struct v4l2_subdev
*sd
,
1454 struct v4l2_subdev_fh
*fh
,
1455 struct v4l2_subdev_selection
*sel
)
1457 struct camif_dev
*camif
= v4l2_get_subdevdata(sd
);
1458 struct v4l2_rect
*crop
= &camif
->camif_crop
;
1459 struct camif_scaler scaler
;
1461 if (sel
->target
!= V4L2_SEL_TGT_CROP
|| sel
->pad
!= CAMIF_SD_PAD_SINK
)
1464 mutex_lock(&camif
->lock
);
1465 __camif_try_crop(camif
, &sel
->r
);
1467 if (sel
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
1468 *v4l2_subdev_get_try_crop(fh
, sel
->pad
) = sel
->r
;
1470 unsigned long flags
;
1473 spin_lock_irqsave(&camif
->slock
, flags
);
1476 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1477 struct camif_vp
*vp
= &camif
->vp
[i
];
1478 scaler
= vp
->scaler
;
1479 if (s3c_camif_get_scaler_config(vp
, &scaler
))
1481 vp
->scaler
= scaler
;
1482 vp
->state
|= ST_VP_CONFIG
;
1485 spin_unlock_irqrestore(&camif
->slock
, flags
);
1487 mutex_unlock(&camif
->lock
);
1489 v4l2_dbg(1, debug
, sd
, "%s: (%d,%d) %dx%d, f_w: %u, f_h: %u\n",
1490 __func__
, crop
->left
, crop
->top
, crop
->width
, crop
->height
,
1491 camif
->mbus_fmt
.width
, camif
->mbus_fmt
.height
);
1496 static const struct v4l2_subdev_pad_ops s3c_camif_subdev_pad_ops
= {
1497 .enum_mbus_code
= s3c_camif_subdev_enum_mbus_code
,
1498 .get_selection
= s3c_camif_subdev_get_selection
,
1499 .set_selection
= s3c_camif_subdev_set_selection
,
1500 .get_fmt
= s3c_camif_subdev_get_fmt
,
1501 .set_fmt
= s3c_camif_subdev_set_fmt
,
1504 static struct v4l2_subdev_ops s3c_camif_subdev_ops
= {
1505 .pad
= &s3c_camif_subdev_pad_ops
,
1508 static int s3c_camif_subdev_s_ctrl(struct v4l2_ctrl
*ctrl
)
1510 struct camif_dev
*camif
= container_of(ctrl
->handler
, struct camif_dev
,
1512 unsigned long flags
;
1514 spin_lock_irqsave(&camif
->slock
, flags
);
1517 case V4L2_CID_COLORFX
:
1518 camif
->colorfx
= camif
->ctrl_colorfx
->val
;
1520 switch (ctrl
->val
) {
1521 case V4L2_COLORFX_SEPIA
:
1522 camif
->colorfx_cb
= 115;
1523 camif
->colorfx_cr
= 145;
1525 case V4L2_COLORFX_SET_CBCR
:
1526 camif
->colorfx_cb
= camif
->ctrl_colorfx_cbcr
->val
>> 8;
1527 camif
->colorfx_cr
= camif
->ctrl_colorfx_cbcr
->val
& 0xff;
1530 /* for V4L2_COLORFX_BW and others */
1531 camif
->colorfx_cb
= 128;
1532 camif
->colorfx_cr
= 128;
1535 case V4L2_CID_TEST_PATTERN
:
1536 camif
->test_pattern
= camif
->ctrl_test_pattern
->val
;
1542 camif
->vp
[VP_CODEC
].state
|= ST_VP_CONFIG
;
1543 camif
->vp
[VP_PREVIEW
].state
|= ST_VP_CONFIG
;
1544 spin_unlock_irqrestore(&camif
->slock
, flags
);
1549 static const struct v4l2_ctrl_ops s3c_camif_subdev_ctrl_ops
= {
1550 .s_ctrl
= s3c_camif_subdev_s_ctrl
,
1553 static const char * const s3c_camif_test_pattern_menu
[] = {
1556 "Horizontal increment",
1557 "Vertical increment",
1560 int s3c_camif_create_subdev(struct camif_dev
*camif
)
1562 struct v4l2_ctrl_handler
*handler
= &camif
->ctrl_handler
;
1563 struct v4l2_subdev
*sd
= &camif
->subdev
;
1566 v4l2_subdev_init(sd
, &s3c_camif_subdev_ops
);
1567 sd
->flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
1568 strlcpy(sd
->name
, "S3C-CAMIF", sizeof(sd
->name
));
1570 camif
->pads
[CAMIF_SD_PAD_SINK
].flags
= MEDIA_PAD_FL_SINK
;
1571 camif
->pads
[CAMIF_SD_PAD_SOURCE_C
].flags
= MEDIA_PAD_FL_SOURCE
;
1572 camif
->pads
[CAMIF_SD_PAD_SOURCE_P
].flags
= MEDIA_PAD_FL_SOURCE
;
1574 ret
= media_entity_init(&sd
->entity
, CAMIF_SD_PADS_NUM
,
1579 v4l2_ctrl_handler_init(handler
, 3);
1580 camif
->ctrl_test_pattern
= v4l2_ctrl_new_std_menu_items(handler
,
1581 &s3c_camif_subdev_ctrl_ops
, V4L2_CID_TEST_PATTERN
,
1582 ARRAY_SIZE(s3c_camif_test_pattern_menu
) - 1, 0, 0,
1583 s3c_camif_test_pattern_menu
);
1585 if (camif
->variant
->has_img_effect
) {
1586 camif
->ctrl_colorfx
= v4l2_ctrl_new_std_menu(handler
,
1587 &s3c_camif_subdev_ctrl_ops
,
1588 V4L2_CID_COLORFX
, V4L2_COLORFX_SET_CBCR
,
1589 ~0x981f, V4L2_COLORFX_NONE
);
1591 camif
->ctrl_colorfx_cbcr
= v4l2_ctrl_new_std(handler
,
1592 &s3c_camif_subdev_ctrl_ops
,
1593 V4L2_CID_COLORFX_CBCR
, 0, 0xffff, 1, 0);
1596 if (handler
->error
) {
1597 v4l2_ctrl_handler_free(handler
);
1598 media_entity_cleanup(&sd
->entity
);
1599 return handler
->error
;
1602 if (camif
->variant
->has_img_effect
)
1603 v4l2_ctrl_auto_cluster(2, &camif
->ctrl_colorfx
,
1604 V4L2_COLORFX_SET_CBCR
, false);
1606 sd
->ctrl_handler
= handler
;
1607 v4l2_set_subdevdata(sd
, camif
);
1612 void s3c_camif_unregister_subdev(struct camif_dev
*camif
)
1614 struct v4l2_subdev
*sd
= &camif
->subdev
;
1616 /* Return if not registered */
1617 if (v4l2_get_subdevdata(sd
) == NULL
)
1620 v4l2_device_unregister_subdev(sd
);
1621 media_entity_cleanup(&sd
->entity
);
1622 v4l2_ctrl_handler_free(&camif
->ctrl_handler
);
1623 v4l2_set_subdevdata(sd
, NULL
);
1626 int s3c_camif_set_defaults(struct camif_dev
*camif
)
1628 unsigned int ip_rev
= camif
->variant
->ip_revision
;
1631 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
1632 struct camif_vp
*vp
= &camif
->vp
[i
];
1633 struct camif_frame
*f
= &vp
->out_frame
;
1637 vp
->offset
= camif
->variant
->vp_offset
;
1639 if (ip_rev
== S3C244X_CAMIF_IP_REV
)
1640 vp
->fmt_flags
= i
? FMT_FL_S3C24XX_PREVIEW
:
1641 FMT_FL_S3C24XX_CODEC
;
1643 vp
->fmt_flags
= FMT_FL_S3C64XX
;
1645 vp
->out_fmt
= s3c_camif_find_format(vp
, NULL
, 0);
1646 BUG_ON(vp
->out_fmt
== NULL
);
1648 memset(f
, 0, sizeof(*f
));
1649 f
->f_width
= CAMIF_DEF_WIDTH
;
1650 f
->f_height
= CAMIF_DEF_HEIGHT
;
1651 f
->rect
.width
= CAMIF_DEF_WIDTH
;
1652 f
->rect
.height
= CAMIF_DEF_HEIGHT
;
1654 /* Scaler is always enabled */
1655 vp
->scaler
.enable
= 1;
1657 vp
->payload
= (f
->f_width
* f
->f_height
*
1658 vp
->out_fmt
->depth
) / 8;
1661 memset(&camif
->mbus_fmt
, 0, sizeof(camif
->mbus_fmt
));
1662 camif
->mbus_fmt
.width
= CAMIF_DEF_WIDTH
;
1663 camif
->mbus_fmt
.height
= CAMIF_DEF_HEIGHT
;
1664 camif
->mbus_fmt
.code
= camif_mbus_formats
[0];
1666 memset(&camif
->camif_crop
, 0, sizeof(camif
->camif_crop
));
1667 camif
->camif_crop
.width
= CAMIF_DEF_WIDTH
;
1668 camif
->camif_crop
.height
= CAMIF_DEF_HEIGHT
;