1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021 Renesas Electronics Corp.
4  *
5  * Driver for Renesas R-Car ISP Channel Selector
6  *
7  * The ISP hardware is capable of more than just channel selection, features
8  * such as demosaicing, white balance control and color space conversion are
9  * also possible. These more advanced features are not supported by the driver
10  * due to lack of documentation.
11  */
12 
13 #include <linux/module.h>
14 #include <linux/mutex.h>
15 #include <linux/of_device.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/reset.h>
19 
20 #include <media/mipi-csi2.h>
21 #include <media/v4l2-subdev.h>
22 
23 #define ISPINPUTSEL0_REG				0x0008
24 #define ISPINPUTSEL0_SEL_CSI0				BIT(31)
25 
26 #define ISPSTART_REG					0x0014
27 #define ISPSTART_START					0xffff
28 #define ISPSTART_STOP					0x0000
29 
30 #define ISPPROCMODE_DT_REG(n)				(0x1100 + (0x4 * (n)))
31 #define ISPPROCMODE_DT_PROC_MODE_VC3(pm)		(((pm) & 0x3f) << 24)
32 #define ISPPROCMODE_DT_PROC_MODE_VC2(pm)		(((pm) & 0x3f) << 16)
33 #define ISPPROCMODE_DT_PROC_MODE_VC1(pm)		(((pm) & 0x3f) << 8)
34 #define ISPPROCMODE_DT_PROC_MODE_VC0(pm)		((pm) & 0x3f)
35 
36 #define ISPCS_FILTER_ID_CH_REG(n)			(0x3000 + (0x0100 * (n)))
37 
38 #define ISPCS_DT_CODE03_CH_REG(n)			(0x3008 + (0x100 * (n)))
39 #define ISPCS_DT_CODE03_EN3				BIT(31)
40 #define ISPCS_DT_CODE03_DT3(dt)				(((dt) & 0x3f) << 24)
41 #define ISPCS_DT_CODE03_EN2				BIT(23)
42 #define ISPCS_DT_CODE03_DT2(dt)				(((dt) & 0x3f) << 16)
43 #define ISPCS_DT_CODE03_EN1				BIT(15)
44 #define ISPCS_DT_CODE03_DT1(dt)				(((dt) & 0x3f) << 8)
45 #define ISPCS_DT_CODE03_EN0				BIT(7)
46 #define ISPCS_DT_CODE03_DT0(dt)				((dt) & 0x3f)
47 
48 struct rcar_isp_format {
49 	u32 code;
50 	unsigned int datatype;
51 	unsigned int procmode;
52 };
53 
54 static const struct rcar_isp_format rcar_isp_formats[] = {
55 	{
56 		.code = MEDIA_BUS_FMT_RGB888_1X24,
57 		.datatype = MIPI_CSI2_DT_RGB888,
58 		.procmode = 0x15
59 	}, {
60 		.code = MEDIA_BUS_FMT_Y10_1X10,
61 		.datatype = MIPI_CSI2_DT_RAW10,
62 		.procmode = 0x10,
63 	}, {
64 		.code = MEDIA_BUS_FMT_UYVY8_1X16,
65 		.datatype = MIPI_CSI2_DT_YUV422_8B,
66 		.procmode = 0x0c,
67 	}, {
68 		.code = MEDIA_BUS_FMT_YUYV8_1X16,
69 		.datatype = MIPI_CSI2_DT_YUV422_8B,
70 		.procmode = 0x0c,
71 	}, {
72 		.code = MEDIA_BUS_FMT_UYVY8_2X8,
73 		.datatype = MIPI_CSI2_DT_YUV422_8B,
74 		.procmode = 0x0c,
75 	}, {
76 		.code = MEDIA_BUS_FMT_YUYV10_2X10,
77 		.datatype = MIPI_CSI2_DT_YUV422_8B,
78 		.procmode = 0x0c,
79 	},
80 };
81 
82 static const struct rcar_isp_format *risp_code_to_fmt(unsigned int code)
83 {
84 	unsigned int i;
85 
86 	for (i = 0; i < ARRAY_SIZE(rcar_isp_formats); i++) {
87 		if (rcar_isp_formats[i].code == code)
88 			return &rcar_isp_formats[i];
89 	}
90 
91 	return NULL;
92 }
93 
94 enum rcar_isp_input {
95 	RISP_CSI_INPUT0,
96 	RISP_CSI_INPUT1,
97 };
98 
99 enum rcar_isp_pads {
100 	RCAR_ISP_SINK,
101 	RCAR_ISP_PORT0,
102 	RCAR_ISP_PORT1,
103 	RCAR_ISP_PORT2,
104 	RCAR_ISP_PORT3,
105 	RCAR_ISP_PORT4,
106 	RCAR_ISP_PORT5,
107 	RCAR_ISP_PORT6,
108 	RCAR_ISP_PORT7,
109 	RCAR_ISP_NUM_PADS,
110 };
111 
112 struct rcar_isp {
113 	struct device *dev;
114 	void __iomem *base;
115 	struct reset_control *rstc;
116 
117 	enum rcar_isp_input csi_input;
118 
119 	struct v4l2_subdev subdev;
120 	struct media_pad pads[RCAR_ISP_NUM_PADS];
121 
122 	struct v4l2_async_notifier notifier;
123 	struct v4l2_subdev *remote;
124 
125 	struct mutex lock; /* Protects mf and stream_count. */
126 	struct v4l2_mbus_framefmt mf;
127 	int stream_count;
128 };
129 
130 static inline struct rcar_isp *sd_to_isp(struct v4l2_subdev *sd)
131 {
132 	return container_of(sd, struct rcar_isp, subdev);
133 }
134 
135 static inline struct rcar_isp *notifier_to_isp(struct v4l2_async_notifier *n)
136 {
137 	return container_of(n, struct rcar_isp, notifier);
138 }
139 
140 static void risp_write(struct rcar_isp *isp, u32 offset, u32 value)
141 {
142 	iowrite32(value, isp->base + offset);
143 }
144 
145 static u32 risp_read(struct rcar_isp *isp, u32 offset)
146 {
147 	return ioread32(isp->base + offset);
148 }
149 
150 static int risp_power_on(struct rcar_isp *isp)
151 {
152 	int ret;
153 
154 	ret = pm_runtime_resume_and_get(isp->dev);
155 	if (ret < 0)
156 		return ret;
157 
158 	ret = reset_control_deassert(isp->rstc);
159 	if (ret < 0) {
160 		pm_runtime_put(isp->dev);
161 		return ret;
162 	}
163 
164 	return 0;
165 }
166 
167 static void risp_power_off(struct rcar_isp *isp)
168 {
169 	reset_control_assert(isp->rstc);
170 	pm_runtime_put(isp->dev);
171 }
172 
173 static int risp_start(struct rcar_isp *isp)
174 {
175 	const struct rcar_isp_format *format;
176 	unsigned int vc;
177 	u32 sel_csi = 0;
178 	int ret;
179 
180 	format = risp_code_to_fmt(isp->mf.code);
181 	if (!format) {
182 		dev_err(isp->dev, "Unsupported bus format\n");
183 		return -EINVAL;
184 	}
185 
186 	ret = risp_power_on(isp);
187 	if (ret) {
188 		dev_err(isp->dev, "Failed to power on ISP\n");
189 		return ret;
190 	}
191 
192 	/* Select CSI-2 input source. */
193 	if (isp->csi_input == RISP_CSI_INPUT1)
194 		sel_csi = ISPINPUTSEL0_SEL_CSI0;
195 
196 	risp_write(isp, ISPINPUTSEL0_REG,
197 		   risp_read(isp, ISPINPUTSEL0_REG) | sel_csi);
198 
199 	/* Configure Channel Selector. */
200 	for (vc = 0; vc < 4; vc++) {
201 		u8 ch = vc + 4;
202 		u8 dt = format->datatype;
203 
204 		risp_write(isp, ISPCS_FILTER_ID_CH_REG(ch), BIT(vc));
205 		risp_write(isp, ISPCS_DT_CODE03_CH_REG(ch),
206 			   ISPCS_DT_CODE03_EN3 | ISPCS_DT_CODE03_DT3(dt) |
207 			   ISPCS_DT_CODE03_EN2 | ISPCS_DT_CODE03_DT2(dt) |
208 			   ISPCS_DT_CODE03_EN1 | ISPCS_DT_CODE03_DT1(dt) |
209 			   ISPCS_DT_CODE03_EN0 | ISPCS_DT_CODE03_DT0(dt));
210 	}
211 
212 	/* Setup processing method. */
213 	risp_write(isp, ISPPROCMODE_DT_REG(format->datatype),
214 		   ISPPROCMODE_DT_PROC_MODE_VC3(format->procmode) |
215 		   ISPPROCMODE_DT_PROC_MODE_VC2(format->procmode) |
216 		   ISPPROCMODE_DT_PROC_MODE_VC1(format->procmode) |
217 		   ISPPROCMODE_DT_PROC_MODE_VC0(format->procmode));
218 
219 	/* Start ISP. */
220 	risp_write(isp, ISPSTART_REG, ISPSTART_START);
221 
222 	ret = v4l2_subdev_call(isp->remote, video, s_stream, 1);
223 	if (ret)
224 		risp_power_off(isp);
225 
226 	return ret;
227 }
228 
229 static void risp_stop(struct rcar_isp *isp)
230 {
231 	v4l2_subdev_call(isp->remote, video, s_stream, 0);
232 
233 	/* Stop ISP. */
234 	risp_write(isp, ISPSTART_REG, ISPSTART_STOP);
235 
236 	risp_power_off(isp);
237 }
238 
239 static int risp_s_stream(struct v4l2_subdev *sd, int enable)
240 {
241 	struct rcar_isp *isp = sd_to_isp(sd);
242 	int ret = 0;
243 
244 	mutex_lock(&isp->lock);
245 
246 	if (!isp->remote) {
247 		ret = -ENODEV;
248 		goto out;
249 	}
250 
251 	if (enable && isp->stream_count == 0) {
252 		ret = risp_start(isp);
253 		if (ret)
254 			goto out;
255 	} else if (!enable && isp->stream_count == 1) {
256 		risp_stop(isp);
257 	}
258 
259 	isp->stream_count += enable ? 1 : -1;
260 out:
261 	mutex_unlock(&isp->lock);
262 
263 	return ret;
264 }
265 
266 static const struct v4l2_subdev_video_ops risp_video_ops = {
267 	.s_stream = risp_s_stream,
268 };
269 
270 static int risp_set_pad_format(struct v4l2_subdev *sd,
271 			       struct v4l2_subdev_state *sd_state,
272 			       struct v4l2_subdev_format *format)
273 {
274 	struct rcar_isp *isp = sd_to_isp(sd);
275 	struct v4l2_mbus_framefmt *framefmt;
276 
277 	mutex_lock(&isp->lock);
278 
279 	if (!risp_code_to_fmt(format->format.code))
280 		format->format.code = rcar_isp_formats[0].code;
281 
282 	if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
283 		isp->mf = format->format;
284 	} else {
285 		framefmt = v4l2_subdev_get_try_format(sd, sd_state, 0);
286 		*framefmt = format->format;
287 	}
288 
289 	mutex_unlock(&isp->lock);
290 
291 	return 0;
292 }
293 
294 static int risp_get_pad_format(struct v4l2_subdev *sd,
295 			       struct v4l2_subdev_state *sd_state,
296 			       struct v4l2_subdev_format *format)
297 {
298 	struct rcar_isp *isp = sd_to_isp(sd);
299 
300 	mutex_lock(&isp->lock);
301 
302 	if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE)
303 		format->format = isp->mf;
304 	else
305 		format->format = *v4l2_subdev_get_try_format(sd, sd_state, 0);
306 
307 	mutex_unlock(&isp->lock);
308 
309 	return 0;
310 }
311 
312 static const struct v4l2_subdev_pad_ops risp_pad_ops = {
313 	.set_fmt = risp_set_pad_format,
314 	.get_fmt = risp_get_pad_format,
315 	.link_validate = v4l2_subdev_link_validate_default,
316 };
317 
318 static const struct v4l2_subdev_ops rcar_isp_subdev_ops = {
319 	.video	= &risp_video_ops,
320 	.pad	= &risp_pad_ops,
321 };
322 
323 /* -----------------------------------------------------------------------------
324  * Async handling and registration of subdevices and links
325  */
326 
327 static int risp_notify_bound(struct v4l2_async_notifier *notifier,
328 			     struct v4l2_subdev *subdev,
329 			     struct v4l2_async_subdev *asd)
330 {
331 	struct rcar_isp *isp = notifier_to_isp(notifier);
332 	int pad;
333 
334 	pad = media_entity_get_fwnode_pad(&subdev->entity, asd->match.fwnode,
335 					  MEDIA_PAD_FL_SOURCE);
336 	if (pad < 0) {
337 		dev_err(isp->dev, "Failed to find pad for %s\n", subdev->name);
338 		return pad;
339 	}
340 
341 	isp->remote = subdev;
342 
343 	dev_dbg(isp->dev, "Bound %s pad: %d\n", subdev->name, pad);
344 
345 	return media_create_pad_link(&subdev->entity, pad,
346 				     &isp->subdev.entity, 0,
347 				     MEDIA_LNK_FL_ENABLED |
348 				     MEDIA_LNK_FL_IMMUTABLE);
349 }
350 
351 static void risp_notify_unbind(struct v4l2_async_notifier *notifier,
352 			       struct v4l2_subdev *subdev,
353 			       struct v4l2_async_subdev *asd)
354 {
355 	struct rcar_isp *isp = notifier_to_isp(notifier);
356 
357 	isp->remote = NULL;
358 
359 	dev_dbg(isp->dev, "Unbind %s\n", subdev->name);
360 }
361 
362 static const struct v4l2_async_notifier_operations risp_notify_ops = {
363 	.bound = risp_notify_bound,
364 	.unbind = risp_notify_unbind,
365 };
366 
367 static int risp_parse_dt(struct rcar_isp *isp)
368 {
369 	struct v4l2_async_subdev *asd;
370 	struct fwnode_handle *fwnode;
371 	struct fwnode_handle *ep;
372 	unsigned int id;
373 	int ret;
374 
375 	for (id = 0; id < 2; id++) {
376 		ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(isp->dev),
377 						     0, id, 0);
378 		if (ep)
379 			break;
380 	}
381 
382 	if (!ep) {
383 		dev_err(isp->dev, "Not connected to subdevice\n");
384 		return -EINVAL;
385 	}
386 
387 	if (id == 1)
388 		isp->csi_input = RISP_CSI_INPUT1;
389 
390 	fwnode = fwnode_graph_get_remote_endpoint(ep);
391 	fwnode_handle_put(ep);
392 
393 	dev_dbg(isp->dev, "Found '%pOF'\n", to_of_node(fwnode));
394 
395 	v4l2_async_nf_init(&isp->notifier);
396 	isp->notifier.ops = &risp_notify_ops;
397 
398 	asd = v4l2_async_nf_add_fwnode(&isp->notifier, fwnode,
399 				       struct v4l2_async_subdev);
400 	fwnode_handle_put(fwnode);
401 	if (IS_ERR(asd))
402 		return PTR_ERR(asd);
403 
404 	ret = v4l2_async_subdev_nf_register(&isp->subdev, &isp->notifier);
405 	if (ret)
406 		v4l2_async_nf_cleanup(&isp->notifier);
407 
408 	return ret;
409 }
410 
411 /* -----------------------------------------------------------------------------
412  * Platform Device Driver
413  */
414 
415 static const struct media_entity_operations risp_entity_ops = {
416 	.link_validate = v4l2_subdev_link_validate,
417 };
418 
419 static int risp_probe_resources(struct rcar_isp *isp,
420 				struct platform_device *pdev)
421 {
422 	struct resource *res;
423 
424 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
425 	isp->base = devm_ioremap_resource(&pdev->dev, res);
426 	if (IS_ERR(isp->base))
427 		return PTR_ERR(isp->base);
428 
429 	isp->rstc = devm_reset_control_get(&pdev->dev, NULL);
430 
431 	return PTR_ERR_OR_ZERO(isp->rstc);
432 }
433 
434 static const struct of_device_id risp_of_id_table[] = {
435 	{ .compatible = "renesas,r8a779a0-isp" },
436 	{ /* sentinel */ },
437 };
438 MODULE_DEVICE_TABLE(of, risp_of_id_table);
439 
440 static int risp_probe(struct platform_device *pdev)
441 {
442 	struct rcar_isp *isp;
443 	unsigned int i;
444 	int ret;
445 
446 	isp = devm_kzalloc(&pdev->dev, sizeof(*isp), GFP_KERNEL);
447 	if (!isp)
448 		return -ENOMEM;
449 
450 	isp->dev = &pdev->dev;
451 
452 	mutex_init(&isp->lock);
453 
454 	ret = risp_probe_resources(isp, pdev);
455 	if (ret) {
456 		dev_err(isp->dev, "Failed to get resources\n");
457 		goto error_mutex;
458 	}
459 
460 	platform_set_drvdata(pdev, isp);
461 
462 	pm_runtime_enable(&pdev->dev);
463 
464 	ret = risp_parse_dt(isp);
465 	if (ret)
466 		goto error_pm;
467 
468 	isp->subdev.owner = THIS_MODULE;
469 	isp->subdev.dev = &pdev->dev;
470 	v4l2_subdev_init(&isp->subdev, &rcar_isp_subdev_ops);
471 	v4l2_set_subdevdata(&isp->subdev, &pdev->dev);
472 	snprintf(isp->subdev.name, V4L2_SUBDEV_NAME_SIZE, "%s %s",
473 		 KBUILD_MODNAME, dev_name(&pdev->dev));
474 	isp->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
475 
476 	isp->subdev.entity.function = MEDIA_ENT_F_VID_MUX;
477 	isp->subdev.entity.ops = &risp_entity_ops;
478 
479 	isp->pads[RCAR_ISP_SINK].flags = MEDIA_PAD_FL_SINK;
480 	for (i = RCAR_ISP_PORT0; i < RCAR_ISP_NUM_PADS; i++)
481 		isp->pads[i].flags = MEDIA_PAD_FL_SOURCE;
482 
483 	ret = media_entity_pads_init(&isp->subdev.entity, RCAR_ISP_NUM_PADS,
484 				     isp->pads);
485 	if (ret)
486 		goto error_notifier;
487 
488 	ret = v4l2_async_register_subdev(&isp->subdev);
489 	if (ret < 0)
490 		goto error_notifier;
491 
492 	dev_info(isp->dev, "Using CSI-2 input: %u\n", isp->csi_input);
493 
494 	return 0;
495 error_notifier:
496 	v4l2_async_nf_unregister(&isp->notifier);
497 	v4l2_async_nf_cleanup(&isp->notifier);
498 error_pm:
499 	pm_runtime_disable(&pdev->dev);
500 error_mutex:
501 	mutex_destroy(&isp->lock);
502 
503 	return ret;
504 }
505 
506 static int risp_remove(struct platform_device *pdev)
507 {
508 	struct rcar_isp *isp = platform_get_drvdata(pdev);
509 
510 	v4l2_async_nf_unregister(&isp->notifier);
511 	v4l2_async_nf_cleanup(&isp->notifier);
512 
513 	v4l2_async_unregister_subdev(&isp->subdev);
514 
515 	pm_runtime_disable(&pdev->dev);
516 
517 	mutex_destroy(&isp->lock);
518 
519 	return 0;
520 }
521 
522 static struct platform_driver rcar_isp_driver = {
523 	.driver = {
524 		.name = "rcar-isp",
525 		.of_match_table = risp_of_id_table,
526 	},
527 	.probe = risp_probe,
528 	.remove = risp_remove,
529 };
530 
531 module_platform_driver(rcar_isp_driver);
532 
533 MODULE_AUTHOR("Niklas Söderlund <niklas.soderlund@ragnatech.se>");
534 MODULE_DESCRIPTION("Renesas R-Car ISP Channel Selector driver");
535 MODULE_LICENSE("GPL");
536