1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2016 NextThing Co
4  * Copyright (C) 2016-2019 Bootlin
5  *
6  * Author: Maxime Ripard <maxime.ripard@bootlin.com>
7  */
8 
9 #include <linux/clk.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13 #include <linux/mutex.h>
14 #include <linux/of.h>
15 #include <linux/of_device.h>
16 #include <linux/of_graph.h>
17 #include <linux/platform_device.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/reset.h>
20 #include <linux/videodev2.h>
21 
22 #include <media/v4l2-dev.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-fwnode.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/v4l2-mediabus.h>
27 
28 #include <media/videobuf2-core.h>
29 #include <media/videobuf2-dma-contig.h>
30 
31 #include "sun4i_csi.h"
32 
33 struct sun4i_csi_traits {
34 	unsigned int channels;
35 	unsigned int max_width;
36 	bool has_isp;
37 };
38 
39 static const struct media_entity_operations sun4i_csi_video_entity_ops = {
40 	.link_validate = v4l2_subdev_link_validate,
41 };
42 
43 static int sun4i_csi_notify_bound(struct v4l2_async_notifier *notifier,
44 				  struct v4l2_subdev *subdev,
45 				  struct v4l2_async_subdev *asd)
46 {
47 	struct sun4i_csi *csi = container_of(notifier, struct sun4i_csi,
48 					     notifier);
49 
50 	csi->src_subdev = subdev;
51 	csi->src_pad = media_entity_get_fwnode_pad(&subdev->entity,
52 						   subdev->fwnode,
53 						   MEDIA_PAD_FL_SOURCE);
54 	if (csi->src_pad < 0) {
55 		dev_err(csi->dev, "Couldn't find output pad for subdev %s\n",
56 			subdev->name);
57 		return csi->src_pad;
58 	}
59 
60 	dev_dbg(csi->dev, "Bound %s pad: %d\n", subdev->name, csi->src_pad);
61 	return 0;
62 }
63 
64 static int sun4i_csi_notify_complete(struct v4l2_async_notifier *notifier)
65 {
66 	struct sun4i_csi *csi = container_of(notifier, struct sun4i_csi,
67 					     notifier);
68 	struct v4l2_subdev *subdev = &csi->subdev;
69 	struct video_device *vdev = &csi->vdev;
70 	int ret;
71 
72 	ret = v4l2_device_register_subdev(&csi->v4l, subdev);
73 	if (ret < 0)
74 		return ret;
75 
76 	ret = sun4i_csi_v4l2_register(csi);
77 	if (ret < 0)
78 		return ret;
79 
80 	ret = media_device_register(&csi->mdev);
81 	if (ret)
82 		return ret;
83 
84 	/* Create link from subdev to main device */
85 	ret = media_create_pad_link(&subdev->entity, CSI_SUBDEV_SOURCE,
86 				    &vdev->entity, 0,
87 				    MEDIA_LNK_FL_ENABLED |
88 				    MEDIA_LNK_FL_IMMUTABLE);
89 	if (ret)
90 		goto err_clean_media;
91 
92 	ret = media_create_pad_link(&csi->src_subdev->entity, csi->src_pad,
93 				    &subdev->entity, CSI_SUBDEV_SINK,
94 				    MEDIA_LNK_FL_ENABLED |
95 				    MEDIA_LNK_FL_IMMUTABLE);
96 	if (ret)
97 		goto err_clean_media;
98 
99 	ret = v4l2_device_register_subdev_nodes(&csi->v4l);
100 	if (ret < 0)
101 		goto err_clean_media;
102 
103 	return 0;
104 
105 err_clean_media:
106 	media_device_unregister(&csi->mdev);
107 
108 	return ret;
109 }
110 
111 static const struct v4l2_async_notifier_operations sun4i_csi_notify_ops = {
112 	.bound		= sun4i_csi_notify_bound,
113 	.complete	= sun4i_csi_notify_complete,
114 };
115 
116 static int sun4i_csi_notifier_init(struct sun4i_csi *csi)
117 {
118 	struct v4l2_fwnode_endpoint vep = {
119 		.bus_type = V4L2_MBUS_PARALLEL,
120 	};
121 	struct v4l2_async_subdev *asd;
122 	struct fwnode_handle *ep;
123 	int ret;
124 
125 	v4l2_async_nf_init(&csi->notifier);
126 
127 	ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(csi->dev), 0, 0,
128 					     FWNODE_GRAPH_ENDPOINT_NEXT);
129 	if (!ep)
130 		return -EINVAL;
131 
132 	ret = v4l2_fwnode_endpoint_parse(ep, &vep);
133 	if (ret)
134 		goto out;
135 
136 	csi->bus = vep.bus.parallel;
137 
138 	asd = v4l2_async_nf_add_fwnode_remote(&csi->notifier, ep,
139 					      struct v4l2_async_subdev);
140 	if (IS_ERR(asd)) {
141 		ret = PTR_ERR(asd);
142 		goto out;
143 	}
144 
145 	csi->notifier.ops = &sun4i_csi_notify_ops;
146 
147 out:
148 	fwnode_handle_put(ep);
149 	return ret;
150 }
151 
152 static int sun4i_csi_probe(struct platform_device *pdev)
153 {
154 	struct v4l2_subdev *subdev;
155 	struct video_device *vdev;
156 	struct sun4i_csi *csi;
157 	int ret;
158 	int irq;
159 
160 	csi = devm_kzalloc(&pdev->dev, sizeof(*csi), GFP_KERNEL);
161 	if (!csi)
162 		return -ENOMEM;
163 	platform_set_drvdata(pdev, csi);
164 	csi->dev = &pdev->dev;
165 	subdev = &csi->subdev;
166 	vdev = &csi->vdev;
167 
168 	csi->traits = of_device_get_match_data(&pdev->dev);
169 	if (!csi->traits)
170 		return -EINVAL;
171 
172 	csi->mdev.dev = csi->dev;
173 	strscpy(csi->mdev.model, "Allwinner Video Capture Device",
174 		sizeof(csi->mdev.model));
175 	csi->mdev.hw_revision = 0;
176 	media_device_init(&csi->mdev);
177 	csi->v4l.mdev = &csi->mdev;
178 
179 	csi->regs = devm_platform_ioremap_resource(pdev, 0);
180 	if (IS_ERR(csi->regs))
181 		return PTR_ERR(csi->regs);
182 
183 	irq = platform_get_irq(pdev, 0);
184 	if (irq < 0)
185 		return irq;
186 
187 	csi->bus_clk = devm_clk_get(&pdev->dev, "bus");
188 	if (IS_ERR(csi->bus_clk)) {
189 		dev_err(&pdev->dev, "Couldn't get our bus clock\n");
190 		return PTR_ERR(csi->bus_clk);
191 	}
192 
193 	if (csi->traits->has_isp) {
194 		csi->isp_clk = devm_clk_get(&pdev->dev, "isp");
195 		if (IS_ERR(csi->isp_clk)) {
196 			dev_err(&pdev->dev, "Couldn't get our ISP clock\n");
197 			return PTR_ERR(csi->isp_clk);
198 		}
199 	}
200 
201 	csi->ram_clk = devm_clk_get(&pdev->dev, "ram");
202 	if (IS_ERR(csi->ram_clk)) {
203 		dev_err(&pdev->dev, "Couldn't get our ram clock\n");
204 		return PTR_ERR(csi->ram_clk);
205 	}
206 
207 	csi->rst = devm_reset_control_get(&pdev->dev, NULL);
208 	if (IS_ERR(csi->rst)) {
209 		dev_err(&pdev->dev, "Couldn't get our reset line\n");
210 		return PTR_ERR(csi->rst);
211 	}
212 
213 	/* Initialize subdev */
214 	v4l2_subdev_init(subdev, &sun4i_csi_subdev_ops);
215 	subdev->flags = V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
216 	subdev->entity.function = MEDIA_ENT_F_VID_IF_BRIDGE;
217 	subdev->owner = THIS_MODULE;
218 	snprintf(subdev->name, sizeof(subdev->name), "sun4i-csi-0");
219 	v4l2_set_subdevdata(subdev, csi);
220 
221 	csi->subdev_pads[CSI_SUBDEV_SINK].flags =
222 		MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
223 	csi->subdev_pads[CSI_SUBDEV_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
224 	ret = media_entity_pads_init(&subdev->entity, CSI_SUBDEV_PADS,
225 				     csi->subdev_pads);
226 	if (ret < 0)
227 		return ret;
228 
229 	csi->vdev_pad.flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
230 	vdev->entity.ops = &sun4i_csi_video_entity_ops;
231 	ret = media_entity_pads_init(&vdev->entity, 1, &csi->vdev_pad);
232 	if (ret < 0)
233 		return ret;
234 
235 	ret = sun4i_csi_dma_register(csi, irq);
236 	if (ret)
237 		goto err_clean_pad;
238 
239 	ret = sun4i_csi_notifier_init(csi);
240 	if (ret)
241 		goto err_unregister_media;
242 
243 	ret = v4l2_async_nf_register(&csi->v4l, &csi->notifier);
244 	if (ret) {
245 		dev_err(csi->dev, "Couldn't register our notifier.\n");
246 		goto err_unregister_media;
247 	}
248 
249 	pm_runtime_enable(&pdev->dev);
250 
251 	return 0;
252 
253 err_unregister_media:
254 	media_device_unregister(&csi->mdev);
255 	sun4i_csi_dma_unregister(csi);
256 
257 err_clean_pad:
258 	media_device_cleanup(&csi->mdev);
259 
260 	return ret;
261 }
262 
263 static int sun4i_csi_remove(struct platform_device *pdev)
264 {
265 	struct sun4i_csi *csi = platform_get_drvdata(pdev);
266 
267 	pm_runtime_disable(&pdev->dev);
268 	v4l2_async_nf_unregister(&csi->notifier);
269 	v4l2_async_nf_cleanup(&csi->notifier);
270 	vb2_video_unregister_device(&csi->vdev);
271 	media_device_unregister(&csi->mdev);
272 	sun4i_csi_dma_unregister(csi);
273 	media_device_cleanup(&csi->mdev);
274 
275 	return 0;
276 }
277 
278 static const struct sun4i_csi_traits sun4i_a10_csi1_traits = {
279 	.channels = 1,
280 	.max_width = 24,
281 	.has_isp = false,
282 };
283 
284 static const struct sun4i_csi_traits sun7i_a20_csi0_traits = {
285 	.channels = 4,
286 	.max_width = 16,
287 	.has_isp = true,
288 };
289 
290 static const struct of_device_id sun4i_csi_of_match[] = {
291 	{ .compatible = "allwinner,sun4i-a10-csi1", .data = &sun4i_a10_csi1_traits },
292 	{ .compatible = "allwinner,sun7i-a20-csi0", .data = &sun7i_a20_csi0_traits },
293 	{ /* Sentinel */ }
294 };
295 MODULE_DEVICE_TABLE(of, sun4i_csi_of_match);
296 
297 static int __maybe_unused sun4i_csi_runtime_resume(struct device *dev)
298 {
299 	struct sun4i_csi *csi = dev_get_drvdata(dev);
300 
301 	reset_control_deassert(csi->rst);
302 	clk_prepare_enable(csi->bus_clk);
303 	clk_prepare_enable(csi->ram_clk);
304 	clk_set_rate(csi->isp_clk, 80000000);
305 	clk_prepare_enable(csi->isp_clk);
306 
307 	writel(1, csi->regs + CSI_EN_REG);
308 
309 	return 0;
310 }
311 
312 static int __maybe_unused sun4i_csi_runtime_suspend(struct device *dev)
313 {
314 	struct sun4i_csi *csi = dev_get_drvdata(dev);
315 
316 	clk_disable_unprepare(csi->isp_clk);
317 	clk_disable_unprepare(csi->ram_clk);
318 	clk_disable_unprepare(csi->bus_clk);
319 
320 	reset_control_assert(csi->rst);
321 
322 	return 0;
323 }
324 
325 static const struct dev_pm_ops sun4i_csi_pm_ops = {
326 	SET_RUNTIME_PM_OPS(sun4i_csi_runtime_suspend,
327 			   sun4i_csi_runtime_resume,
328 			   NULL)
329 };
330 
331 static struct platform_driver sun4i_csi_driver = {
332 	.probe	= sun4i_csi_probe,
333 	.remove	= sun4i_csi_remove,
334 	.driver	= {
335 		.name		= "sun4i-csi",
336 		.of_match_table	= sun4i_csi_of_match,
337 		.pm		= &sun4i_csi_pm_ops,
338 	},
339 };
340 module_platform_driver(sun4i_csi_driver);
341 
342 MODULE_DESCRIPTION("Allwinner A10 Camera Sensor Interface driver");
343 MODULE_AUTHOR("Maxime Ripard <mripard@kernel.org>");
344 MODULE_LICENSE("GPL");
345