2 * Driver for the SH-Mobile MIPI CSI-2 unit
4 * Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/delay.h>
12 #include <linux/i2c.h>
14 #include <linux/platform_device.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/slab.h>
17 #include <linux/videodev2.h>
19 #include <media/sh_mobile_csi2.h>
20 #include <media/soc_camera.h>
21 #include <media/v4l2-common.h>
22 #include <media/v4l2-dev.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-mediabus.h>
25 #include <media/v4l2-subdev.h>
27 #define SH_CSI2_TREF 0x00
28 #define SH_CSI2_SRST 0x04
29 #define SH_CSI2_PHYCNT 0x08
30 #define SH_CSI2_CHKSUM 0x0C
31 #define SH_CSI2_VCDT 0x10
34 struct v4l2_subdev subdev
;
35 struct list_head list
;
36 struct notifier_block notifier
;
39 struct platform_device
*pdev
;
40 struct sh_csi2_client_config
*client
;
41 unsigned long (*query_bus_param
)(struct soc_camera_device
*);
42 int (*set_bus_param
)(struct soc_camera_device
*, unsigned long);
45 static int sh_csi2_try_fmt(struct v4l2_subdev
*sd
,
46 struct v4l2_mbus_framefmt
*mf
)
48 struct sh_csi2
*priv
= container_of(sd
, struct sh_csi2
, subdev
);
49 struct sh_csi2_pdata
*pdata
= priv
->pdev
->dev
.platform_data
;
53 else if (mf
->width
& 1)
56 switch (pdata
->type
) {
59 case V4L2_MBUS_FMT_UYVY8_2X8
: /* YUV422 */
60 case V4L2_MBUS_FMT_YUYV8_1_5X8
: /* YUV420 */
61 case V4L2_MBUS_FMT_Y8_1X8
: /* RAW8 */
62 case V4L2_MBUS_FMT_SBGGR8_1X8
:
63 case V4L2_MBUS_FMT_SGRBG8_1X8
:
66 /* All MIPI CSI-2 devices must support one of primary formats */
67 mf
->code
= V4L2_MBUS_FMT_YUYV8_2X8
;
72 case V4L2_MBUS_FMT_Y8_1X8
: /* RAW8 */
73 case V4L2_MBUS_FMT_SBGGR8_1X8
:
74 case V4L2_MBUS_FMT_SGRBG8_1X8
:
75 case V4L2_MBUS_FMT_SBGGR10_1X10
: /* RAW10 */
76 case V4L2_MBUS_FMT_SBGGR12_1X12
: /* RAW12 */
79 /* All MIPI CSI-2 devices must support one of primary formats */
80 mf
->code
= V4L2_MBUS_FMT_SBGGR8_1X8
;
89 * We have done our best in try_fmt to try and tell the sensor, which formats
90 * we support. If now the configuration is unsuitable for us we can only
93 static int sh_csi2_s_fmt(struct v4l2_subdev
*sd
,
94 struct v4l2_mbus_framefmt
*mf
)
96 struct sh_csi2
*priv
= container_of(sd
, struct sh_csi2
, subdev
);
97 u32 tmp
= (priv
->client
->channel
& 3) << 8;
99 dev_dbg(sd
->v4l2_dev
->dev
, "%s(%u)\n", __func__
, mf
->code
);
100 if (mf
->width
> 8188 || mf
->width
& 1)
104 case V4L2_MBUS_FMT_UYVY8_2X8
:
105 tmp
|= 0x1e; /* YUV422 8 bit */
107 case V4L2_MBUS_FMT_YUYV8_1_5X8
:
108 tmp
|= 0x18; /* YUV420 8 bit */
110 case V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE
:
111 tmp
|= 0x21; /* RGB555 */
113 case V4L2_MBUS_FMT_RGB565_2X8_BE
:
114 tmp
|= 0x22; /* RGB565 */
116 case V4L2_MBUS_FMT_Y8_1X8
:
117 case V4L2_MBUS_FMT_SBGGR8_1X8
:
118 case V4L2_MBUS_FMT_SGRBG8_1X8
:
119 tmp
|= 0x2a; /* RAW8 */
125 iowrite32(tmp
, priv
->base
+ SH_CSI2_VCDT
);
130 static struct v4l2_subdev_video_ops sh_csi2_subdev_video_ops
= {
131 .s_mbus_fmt
= sh_csi2_s_fmt
,
132 .try_mbus_fmt
= sh_csi2_try_fmt
,
135 static struct v4l2_subdev_core_ops sh_csi2_subdev_core_ops
;
137 static struct v4l2_subdev_ops sh_csi2_subdev_ops
= {
138 .core
= &sh_csi2_subdev_core_ops
,
139 .video
= &sh_csi2_subdev_video_ops
,
142 static void sh_csi2_hwinit(struct sh_csi2
*priv
)
144 struct sh_csi2_pdata
*pdata
= priv
->pdev
->dev
.platform_data
;
145 __u32 tmp
= 0x10; /* Enable MIPI CSI clock lane */
147 /* Reflect registers immediately */
148 iowrite32(0x00000001, priv
->base
+ SH_CSI2_TREF
);
149 /* reset CSI2 harware */
150 iowrite32(0x00000001, priv
->base
+ SH_CSI2_SRST
);
152 iowrite32(0x00000000, priv
->base
+ SH_CSI2_SRST
);
154 if (priv
->client
->lanes
& 3)
155 tmp
|= priv
->client
->lanes
& 3;
157 /* Default - both lanes */
160 if (priv
->client
->phy
== SH_CSI2_PHY_MAIN
)
163 iowrite32(tmp
, priv
->base
+ SH_CSI2_PHYCNT
);
166 if (pdata
->flags
& SH_CSI2_ECC
)
168 if (pdata
->flags
& SH_CSI2_CRC
)
170 iowrite32(tmp
, priv
->base
+ SH_CSI2_CHKSUM
);
173 static int sh_csi2_set_bus_param(struct soc_camera_device
*icd
,
179 static unsigned long sh_csi2_query_bus_param(struct soc_camera_device
*icd
)
181 struct soc_camera_link
*icl
= to_soc_camera_link(icd
);
182 const unsigned long flags
= SOCAM_PCLK_SAMPLE_RISING
|
183 SOCAM_HSYNC_ACTIVE_HIGH
| SOCAM_VSYNC_ACTIVE_HIGH
|
184 SOCAM_MASTER
| SOCAM_DATAWIDTH_8
| SOCAM_DATA_ACTIVE_HIGH
;
186 return soc_camera_apply_sensor_flags(icl
, flags
);
189 static int sh_csi2_notify(struct notifier_block
*nb
,
190 unsigned long action
, void *data
)
192 struct device
*dev
= data
;
193 struct soc_camera_device
*icd
= to_soc_camera_dev(dev
);
194 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(dev
->parent
);
195 struct sh_csi2
*priv
=
196 container_of(nb
, struct sh_csi2
, notifier
);
197 struct sh_csi2_pdata
*pdata
= priv
->pdev
->dev
.platform_data
;
200 for (i
= 0; i
< pdata
->num_clients
; i
++)
201 if (&pdata
->clients
[i
].pdev
->dev
== icd
->pdev
)
204 dev_dbg(dev
, "%s(%p): action = %lu, found #%d\n", __func__
, dev
, action
, i
);
206 if (i
== pdata
->num_clients
)
210 case BUS_NOTIFY_BOUND_DRIVER
:
211 snprintf(priv
->subdev
.name
, V4L2_SUBDEV_NAME_SIZE
, "%s%s",
212 dev_name(v4l2_dev
->dev
), ".mipi-csi");
213 priv
->subdev
.grp_id
= (long)icd
;
214 ret
= v4l2_device_register_subdev(v4l2_dev
, &priv
->subdev
);
215 dev_dbg(dev
, "%s(%p): ret(register_subdev) = %d\n", __func__
, priv
, ret
);
219 priv
->client
= pdata
->clients
+ i
;
221 priv
->set_bus_param
= icd
->ops
->set_bus_param
;
222 priv
->query_bus_param
= icd
->ops
->query_bus_param
;
223 icd
->ops
->set_bus_param
= sh_csi2_set_bus_param
;
224 icd
->ops
->query_bus_param
= sh_csi2_query_bus_param
;
226 pm_runtime_get_sync(v4l2_get_subdevdata(&priv
->subdev
));
228 sh_csi2_hwinit(priv
);
230 case BUS_NOTIFY_UNBIND_DRIVER
:
233 /* Driver is about to be unbound */
234 icd
->ops
->set_bus_param
= priv
->set_bus_param
;
235 icd
->ops
->query_bus_param
= priv
->query_bus_param
;
236 priv
->set_bus_param
= NULL
;
237 priv
->query_bus_param
= NULL
;
239 v4l2_device_unregister_subdev(&priv
->subdev
);
241 pm_runtime_put(v4l2_get_subdevdata(&priv
->subdev
));
248 static __devinit
int sh_csi2_probe(struct platform_device
*pdev
)
250 struct resource
*res
;
253 struct sh_csi2
*priv
;
254 /* Platform data specify the PHY, lanes, ECC, CRC */
255 struct sh_csi2_pdata
*pdata
= pdev
->dev
.platform_data
;
257 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
258 /* Interrupt unused so far */
259 irq
= platform_get_irq(pdev
, 0);
261 if (!res
|| (int)irq
<= 0 || !pdata
) {
262 dev_err(&pdev
->dev
, "Not enough CSI2 platform resources.\n");
266 /* TODO: Add support for CSI2I. Careful: different register layout! */
267 if (pdata
->type
!= SH_CSI2C
) {
268 dev_err(&pdev
->dev
, "Only CSI2C supported ATM.\n");
272 priv
= kzalloc(sizeof(struct sh_csi2
), GFP_KERNEL
);
277 priv
->notifier
.notifier_call
= sh_csi2_notify
;
279 /* We MUST attach after the MIPI sensor */
280 ret
= bus_register_notifier(&soc_camera_bus_type
, &priv
->notifier
);
282 dev_err(&pdev
->dev
, "CSI2 cannot register notifier\n");
286 if (!request_mem_region(res
->start
, resource_size(res
), pdev
->name
)) {
287 dev_err(&pdev
->dev
, "CSI2 register region already claimed\n");
292 priv
->base
= ioremap(res
->start
, resource_size(res
));
295 dev_err(&pdev
->dev
, "Unable to ioremap CSI2 registers.\n");
301 v4l2_subdev_init(&priv
->subdev
, &sh_csi2_subdev_ops
);
302 v4l2_set_subdevdata(&priv
->subdev
, &pdev
->dev
);
304 platform_set_drvdata(pdev
, priv
);
306 pm_runtime_enable(&pdev
->dev
);
308 dev_dbg(&pdev
->dev
, "CSI2 probed.\n");
313 release_mem_region(res
->start
, resource_size(res
));
315 bus_unregister_notifier(&soc_camera_bus_type
, &priv
->notifier
);
322 static __devexit
int sh_csi2_remove(struct platform_device
*pdev
)
324 struct sh_csi2
*priv
= platform_get_drvdata(pdev
);
325 struct resource
*res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
327 bus_unregister_notifier(&soc_camera_bus_type
, &priv
->notifier
);
328 pm_runtime_disable(&pdev
->dev
);
330 release_mem_region(res
->start
, resource_size(res
));
331 platform_set_drvdata(pdev
, NULL
);
337 static struct platform_driver __refdata sh_csi2_pdrv
= {
338 .remove
= __devexit_p(sh_csi2_remove
),
340 .name
= "sh-mobile-csi2",
341 .owner
= THIS_MODULE
,
345 static int __init
sh_csi2_init(void)
347 return platform_driver_probe(&sh_csi2_pdrv
, sh_csi2_probe
);
350 static void __exit
sh_csi2_exit(void)
352 platform_driver_unregister(&sh_csi2_pdrv
);
355 module_init(sh_csi2_init
);
356 module_exit(sh_csi2_exit
);
358 MODULE_DESCRIPTION("SH-Mobile MIPI CSI-2 driver");
359 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
360 MODULE_LICENSE("GPL v2");
361 MODULE_ALIAS("platform:sh-mobile-csi2");