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