1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT)
2 /*
3 * Rockchip ISP1 Driver - Base driver
4 *
5 * Copyright (C) 2019 Collabora, Ltd.
6 *
7 * Based on Rockchip ISP1 driver by Rockchip Electronics Co., Ltd.
8 * Copyright (C) 2017 Rockchip Electronics Co., Ltd.
9 */
10
11 #include <linux/clk.h>
12 #include <linux/debugfs.h>
13 #include <linux/interrupt.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_graph.h>
17 #include <linux/of_platform.h>
18 #include <linux/pinctrl/consumer.h>
19 #include <linux/phy/phy.h>
20 #include <linux/phy/phy-mipi-dphy.h>
21 #include <media/v4l2-fwnode.h>
22
23 #include "rkisp1-common.h"
24
25 /*
26 * ISP Details
27 * -----------
28 *
29 * ISP Comprises with:
30 * MIPI serial camera interface
31 * Image Signal Processing
32 * Many Image Enhancement Blocks
33 * Crop
34 * Resizer
35 * RBG display ready image
36 * Image Rotation
37 *
38 * ISP Block Diagram
39 * -----------------
40 * rkisp1-resizer.c rkisp1-capture.c
41 * |====================| |=======================|
42 * rkisp1-isp.c Main Picture Path
43 * |==========================| |===============================================|
44 * +-----------+ +--+--+--+--+ +--------+ +--------+ +-----------+
45 * | | | | | | | | | | | | |
46 * +--------+ |\ | | | | | | | -->| Crop |->| RSZ |------------->| |
47 * | MIPI |--->| \ | | | | | | | | | | | | | |
48 * +--------+ | | | | |IE|IE|IE|IE| | +--------+ +--------+ | Memory |
49 * |MUX|--->| ISP |->|0 |1 |2 |3 |---+ | Interface |
50 * +--------+ | | | | | | | | | | +--------+ +--------+ +--------+ | |
51 * |Parallel|--->| / | | | | | | | | | | | | | | | |
52 * +--------+ |/ | | | | | | | -->| Crop |->| RSZ |->| RGB |->| |
53 * | | | | | | | | | | | | Rotate | | |
54 * +-----------+ +--+--+--+--+ +--------+ +--------+ +--------+ +-----------+
55 * ^
56 * +--------+ | |===============================================|
57 * | DMA |------------------------------------+ Self Picture Path
58 * +--------+
59 *
60 * rkisp1-stats.c rkisp1-params.c
61 * |===============| |===============|
62 * +---------------+ +---------------+
63 * | | | |
64 * | ISP | | ISP |
65 * | | | |
66 * +---------------+ +---------------+
67 *
68 *
69 * Media Topology
70 * --------------
71 * +----------+ +----------+
72 * | Sensor 2 | | Sensor X |
73 * ------------ ... ------------
74 * | 0 | | 0 |
75 * +----------+ +----------+ +-----------+
76 * \ | | params |
77 * \ | | (output) |
78 * +----------+ \ | +-----------+
79 * | Sensor 1 | v v |
80 * ------------ +------+------+ |
81 * | 0 |----->| 0 | 1 |<---------+
82 * +----------+ |------+------|
83 * | ISP |
84 * |------+------|
85 * +-------------| 2 | 3 |----------+
86 * | +------+------+ |
87 * | | |
88 * v v v
89 * +- ---------+ +-----------+ +-----------+
90 * | 0 | | 0 | | stats |
91 * ------------- ------------- | (capture) |
92 * | Resizer | | Resizer | +-----------+
93 * ------------| ------------|
94 * | 1 | | 1 |
95 * +-----------+ +-----------+
96 * | |
97 * v v
98 * +-----------+ +-----------+
99 * | selfpath | | mainpath |
100 * | (capture) | | (capture) |
101 * +-----------+ +-----------+
102 */
103
104 struct rkisp1_match_data {
105 const char * const *clks;
106 unsigned int size;
107 };
108
109 /* ----------------------------------------------------------------------------
110 * Sensor DT bindings
111 */
112
rkisp1_create_links(struct rkisp1_device * rkisp1)113 static int rkisp1_create_links(struct rkisp1_device *rkisp1)
114 {
115 struct media_entity *source, *sink;
116 unsigned int flags, source_pad;
117 struct v4l2_subdev *sd;
118 unsigned int i;
119 int ret;
120
121 /* sensor links */
122 flags = MEDIA_LNK_FL_ENABLED;
123 list_for_each_entry(sd, &rkisp1->v4l2_dev.subdevs, list) {
124 if (sd == &rkisp1->isp.sd ||
125 sd == &rkisp1->resizer_devs[RKISP1_MAINPATH].sd ||
126 sd == &rkisp1->resizer_devs[RKISP1_SELFPATH].sd)
127 continue;
128
129 ret = media_entity_get_fwnode_pad(&sd->entity, sd->fwnode,
130 MEDIA_PAD_FL_SOURCE);
131 if (ret < 0) {
132 dev_err(rkisp1->dev, "failed to find src pad for %s\n",
133 sd->name);
134 return ret;
135 }
136 source_pad = ret;
137
138 ret = media_create_pad_link(&sd->entity, source_pad,
139 &rkisp1->isp.sd.entity,
140 RKISP1_ISP_PAD_SINK_VIDEO,
141 flags);
142 if (ret)
143 return ret;
144
145 flags = 0;
146 }
147
148 flags = MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE;
149
150 /* create ISP->RSZ->CAP links */
151 for (i = 0; i < 2; i++) {
152 source = &rkisp1->isp.sd.entity;
153 sink = &rkisp1->resizer_devs[i].sd.entity;
154 ret = media_create_pad_link(source, RKISP1_ISP_PAD_SOURCE_VIDEO,
155 sink, RKISP1_RSZ_PAD_SINK,
156 MEDIA_LNK_FL_ENABLED);
157 if (ret)
158 return ret;
159
160 source = sink;
161 sink = &rkisp1->capture_devs[i].vnode.vdev.entity;
162 ret = media_create_pad_link(source, RKISP1_RSZ_PAD_SRC,
163 sink, 0, flags);
164 if (ret)
165 return ret;
166 }
167
168 /* params links */
169 source = &rkisp1->params.vnode.vdev.entity;
170 sink = &rkisp1->isp.sd.entity;
171 ret = media_create_pad_link(source, 0, sink,
172 RKISP1_ISP_PAD_SINK_PARAMS, flags);
173 if (ret)
174 return ret;
175
176 /* 3A stats links */
177 source = &rkisp1->isp.sd.entity;
178 sink = &rkisp1->stats.vnode.vdev.entity;
179 return media_create_pad_link(source, RKISP1_ISP_PAD_SOURCE_STATS,
180 sink, 0, flags);
181 }
182
rkisp1_subdev_notifier_bound(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct v4l2_async_subdev * asd)183 static int rkisp1_subdev_notifier_bound(struct v4l2_async_notifier *notifier,
184 struct v4l2_subdev *sd,
185 struct v4l2_async_subdev *asd)
186 {
187 struct rkisp1_device *rkisp1 =
188 container_of(notifier, struct rkisp1_device, notifier);
189 struct rkisp1_sensor_async *s_asd =
190 container_of(asd, struct rkisp1_sensor_async, asd);
191
192 s_asd->pixel_rate_ctrl = v4l2_ctrl_find(sd->ctrl_handler,
193 V4L2_CID_PIXEL_RATE);
194 s_asd->sd = sd;
195 s_asd->dphy = devm_phy_get(rkisp1->dev, "dphy");
196 if (IS_ERR(s_asd->dphy)) {
197 if (PTR_ERR(s_asd->dphy) != -EPROBE_DEFER)
198 dev_err(rkisp1->dev, "Couldn't get the MIPI D-PHY\n");
199 return PTR_ERR(s_asd->dphy);
200 }
201
202 phy_init(s_asd->dphy);
203
204 return 0;
205 }
206
rkisp1_subdev_notifier_unbind(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct v4l2_async_subdev * asd)207 static void rkisp1_subdev_notifier_unbind(struct v4l2_async_notifier *notifier,
208 struct v4l2_subdev *sd,
209 struct v4l2_async_subdev *asd)
210 {
211 struct rkisp1_sensor_async *s_asd =
212 container_of(asd, struct rkisp1_sensor_async, asd);
213
214 phy_exit(s_asd->dphy);
215 }
216
rkisp1_subdev_notifier_complete(struct v4l2_async_notifier * notifier)217 static int rkisp1_subdev_notifier_complete(struct v4l2_async_notifier *notifier)
218 {
219 struct rkisp1_device *rkisp1 =
220 container_of(notifier, struct rkisp1_device, notifier);
221 int ret;
222
223 ret = rkisp1_create_links(rkisp1);
224 if (ret)
225 return ret;
226
227 ret = v4l2_device_register_subdev_nodes(&rkisp1->v4l2_dev);
228 if (ret)
229 return ret;
230
231 dev_dbg(rkisp1->dev, "Async subdev notifier completed\n");
232
233 return 0;
234 }
235
236 static const struct v4l2_async_notifier_operations rkisp1_subdev_notifier_ops = {
237 .bound = rkisp1_subdev_notifier_bound,
238 .unbind = rkisp1_subdev_notifier_unbind,
239 .complete = rkisp1_subdev_notifier_complete,
240 };
241
rkisp1_subdev_notifier(struct rkisp1_device * rkisp1)242 static int rkisp1_subdev_notifier(struct rkisp1_device *rkisp1)
243 {
244 struct v4l2_async_notifier *ntf = &rkisp1->notifier;
245 unsigned int next_id = 0;
246 int ret;
247
248 v4l2_async_notifier_init(ntf);
249
250 while (1) {
251 struct v4l2_fwnode_endpoint vep = {
252 .bus_type = V4L2_MBUS_CSI2_DPHY
253 };
254 struct rkisp1_sensor_async *rk_asd = NULL;
255 struct fwnode_handle *ep;
256
257 ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(rkisp1->dev),
258 0, next_id, FWNODE_GRAPH_ENDPOINT_NEXT);
259 if (!ep)
260 break;
261
262 ret = v4l2_fwnode_endpoint_parse(ep, &vep);
263 if (ret)
264 goto err_parse;
265
266 rk_asd = kzalloc(sizeof(*rk_asd), GFP_KERNEL);
267 if (!rk_asd) {
268 ret = -ENOMEM;
269 goto err_parse;
270 }
271
272 rk_asd->mbus_type = vep.bus_type;
273 rk_asd->mbus_flags = vep.bus.mipi_csi2.flags;
274 rk_asd->lanes = vep.bus.mipi_csi2.num_data_lanes;
275
276 ret = v4l2_async_notifier_add_fwnode_remote_subdev(ntf, ep,
277 &rk_asd->asd);
278 if (ret)
279 goto err_parse;
280
281 dev_dbg(rkisp1->dev, "registered ep id %d with %d lanes\n",
282 vep.base.id, rk_asd->lanes);
283
284 next_id = vep.base.id + 1;
285
286 fwnode_handle_put(ep);
287
288 continue;
289 err_parse:
290 fwnode_handle_put(ep);
291 kfree(rk_asd);
292 v4l2_async_notifier_cleanup(ntf);
293 return ret;
294 }
295
296 if (next_id == 0)
297 dev_dbg(rkisp1->dev, "no remote subdevice found\n");
298 ntf->ops = &rkisp1_subdev_notifier_ops;
299 ret = v4l2_async_notifier_register(&rkisp1->v4l2_dev, ntf);
300 if (ret) {
301 v4l2_async_notifier_cleanup(ntf);
302 return ret;
303 }
304 return 0;
305 }
306
307 /* ----------------------------------------------------------------------------
308 * Power
309 */
310
rkisp1_runtime_suspend(struct device * dev)311 static int __maybe_unused rkisp1_runtime_suspend(struct device *dev)
312 {
313 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev);
314
315 clk_bulk_disable_unprepare(rkisp1->clk_size, rkisp1->clks);
316 return pinctrl_pm_select_sleep_state(dev);
317 }
318
rkisp1_runtime_resume(struct device * dev)319 static int __maybe_unused rkisp1_runtime_resume(struct device *dev)
320 {
321 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev);
322 int ret;
323
324 ret = pinctrl_pm_select_default_state(dev);
325 if (ret)
326 return ret;
327 ret = clk_bulk_prepare_enable(rkisp1->clk_size, rkisp1->clks);
328 if (ret)
329 return ret;
330
331 return 0;
332 }
333
334 static const struct dev_pm_ops rkisp1_pm_ops = {
335 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
336 pm_runtime_force_resume)
337 SET_RUNTIME_PM_OPS(rkisp1_runtime_suspend, rkisp1_runtime_resume, NULL)
338 };
339
340 /* ----------------------------------------------------------------------------
341 * Core
342 */
343
rkisp1_entities_register(struct rkisp1_device * rkisp1)344 static int rkisp1_entities_register(struct rkisp1_device *rkisp1)
345 {
346 int ret;
347
348 ret = rkisp1_isp_register(rkisp1);
349 if (ret)
350 return ret;
351
352 ret = rkisp1_resizer_devs_register(rkisp1);
353 if (ret)
354 goto err_unreg_isp_subdev;
355
356 ret = rkisp1_capture_devs_register(rkisp1);
357 if (ret)
358 goto err_unreg_resizer_devs;
359
360 ret = rkisp1_stats_register(rkisp1);
361 if (ret)
362 goto err_unreg_capture_devs;
363
364 ret = rkisp1_params_register(rkisp1);
365 if (ret)
366 goto err_unreg_stats;
367
368 ret = rkisp1_subdev_notifier(rkisp1);
369 if (ret) {
370 dev_err(rkisp1->dev,
371 "Failed to register subdev notifier(%d)\n", ret);
372 goto err_unreg_params;
373 }
374
375 return 0;
376 err_unreg_params:
377 rkisp1_params_unregister(rkisp1);
378 err_unreg_stats:
379 rkisp1_stats_unregister(rkisp1);
380 err_unreg_capture_devs:
381 rkisp1_capture_devs_unregister(rkisp1);
382 err_unreg_resizer_devs:
383 rkisp1_resizer_devs_unregister(rkisp1);
384 err_unreg_isp_subdev:
385 rkisp1_isp_unregister(rkisp1);
386 return ret;
387 }
388
rkisp1_isr(int irq,void * ctx)389 static irqreturn_t rkisp1_isr(int irq, void *ctx)
390 {
391 struct device *dev = ctx;
392 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev);
393
394 /*
395 * Call rkisp1_capture_isr() first to handle the frame that
396 * potentially completed using the current frame_sequence number before
397 * it is potentially incremented by rkisp1_isp_isr() in the vertical
398 * sync.
399 */
400 rkisp1_capture_isr(rkisp1);
401 rkisp1_isp_isr(rkisp1);
402 rkisp1_mipi_isr(rkisp1);
403
404 return IRQ_HANDLED;
405 }
406
407 static const char * const rk3399_isp_clks[] = {
408 "clk_isp",
409 "aclk_isp",
410 "hclk_isp",
411 "aclk_isp_wrap",
412 "hclk_isp_wrap",
413 };
414
415 static const struct rkisp1_match_data rk3399_isp_clk_data = {
416 .clks = rk3399_isp_clks,
417 .size = ARRAY_SIZE(rk3399_isp_clks),
418 };
419
420 static const struct of_device_id rkisp1_of_match[] = {
421 {
422 .compatible = "rockchip,rk3399-cif-isp",
423 .data = &rk3399_isp_clk_data,
424 },
425 {},
426 };
427 MODULE_DEVICE_TABLE(of, rkisp1_of_match);
428
rkisp1_debug_init(struct rkisp1_device * rkisp1)429 static void rkisp1_debug_init(struct rkisp1_device *rkisp1)
430 {
431 struct rkisp1_debug *debug = &rkisp1->debug;
432
433 debug->debugfs_dir = debugfs_create_dir(RKISP1_DRIVER_NAME, NULL);
434 if (!debug->debugfs_dir) {
435 dev_dbg(rkisp1->dev, "failed to create debugfs directory\n");
436 return;
437 }
438 debugfs_create_ulong("data_loss", 0444, debug->debugfs_dir,
439 &debug->data_loss);
440 debugfs_create_ulong("outform_size_err", 0444, debug->debugfs_dir,
441 &debug->outform_size_error);
442 debugfs_create_ulong("img_stabilization_size_error", 0444,
443 debug->debugfs_dir,
444 &debug->img_stabilization_size_error);
445 debugfs_create_ulong("inform_size_error", 0444, debug->debugfs_dir,
446 &debug->inform_size_error);
447 debugfs_create_ulong("irq_delay", 0444, debug->debugfs_dir,
448 &debug->irq_delay);
449 debugfs_create_ulong("mipi_error", 0444, debug->debugfs_dir,
450 &debug->mipi_error);
451 debugfs_create_ulong("stats_error", 0444, debug->debugfs_dir,
452 &debug->stats_error);
453 debugfs_create_ulong("mp_stop_timeout", 0444, debug->debugfs_dir,
454 &debug->stop_timeout[RKISP1_MAINPATH]);
455 debugfs_create_ulong("sp_stop_timeout", 0444, debug->debugfs_dir,
456 &debug->stop_timeout[RKISP1_SELFPATH]);
457 debugfs_create_ulong("mp_frame_drop", 0444, debug->debugfs_dir,
458 &debug->frame_drop[RKISP1_MAINPATH]);
459 debugfs_create_ulong("sp_frame_drop", 0444, debug->debugfs_dir,
460 &debug->frame_drop[RKISP1_SELFPATH]);
461 }
462
rkisp1_probe(struct platform_device * pdev)463 static int rkisp1_probe(struct platform_device *pdev)
464 {
465 const struct rkisp1_match_data *clk_data;
466 struct device *dev = &pdev->dev;
467 struct rkisp1_device *rkisp1;
468 struct v4l2_device *v4l2_dev;
469 unsigned int i;
470 int ret, irq;
471
472 clk_data = of_device_get_match_data(&pdev->dev);
473 if (!clk_data)
474 return -ENODEV;
475
476 rkisp1 = devm_kzalloc(dev, sizeof(*rkisp1), GFP_KERNEL);
477 if (!rkisp1)
478 return -ENOMEM;
479
480 dev_set_drvdata(dev, rkisp1);
481 rkisp1->dev = dev;
482
483 mutex_init(&rkisp1->stream_lock);
484
485 rkisp1->base_addr = devm_platform_ioremap_resource(pdev, 0);
486 if (IS_ERR(rkisp1->base_addr))
487 return PTR_ERR(rkisp1->base_addr);
488
489 irq = platform_get_irq(pdev, 0);
490 if (irq < 0)
491 return irq;
492
493 ret = devm_request_irq(dev, irq, rkisp1_isr, IRQF_SHARED,
494 dev_driver_string(dev), dev);
495 if (ret) {
496 dev_err(dev, "request irq failed: %d\n", ret);
497 return ret;
498 }
499
500 rkisp1->irq = irq;
501
502 for (i = 0; i < clk_data->size; i++)
503 rkisp1->clks[i].id = clk_data->clks[i];
504 ret = devm_clk_bulk_get(dev, clk_data->size, rkisp1->clks);
505 if (ret)
506 return ret;
507 rkisp1->clk_size = clk_data->size;
508
509 pm_runtime_enable(&pdev->dev);
510
511 strscpy(rkisp1->media_dev.model, RKISP1_DRIVER_NAME,
512 sizeof(rkisp1->media_dev.model));
513 rkisp1->media_dev.dev = &pdev->dev;
514 strscpy(rkisp1->media_dev.bus_info, RKISP1_BUS_INFO,
515 sizeof(rkisp1->media_dev.bus_info));
516 media_device_init(&rkisp1->media_dev);
517
518 v4l2_dev = &rkisp1->v4l2_dev;
519 v4l2_dev->mdev = &rkisp1->media_dev;
520 strscpy(v4l2_dev->name, RKISP1_DRIVER_NAME, sizeof(v4l2_dev->name));
521
522 ret = v4l2_device_register(rkisp1->dev, &rkisp1->v4l2_dev);
523 if (ret)
524 return ret;
525
526 ret = media_device_register(&rkisp1->media_dev);
527 if (ret) {
528 dev_err(dev, "Failed to register media device: %d\n", ret);
529 goto err_unreg_v4l2_dev;
530 }
531
532 ret = rkisp1_entities_register(rkisp1);
533 if (ret)
534 goto err_unreg_media_dev;
535
536 rkisp1_debug_init(rkisp1);
537
538 return 0;
539
540 err_unreg_media_dev:
541 media_device_unregister(&rkisp1->media_dev);
542 err_unreg_v4l2_dev:
543 v4l2_device_unregister(&rkisp1->v4l2_dev);
544 pm_runtime_disable(&pdev->dev);
545 return ret;
546 }
547
rkisp1_remove(struct platform_device * pdev)548 static int rkisp1_remove(struct platform_device *pdev)
549 {
550 struct rkisp1_device *rkisp1 = platform_get_drvdata(pdev);
551
552 v4l2_async_notifier_unregister(&rkisp1->notifier);
553 v4l2_async_notifier_cleanup(&rkisp1->notifier);
554
555 rkisp1_params_unregister(rkisp1);
556 rkisp1_stats_unregister(rkisp1);
557 rkisp1_capture_devs_unregister(rkisp1);
558 rkisp1_resizer_devs_unregister(rkisp1);
559 rkisp1_isp_unregister(rkisp1);
560
561 media_device_unregister(&rkisp1->media_dev);
562 v4l2_device_unregister(&rkisp1->v4l2_dev);
563
564 pm_runtime_disable(&pdev->dev);
565
566 debugfs_remove_recursive(rkisp1->debug.debugfs_dir);
567 return 0;
568 }
569
570 static struct platform_driver rkisp1_drv = {
571 .driver = {
572 .name = RKISP1_DRIVER_NAME,
573 .of_match_table = of_match_ptr(rkisp1_of_match),
574 .pm = &rkisp1_pm_ops,
575 },
576 .probe = rkisp1_probe,
577 .remove = rkisp1_remove,
578 };
579
580 module_platform_driver(rkisp1_drv);
581 MODULE_DESCRIPTION("Rockchip ISP1 platform driver");
582 MODULE_LICENSE("Dual MIT/GPL");
583