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