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 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation, either version 2 of the License,
10 * or (at your option) any later version.
12 #define pr_fmt(fmt) "%s:%d " fmt, __func__, __LINE__
14 #include <linux/bug.h>
15 #include <linux/clk.h>
16 #include <linux/delay.h>
17 #include <linux/device.h>
18 #include <linux/errno.h>
19 #include <linux/gpio.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/slab.h>
29 #include <linux/types.h>
31 #include <media/media-device.h>
32 #include <media/v4l2-ctrls.h>
33 #include <media/v4l2-ioctl.h>
34 #include <media/videobuf2-core.h>
35 #include <media/videobuf2-dma-contig.h>
37 #include "camif-core.h"
39 static char *camif_clocks
[CLK_MAX_NUM
] = {
40 /* HCLK CAMIF clock */
42 /* CAMIF / external camera sensor master clock */
46 static const struct camif_fmt camif_formats
[] = {
48 .name
= "YUV 4:2:2 planar, Y/Cb/Cr",
49 .fourcc
= V4L2_PIX_FMT_YUV422P
,
52 .color
= IMG_FMT_YCBCR422P
,
54 .flags
= FMT_FL_S3C24XX_CODEC
|
57 .name
= "YUV 4:2:0 planar, Y/Cb/Cr",
58 .fourcc
= V4L2_PIX_FMT_YUV420
,
61 .color
= IMG_FMT_YCBCR420
,
63 .flags
= FMT_FL_S3C24XX_CODEC
|
66 .name
= "YVU 4:2:0 planar, Y/Cr/Cb",
67 .fourcc
= V4L2_PIX_FMT_YVU420
,
70 .color
= IMG_FMT_YCRCB420
,
72 .flags
= FMT_FL_S3C24XX_CODEC
|
75 .name
= "RGB565, 16 bpp",
76 .fourcc
= V4L2_PIX_FMT_RGB565X
,
79 .color
= IMG_FMT_RGB565
,
81 .flags
= FMT_FL_S3C24XX_PREVIEW
|
84 .name
= "XRGB8888, 32 bpp",
85 .fourcc
= V4L2_PIX_FMT_RGB32
,
88 .color
= IMG_FMT_XRGB8888
,
90 .flags
= FMT_FL_S3C24XX_PREVIEW
|
94 .fourcc
= V4L2_PIX_FMT_BGR666
,
97 .color
= IMG_FMT_RGB666
,
99 .flags
= FMT_FL_S3C64XX
,
104 * s3c_camif_find_format() - lookup camif color format by fourcc or an index
105 * @pixelformat: fourcc to match, ignored if null
106 * @index: index to the camif_formats array, ignored if negative
108 const struct camif_fmt
*s3c_camif_find_format(struct camif_vp
*vp
,
109 const u32
*pixelformat
,
112 const struct camif_fmt
*fmt
, *def_fmt
= NULL
;
116 if (index
>= (int)ARRAY_SIZE(camif_formats
))
119 for (i
= 0; i
< ARRAY_SIZE(camif_formats
); ++i
) {
120 fmt
= &camif_formats
[i
];
121 if (vp
&& !(vp
->fmt_flags
& fmt
->flags
))
123 if (pixelformat
&& fmt
->fourcc
== *pixelformat
)
132 static int camif_get_scaler_factor(u32 src
, u32 tar
, u32
*ratio
, u32
*shift
)
140 unsigned int tmp
= 1 << sh
;
141 if (src
>= tar
* tmp
) {
142 *shift
= sh
, *ratio
= tmp
;
146 *shift
= 0, *ratio
= 1;
150 int s3c_camif_get_scaler_config(struct camif_vp
*vp
,
151 struct camif_scaler
*scaler
)
153 struct v4l2_rect
*camif_crop
= &vp
->camif
->camif_crop
;
154 int source_x
= camif_crop
->width
;
155 int source_y
= camif_crop
->height
;
156 int target_x
= vp
->out_frame
.rect
.width
;
157 int target_y
= vp
->out_frame
.rect
.height
;
160 if (vp
->rotation
== 90 || vp
->rotation
== 270)
161 swap(target_x
, target_y
);
163 ret
= camif_get_scaler_factor(source_x
, target_x
, &scaler
->pre_h_ratio
,
168 ret
= camif_get_scaler_factor(source_y
, target_y
, &scaler
->pre_v_ratio
,
173 scaler
->pre_dst_width
= source_x
/ scaler
->pre_h_ratio
;
174 scaler
->pre_dst_height
= source_y
/ scaler
->pre_v_ratio
;
176 scaler
->main_h_ratio
= (source_x
<< 8) / (target_x
<< scaler
->h_shift
);
177 scaler
->main_v_ratio
= (source_y
<< 8) / (target_y
<< scaler
->v_shift
);
179 scaler
->scaleup_h
= (target_x
>= source_x
);
180 scaler
->scaleup_v
= (target_y
>= source_y
);
184 pr_debug("H: ratio: %u, shift: %u. V: ratio: %u, shift: %u.\n",
185 scaler
->pre_h_ratio
, scaler
->h_shift
,
186 scaler
->pre_v_ratio
, scaler
->v_shift
);
188 pr_debug("Source: %dx%d, Target: %dx%d, scaleup_h/v: %d/%d\n",
189 source_x
, source_y
, target_x
, target_y
,
190 scaler
->scaleup_h
, scaler
->scaleup_v
);
195 static int camif_register_sensor(struct camif_dev
*camif
)
197 struct s3c_camif_sensor_info
*sensor
= &camif
->pdata
.sensor
;
198 struct v4l2_device
*v4l2_dev
= &camif
->v4l2_dev
;
199 struct i2c_adapter
*adapter
;
200 struct v4l2_subdev_format format
;
201 struct v4l2_subdev
*sd
;
204 camif
->sensor
.sd
= NULL
;
206 if (sensor
->i2c_board_info
.addr
== 0)
209 adapter
= i2c_get_adapter(sensor
->i2c_bus_num
);
210 if (adapter
== NULL
) {
211 v4l2_warn(v4l2_dev
, "failed to get I2C adapter %d\n",
212 sensor
->i2c_bus_num
);
213 return -EPROBE_DEFER
;
216 sd
= v4l2_i2c_new_subdev_board(v4l2_dev
, adapter
,
217 &sensor
->i2c_board_info
, NULL
);
219 i2c_put_adapter(adapter
);
220 v4l2_warn(v4l2_dev
, "failed to acquire subdev %s\n",
221 sensor
->i2c_board_info
.type
);
222 return -EPROBE_DEFER
;
224 camif
->sensor
.sd
= sd
;
226 v4l2_info(v4l2_dev
, "registered sensor subdevice %s\n", sd
->name
);
228 /* Get initial pixel format and set it at the camif sink pad */
230 format
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
231 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &format
);
236 format
.pad
= CAMIF_SD_PAD_SINK
;
237 v4l2_subdev_call(&camif
->subdev
, pad
, set_fmt
, NULL
, &format
);
239 v4l2_info(sd
, "Initial format from sensor: %dx%d, %#x\n",
240 format
.format
.width
, format
.format
.height
,
245 static void camif_unregister_sensor(struct camif_dev
*camif
)
247 struct v4l2_subdev
*sd
= camif
->sensor
.sd
;
248 struct i2c_client
*client
= sd
? v4l2_get_subdevdata(sd
) : NULL
;
249 struct i2c_adapter
*adapter
;
254 adapter
= client
->adapter
;
255 v4l2_device_unregister_subdev(sd
);
256 camif
->sensor
.sd
= NULL
;
257 i2c_unregister_device(client
);
259 i2c_put_adapter(adapter
);
262 static int camif_create_media_links(struct camif_dev
*camif
)
266 ret
= media_entity_create_link(&camif
->sensor
.sd
->entity
, 0,
267 &camif
->subdev
.entity
, CAMIF_SD_PAD_SINK
,
268 MEDIA_LNK_FL_IMMUTABLE
|
269 MEDIA_LNK_FL_ENABLED
);
273 for (i
= 1; i
< CAMIF_SD_PADS_NUM
&& !ret
; i
++) {
274 ret
= media_entity_create_link(&camif
->subdev
.entity
, i
,
275 &camif
->vp
[i
- 1].vdev
.entity
, 0,
276 MEDIA_LNK_FL_IMMUTABLE
|
277 MEDIA_LNK_FL_ENABLED
);
283 static int camif_register_video_nodes(struct camif_dev
*camif
)
285 int ret
= s3c_camif_register_video_node(camif
, VP_CODEC
);
289 return s3c_camif_register_video_node(camif
, VP_PREVIEW
);
292 static void camif_unregister_video_nodes(struct camif_dev
*camif
)
294 s3c_camif_unregister_video_node(camif
, VP_CODEC
);
295 s3c_camif_unregister_video_node(camif
, VP_PREVIEW
);
298 static void camif_unregister_media_entities(struct camif_dev
*camif
)
300 camif_unregister_video_nodes(camif
);
301 camif_unregister_sensor(camif
);
302 s3c_camif_unregister_subdev(camif
);
308 static int camif_media_dev_register(struct camif_dev
*camif
)
310 struct media_device
*md
= &camif
->media_dev
;
311 struct v4l2_device
*v4l2_dev
= &camif
->v4l2_dev
;
312 unsigned int ip_rev
= camif
->variant
->ip_revision
;
315 memset(md
, 0, sizeof(*md
));
316 snprintf(md
->model
, sizeof(md
->model
), "SAMSUNG S3C%s CAMIF",
317 ip_rev
== S3C6410_CAMIF_IP_REV
? "6410" : "244X");
318 strlcpy(md
->bus_info
, "platform", sizeof(md
->bus_info
));
319 md
->hw_revision
= ip_rev
;
320 md
->driver_version
= KERNEL_VERSION(1, 0, 0);
322 md
->dev
= camif
->dev
;
324 strlcpy(v4l2_dev
->name
, "s3c-camif", sizeof(v4l2_dev
->name
));
327 ret
= v4l2_device_register(camif
->dev
, v4l2_dev
);
331 ret
= media_device_register(md
);
333 v4l2_device_unregister(v4l2_dev
);
338 static void camif_clk_put(struct camif_dev
*camif
)
342 for (i
= 0; i
< CLK_MAX_NUM
; i
++) {
343 if (IS_ERR_OR_NULL(camif
->clock
[i
]))
345 clk_unprepare(camif
->clock
[i
]);
346 clk_put(camif
->clock
[i
]);
350 static int camif_clk_get(struct camif_dev
*camif
)
354 for (i
= 0; i
< CLK_MAX_NUM
; i
++) {
355 camif
->clock
[i
] = clk_get(camif
->dev
, camif_clocks
[i
]);
356 if (IS_ERR(camif
->clock
[i
])) {
357 ret
= PTR_ERR(camif
->clock
[i
]);
360 ret
= clk_prepare(camif
->clock
[i
]);
362 clk_put(camif
->clock
[i
]);
363 camif
->clock
[i
] = NULL
;
369 camif_clk_put(camif
);
370 dev_err(camif
->dev
, "failed to get clock: %s\n",
376 * The CAMIF device has two relatively independent data processing paths
377 * that can source data from memory or the common camera input frontend.
378 * Register interrupts for each data processing path (camif_vp).
380 static int camif_request_irqs(struct platform_device
*pdev
,
381 struct camif_dev
*camif
)
385 for (i
= 0; i
< CAMIF_VP_NUM
; i
++) {
386 struct camif_vp
*vp
= &camif
->vp
[i
];
388 init_waitqueue_head(&vp
->irq_queue
);
390 irq
= platform_get_irq(pdev
, i
);
392 dev_err(&pdev
->dev
, "failed to get IRQ %d\n", i
);
396 ret
= devm_request_irq(&pdev
->dev
, irq
, s3c_camif_irq_handler
,
397 0, dev_name(&pdev
->dev
), vp
);
399 dev_err(&pdev
->dev
, "failed to install IRQ: %d\n", ret
);
407 static int s3c_camif_probe(struct platform_device
*pdev
)
409 struct device
*dev
= &pdev
->dev
;
410 struct s3c_camif_plat_data
*pdata
= dev
->platform_data
;
411 struct s3c_camif_drvdata
*drvdata
;
412 struct camif_dev
*camif
;
413 struct resource
*mres
;
416 camif
= devm_kzalloc(dev
, sizeof(*camif
), GFP_KERNEL
);
420 spin_lock_init(&camif
->slock
);
421 mutex_init(&camif
->lock
);
425 if (!pdata
|| !pdata
->gpio_get
|| !pdata
->gpio_put
) {
426 dev_err(dev
, "wrong platform data\n");
430 camif
->pdata
= *pdata
;
431 drvdata
= (void *)platform_get_device_id(pdev
)->driver_data
;
432 camif
->variant
= drvdata
->variant
;
434 mres
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
436 camif
->io_base
= devm_request_and_ioremap(dev
, mres
);
437 if (!camif
->io_base
) {
438 dev_err(dev
, "failed to obtain I/O memory\n");
442 ret
= camif_request_irqs(pdev
, camif
);
446 ret
= pdata
->gpio_get();
450 ret
= s3c_camif_create_subdev(camif
);
454 ret
= camif_clk_get(camif
);
458 platform_set_drvdata(pdev
, camif
);
459 clk_set_rate(camif
->clock
[CLK_CAM
],
460 camif
->pdata
.sensor
.clock_frequency
);
462 dev_info(dev
, "sensor clock frequency: %lu\n",
463 clk_get_rate(camif
->clock
[CLK_CAM
]));
465 * Set initial pixel format, resolution and crop rectangle.
466 * Must be done before a sensor subdev is registered as some
467 * settings are overrode with values from sensor subdev.
469 s3c_camif_set_defaults(camif
);
471 pm_runtime_enable(dev
);
473 ret
= pm_runtime_get_sync(dev
);
477 /* Initialize contiguous memory allocator */
478 camif
->alloc_ctx
= vb2_dma_contig_init_ctx(dev
);
479 if (IS_ERR(camif
->alloc_ctx
)) {
480 ret
= PTR_ERR(camif
->alloc_ctx
);
484 ret
= camif_media_dev_register(camif
);
488 ret
= camif_register_sensor(camif
);
492 ret
= v4l2_device_register_subdev(&camif
->v4l2_dev
, &camif
->subdev
);
496 mutex_lock(&camif
->media_dev
.graph_mutex
);
498 ret
= v4l2_device_register_subdev_nodes(&camif
->v4l2_dev
);
502 ret
= camif_register_video_nodes(camif
);
506 ret
= camif_create_media_links(camif
);
510 mutex_unlock(&camif
->media_dev
.graph_mutex
);
515 mutex_unlock(&camif
->media_dev
.graph_mutex
);
517 v4l2_device_unregister(&camif
->v4l2_dev
);
518 media_device_unregister(&camif
->media_dev
);
519 camif_unregister_media_entities(camif
);
521 vb2_dma_contig_cleanup_ctx(camif
->alloc_ctx
);
524 pm_runtime_disable(dev
);
526 camif_clk_put(camif
);
528 s3c_camif_unregister_subdev(camif
);
534 static int s3c_camif_remove(struct platform_device
*pdev
)
536 struct camif_dev
*camif
= platform_get_drvdata(pdev
);
537 struct s3c_camif_plat_data
*pdata
= &camif
->pdata
;
539 media_device_unregister(&camif
->media_dev
);
540 camif_unregister_media_entities(camif
);
541 v4l2_device_unregister(&camif
->v4l2_dev
);
543 pm_runtime_disable(&pdev
->dev
);
544 camif_clk_put(camif
);
550 static int s3c_camif_runtime_resume(struct device
*dev
)
552 struct camif_dev
*camif
= dev_get_drvdata(dev
);
554 clk_enable(camif
->clock
[CLK_GATE
]);
555 /* null op on s3c244x */
556 clk_enable(camif
->clock
[CLK_CAM
]);
560 static int s3c_camif_runtime_suspend(struct device
*dev
)
562 struct camif_dev
*camif
= dev_get_drvdata(dev
);
564 /* null op on s3c244x */
565 clk_disable(camif
->clock
[CLK_CAM
]);
567 clk_disable(camif
->clock
[CLK_GATE
]);
571 static const struct s3c_camif_variant s3c244x_camif_variant
= {
574 .max_out_width
= 4096,
575 .max_sc_out_width
= 2048,
576 .out_width_align
= 16,
581 .max_out_width
= 640,
582 .max_sc_out_width
= 640,
583 .out_width_align
= 16,
589 .win_hor_offset_align
= 8,
591 .ip_revision
= S3C244X_CAMIF_IP_REV
,
594 static struct s3c_camif_drvdata s3c244x_camif_drvdata
= {
595 .variant
= &s3c244x_camif_variant
,
596 .bus_clk_freq
= 24000000UL,
599 static const struct s3c_camif_variant s3c6410_camif_variant
= {
602 .max_out_width
= 4096,
603 .max_sc_out_width
= 2048,
604 .out_width_align
= 16,
609 .max_out_width
= 4096,
610 .max_sc_out_width
= 720,
611 .out_width_align
= 16,
617 .win_hor_offset_align
= 8,
619 .ip_revision
= S3C6410_CAMIF_IP_REV
,
624 static struct s3c_camif_drvdata s3c6410_camif_drvdata
= {
625 .variant
= &s3c6410_camif_variant
,
626 .bus_clk_freq
= 133000000UL,
629 static struct platform_device_id s3c_camif_driver_ids
[] = {
631 .name
= "s3c2440-camif",
632 .driver_data
= (unsigned long)&s3c244x_camif_drvdata
,
634 .name
= "s3c6410-camif",
635 .driver_data
= (unsigned long)&s3c6410_camif_drvdata
,
639 MODULE_DEVICE_TABLE(platform
, s3c_camif_driver_ids
);
641 static const struct dev_pm_ops s3c_camif_pm_ops
= {
642 .runtime_suspend
= s3c_camif_runtime_suspend
,
643 .runtime_resume
= s3c_camif_runtime_resume
,
646 static struct platform_driver s3c_camif_driver
= {
647 .probe
= s3c_camif_probe
,
648 .remove
= s3c_camif_remove
,
649 .id_table
= s3c_camif_driver_ids
,
651 .name
= S3C_CAMIF_DRIVER_NAME
,
652 .owner
= THIS_MODULE
,
653 .pm
= &s3c_camif_pm_ops
,
657 module_platform_driver(s3c_camif_driver
);
659 MODULE_AUTHOR("Sylwester Nawrocki <sylvester.nawrocki@gmail.com>");
660 MODULE_AUTHOR("Tomasz Figa <tomasz.figa@gmail.com>");
661 MODULE_DESCRIPTION("S3C24XX/S3C64XX SoC camera interface driver");
662 MODULE_LICENSE("GPL");