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 enum rkisp1_cif_isp_version isp_ver; 108 }; 109 110 /* ---------------------------------------------------------------------------- 111 * Sensor DT bindings 112 */ 113 114 static 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 /* sensor links */ 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 /* create ISP->RSZ->CAP links */ 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 /* params links */ 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 /* 3A stats links */ 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 184 static 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 208 static 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 218 static 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 237 static 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 243 static 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; 287 err_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 * Power 306 */ 307 308 static 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 316 static 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 331 static 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 * Core 339 */ 340 341 static 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; 373 err_unreg_params: 374 rkisp1_params_unregister(rkisp1); 375 err_unreg_stats: 376 rkisp1_stats_unregister(rkisp1); 377 err_unreg_capture_devs: 378 rkisp1_capture_devs_unregister(rkisp1); 379 err_unreg_resizer_devs: 380 rkisp1_resizer_devs_unregister(rkisp1); 381 err_unreg_isp_subdev: 382 rkisp1_isp_unregister(rkisp1); 383 return ret; 384 } 385 386 static 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 * Call rkisp1_capture_isr() first to handle the frame that 393 * potentially completed using the current frame_sequence number before 394 * it is potentially incremented by rkisp1_isp_isr() in the vertical 395 * sync. 396 */ 397 rkisp1_capture_isr(rkisp1); 398 rkisp1_isp_isr(rkisp1); 399 rkisp1_mipi_isr(rkisp1); 400 401 return IRQ_HANDLED; 402 } 403 404 static const char * const rk3399_isp_clks[] = { 405 "isp", 406 "aclk", 407 "hclk", 408 }; 409 410 static 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 416 static const struct of_device_id rkisp1_of_match[] = { 417 { 418 .compatible = "rockchip,rk3399-cif-isp", 419 .data = &rk3399_isp_match_data, 420 }, 421 {}, 422 }; 423 MODULE_DEVICE_TABLE(of, rkisp1_of_match); 424 425 static 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 455 static 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 533 err_unreg_media_dev: 534 media_device_unregister(&rkisp1->media_dev); 535 err_unreg_v4l2_dev: 536 v4l2_device_unregister(&rkisp1->v4l2_dev); 537 pm_runtime_disable(&pdev->dev); 538 return ret; 539 } 540 541 static 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 563 static 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 573 module_platform_driver(rkisp1_drv); 574 MODULE_DESCRIPTION("Rockchip ISP1 platform driver"); 575 MODULE_LICENSE("Dual MIT/GPL"); 576