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/interrupt.h> 13 #include <linux/module.h> 14 #include <linux/of.h> 15 #include <linux/of_graph.h> 16 #include <linux/platform_device.h> 17 #include <linux/pinctrl/consumer.h> 18 #include <linux/pm_runtime.h> 19 #include <media/v4l2-fwnode.h> 20 #include <media/v4l2-mc.h> 21 22 #include "rkisp1-common.h" 23 #include "rkisp1-csi.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 * +----------+ +----------+ 73 * | Sensor 1 | | Sensor X | 74 * ------------ ... ------------ 75 * | 0 | | 0 | 76 * +----------+ +----------+ 77 * | | 78 * \----\ /----/ 79 * | | 80 * v v 81 * +-------------+ 82 * | 0 | 83 * --------------- 84 * | CSI-2 RX | 85 * --------------- +-----------+ 86 * | 1 | | params | 87 * +-------------+ | (output) | 88 * | +-----------+ 89 * v | 90 * +------+------+ | 91 * | 0 | 1 |<---------+ 92 * |------+------| 93 * | ISP | 94 * |------+------| 95 * +-------------| 2 | 3 |----------+ 96 * | +------+------+ | 97 * | | | 98 * v v v 99 * +- ---------+ +-----------+ +-----------+ 100 * | 0 | | 0 | | stats | 101 * ------------- ------------- | (capture) | 102 * | Resizer | | Resizer | +-----------+ 103 * ------------| ------------| 104 * | 1 | | 1 | 105 * +-----------+ +-----------+ 106 * | | 107 * v v 108 * +-----------+ +-----------+ 109 * | selfpath | | mainpath | 110 * | (capture) | | (capture) | 111 * +-----------+ +-----------+ 112 */ 113 114 struct rkisp1_isr_data { 115 const char *name; 116 irqreturn_t (*isr)(int irq, void *ctx); 117 u32 line_mask; 118 }; 119 120 /* ---------------------------------------------------------------------------- 121 * Sensor DT bindings 122 */ 123 124 static int rkisp1_subdev_notifier_bound(struct v4l2_async_notifier *notifier, 125 struct v4l2_subdev *sd, 126 struct v4l2_async_connection *asc) 127 { 128 struct rkisp1_device *rkisp1 = 129 container_of(notifier, struct rkisp1_device, notifier); 130 struct rkisp1_sensor_async *s_asd = 131 container_of(asc, struct rkisp1_sensor_async, asd); 132 int source_pad; 133 int ret; 134 135 s_asd->sd = sd; 136 137 source_pad = media_entity_get_fwnode_pad(&sd->entity, s_asd->source_ep, 138 MEDIA_PAD_FL_SOURCE); 139 if (source_pad < 0) { 140 dev_err(rkisp1->dev, "failed to find source pad for %s\n", 141 sd->name); 142 return source_pad; 143 } 144 145 if (s_asd->port == 0) 146 return rkisp1_csi_link_sensor(rkisp1, sd, s_asd, source_pad); 147 148 ret = media_create_pad_link(&sd->entity, source_pad, 149 &rkisp1->isp.sd.entity, 150 RKISP1_ISP_PAD_SINK_VIDEO, 151 !s_asd->index ? MEDIA_LNK_FL_ENABLED : 0); 152 if (ret) { 153 dev_err(rkisp1->dev, "failed to link source pad of %s\n", 154 sd->name); 155 return ret; 156 } 157 158 return 0; 159 } 160 161 static int rkisp1_subdev_notifier_complete(struct v4l2_async_notifier *notifier) 162 { 163 struct rkisp1_device *rkisp1 = 164 container_of(notifier, struct rkisp1_device, notifier); 165 166 return v4l2_device_register_subdev_nodes(&rkisp1->v4l2_dev); 167 } 168 169 static void rkisp1_subdev_notifier_destroy(struct v4l2_async_connection *asc) 170 { 171 struct rkisp1_sensor_async *rk_asd = 172 container_of(asc, struct rkisp1_sensor_async, asd); 173 174 fwnode_handle_put(rk_asd->source_ep); 175 } 176 177 static const struct v4l2_async_notifier_operations rkisp1_subdev_notifier_ops = { 178 .bound = rkisp1_subdev_notifier_bound, 179 .complete = rkisp1_subdev_notifier_complete, 180 .destroy = rkisp1_subdev_notifier_destroy, 181 }; 182 183 static int rkisp1_subdev_notifier_register(struct rkisp1_device *rkisp1) 184 { 185 struct v4l2_async_notifier *ntf = &rkisp1->notifier; 186 struct fwnode_handle *fwnode = dev_fwnode(rkisp1->dev); 187 struct fwnode_handle *ep; 188 unsigned int index = 0; 189 int ret = 0; 190 191 v4l2_async_nf_init(ntf, &rkisp1->v4l2_dev); 192 193 ntf->ops = &rkisp1_subdev_notifier_ops; 194 195 fwnode_graph_for_each_endpoint(fwnode, ep) { 196 struct fwnode_handle *port; 197 struct v4l2_fwnode_endpoint vep = { }; 198 struct rkisp1_sensor_async *rk_asd; 199 struct fwnode_handle *source; 200 u32 reg = 0; 201 202 /* Select the bus type based on the port. */ 203 port = fwnode_get_parent(ep); 204 fwnode_property_read_u32(port, "reg", ®); 205 fwnode_handle_put(port); 206 207 switch (reg) { 208 case 0: 209 /* MIPI CSI-2 port */ 210 if (!(rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2)) { 211 dev_err(rkisp1->dev, 212 "internal CSI must be available for port 0\n"); 213 ret = -EINVAL; 214 break; 215 } 216 217 vep.bus_type = V4L2_MBUS_CSI2_DPHY; 218 break; 219 220 case 1: 221 /* 222 * Parallel port. The bus-type property in DT is 223 * mandatory for port 1, it will be used to determine if 224 * it's PARALLEL or BT656. 225 */ 226 vep.bus_type = V4L2_MBUS_UNKNOWN; 227 break; 228 } 229 230 /* Parse the endpoint and validate the bus type. */ 231 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 232 if (ret) { 233 dev_err(rkisp1->dev, "failed to parse endpoint %pfw\n", 234 ep); 235 break; 236 } 237 238 if (vep.base.port == 1) { 239 if (vep.bus_type != V4L2_MBUS_PARALLEL && 240 vep.bus_type != V4L2_MBUS_BT656) { 241 dev_err(rkisp1->dev, 242 "port 1 must be parallel or BT656\n"); 243 ret = -EINVAL; 244 break; 245 } 246 } 247 248 /* Add the async subdev to the notifier. */ 249 source = fwnode_graph_get_remote_endpoint(ep); 250 if (!source) { 251 dev_err(rkisp1->dev, 252 "endpoint %pfw has no remote endpoint\n", 253 ep); 254 ret = -ENODEV; 255 break; 256 } 257 258 rk_asd = v4l2_async_nf_add_fwnode(ntf, source, 259 struct rkisp1_sensor_async); 260 if (IS_ERR(rk_asd)) { 261 fwnode_handle_put(source); 262 ret = PTR_ERR(rk_asd); 263 break; 264 } 265 266 rk_asd->index = index++; 267 rk_asd->source_ep = source; 268 rk_asd->mbus_type = vep.bus_type; 269 rk_asd->port = vep.base.port; 270 271 if (vep.bus_type == V4L2_MBUS_CSI2_DPHY) { 272 rk_asd->mbus_flags = vep.bus.mipi_csi2.flags; 273 rk_asd->lanes = vep.bus.mipi_csi2.num_data_lanes; 274 } else { 275 rk_asd->mbus_flags = vep.bus.parallel.flags; 276 } 277 278 dev_dbg(rkisp1->dev, "registered ep id %d, bus type %u, %u lanes\n", 279 vep.base.id, rk_asd->mbus_type, rk_asd->lanes); 280 } 281 282 if (ret) { 283 fwnode_handle_put(ep); 284 v4l2_async_nf_cleanup(ntf); 285 return ret; 286 } 287 288 if (!index) 289 dev_dbg(rkisp1->dev, "no remote subdevice found\n"); 290 291 ret = v4l2_async_nf_register(ntf); 292 if (ret) { 293 v4l2_async_nf_cleanup(ntf); 294 return ret; 295 } 296 297 return 0; 298 } 299 300 /* ---------------------------------------------------------------------------- 301 * Power 302 */ 303 304 static int __maybe_unused rkisp1_runtime_suspend(struct device *dev) 305 { 306 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev); 307 308 rkisp1->irqs_enabled = false; 309 /* Make sure the IRQ handler will see the above */ 310 mb(); 311 312 /* 313 * Wait until any running IRQ handler has returned. The IRQ handler 314 * may get called even after this (as it's a shared interrupt line) 315 * but the 'irqs_enabled' flag will make the handler return immediately. 316 */ 317 for (unsigned int il = 0; il < ARRAY_SIZE(rkisp1->irqs); ++il) { 318 if (rkisp1->irqs[il] == -1) 319 continue; 320 321 /* Skip if the irq line is the same as previous */ 322 if (il == 0 || rkisp1->irqs[il - 1] != rkisp1->irqs[il]) 323 synchronize_irq(rkisp1->irqs[il]); 324 } 325 326 clk_bulk_disable_unprepare(rkisp1->clk_size, rkisp1->clks); 327 return pinctrl_pm_select_sleep_state(dev); 328 } 329 330 static int __maybe_unused rkisp1_runtime_resume(struct device *dev) 331 { 332 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev); 333 int ret; 334 335 ret = pinctrl_pm_select_default_state(dev); 336 if (ret) 337 return ret; 338 ret = clk_bulk_prepare_enable(rkisp1->clk_size, rkisp1->clks); 339 if (ret) 340 return ret; 341 342 rkisp1->irqs_enabled = true; 343 /* Make sure the IRQ handler will see the above */ 344 mb(); 345 346 return 0; 347 } 348 349 static const struct dev_pm_ops rkisp1_pm_ops = { 350 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 351 pm_runtime_force_resume) 352 SET_RUNTIME_PM_OPS(rkisp1_runtime_suspend, rkisp1_runtime_resume, NULL) 353 }; 354 355 /* ---------------------------------------------------------------------------- 356 * Core 357 */ 358 359 static int rkisp1_create_links(struct rkisp1_device *rkisp1) 360 { 361 unsigned int i; 362 int ret; 363 364 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) { 365 /* Link the CSI receiver to the ISP. */ 366 ret = media_create_pad_link(&rkisp1->csi.sd.entity, 367 RKISP1_CSI_PAD_SRC, 368 &rkisp1->isp.sd.entity, 369 RKISP1_ISP_PAD_SINK_VIDEO, 370 MEDIA_LNK_FL_ENABLED); 371 if (ret) 372 return ret; 373 } 374 375 /* create ISP->RSZ->CAP links */ 376 for (i = 0; i < 2; i++) { 377 struct media_entity *resizer = 378 &rkisp1->resizer_devs[i].sd.entity; 379 struct media_entity *capture = 380 &rkisp1->capture_devs[i].vnode.vdev.entity; 381 382 ret = media_create_pad_link(&rkisp1->isp.sd.entity, 383 RKISP1_ISP_PAD_SOURCE_VIDEO, 384 resizer, RKISP1_RSZ_PAD_SINK, 385 MEDIA_LNK_FL_ENABLED); 386 if (ret) 387 return ret; 388 389 ret = media_create_pad_link(resizer, RKISP1_RSZ_PAD_SRC, 390 capture, 0, 391 MEDIA_LNK_FL_ENABLED | 392 MEDIA_LNK_FL_IMMUTABLE); 393 if (ret) 394 return ret; 395 } 396 397 /* params links */ 398 ret = media_create_pad_link(&rkisp1->params.vnode.vdev.entity, 0, 399 &rkisp1->isp.sd.entity, 400 RKISP1_ISP_PAD_SINK_PARAMS, 401 MEDIA_LNK_FL_ENABLED | 402 MEDIA_LNK_FL_IMMUTABLE); 403 if (ret) 404 return ret; 405 406 /* 3A stats links */ 407 return media_create_pad_link(&rkisp1->isp.sd.entity, 408 RKISP1_ISP_PAD_SOURCE_STATS, 409 &rkisp1->stats.vnode.vdev.entity, 0, 410 MEDIA_LNK_FL_ENABLED | 411 MEDIA_LNK_FL_IMMUTABLE); 412 } 413 414 static void rkisp1_entities_unregister(struct rkisp1_device *rkisp1) 415 { 416 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) 417 rkisp1_csi_unregister(rkisp1); 418 rkisp1_params_unregister(rkisp1); 419 rkisp1_stats_unregister(rkisp1); 420 rkisp1_capture_devs_unregister(rkisp1); 421 rkisp1_resizer_devs_unregister(rkisp1); 422 rkisp1_isp_unregister(rkisp1); 423 } 424 425 static int rkisp1_entities_register(struct rkisp1_device *rkisp1) 426 { 427 int ret; 428 429 ret = rkisp1_isp_register(rkisp1); 430 if (ret) 431 goto error; 432 433 ret = rkisp1_resizer_devs_register(rkisp1); 434 if (ret) 435 goto error; 436 437 ret = rkisp1_capture_devs_register(rkisp1); 438 if (ret) 439 goto error; 440 441 ret = rkisp1_stats_register(rkisp1); 442 if (ret) 443 goto error; 444 445 ret = rkisp1_params_register(rkisp1); 446 if (ret) 447 goto error; 448 449 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) { 450 ret = rkisp1_csi_register(rkisp1); 451 if (ret) 452 goto error; 453 } 454 455 ret = rkisp1_create_links(rkisp1); 456 if (ret) 457 goto error; 458 459 return 0; 460 461 error: 462 rkisp1_entities_unregister(rkisp1); 463 return ret; 464 } 465 466 static irqreturn_t rkisp1_isr(int irq, void *ctx) 467 { 468 irqreturn_t ret = IRQ_NONE; 469 470 /* 471 * Call rkisp1_capture_isr() first to handle the frame that 472 * potentially completed using the current frame_sequence number before 473 * it is potentially incremented by rkisp1_isp_isr() in the vertical 474 * sync. 475 */ 476 477 if (rkisp1_capture_isr(irq, ctx) == IRQ_HANDLED) 478 ret = IRQ_HANDLED; 479 480 if (rkisp1_isp_isr(irq, ctx) == IRQ_HANDLED) 481 ret = IRQ_HANDLED; 482 483 if (rkisp1_csi_isr(irq, ctx) == IRQ_HANDLED) 484 ret = IRQ_HANDLED; 485 486 return ret; 487 } 488 489 static const char * const px30_isp_clks[] = { 490 "isp", 491 "aclk", 492 "hclk", 493 "pclk", 494 }; 495 496 static const struct rkisp1_isr_data px30_isp_isrs[] = { 497 { "isp", rkisp1_isp_isr, BIT(RKISP1_IRQ_ISP) }, 498 { "mi", rkisp1_capture_isr, BIT(RKISP1_IRQ_MI) }, 499 { "mipi", rkisp1_csi_isr, BIT(RKISP1_IRQ_MIPI) }, 500 }; 501 502 static const struct rkisp1_info px30_isp_info = { 503 .clks = px30_isp_clks, 504 .clk_size = ARRAY_SIZE(px30_isp_clks), 505 .isrs = px30_isp_isrs, 506 .isr_size = ARRAY_SIZE(px30_isp_isrs), 507 .isp_ver = RKISP1_V12, 508 .features = RKISP1_FEATURE_MIPI_CSI2, 509 }; 510 511 static const char * const rk3399_isp_clks[] = { 512 "isp", 513 "aclk", 514 "hclk", 515 }; 516 517 static const struct rkisp1_isr_data rk3399_isp_isrs[] = { 518 { NULL, rkisp1_isr, BIT(RKISP1_IRQ_ISP) | BIT(RKISP1_IRQ_MI) | BIT(RKISP1_IRQ_MIPI) }, 519 }; 520 521 static const struct rkisp1_info rk3399_isp_info = { 522 .clks = rk3399_isp_clks, 523 .clk_size = ARRAY_SIZE(rk3399_isp_clks), 524 .isrs = rk3399_isp_isrs, 525 .isr_size = ARRAY_SIZE(rk3399_isp_isrs), 526 .isp_ver = RKISP1_V10, 527 .features = RKISP1_FEATURE_MIPI_CSI2, 528 }; 529 530 static const struct of_device_id rkisp1_of_match[] = { 531 { 532 .compatible = "rockchip,px30-cif-isp", 533 .data = &px30_isp_info, 534 }, 535 { 536 .compatible = "rockchip,rk3399-cif-isp", 537 .data = &rk3399_isp_info, 538 }, 539 {}, 540 }; 541 MODULE_DEVICE_TABLE(of, rkisp1_of_match); 542 543 static int rkisp1_probe(struct platform_device *pdev) 544 { 545 const struct rkisp1_info *info; 546 struct device *dev = &pdev->dev; 547 struct rkisp1_device *rkisp1; 548 struct v4l2_device *v4l2_dev; 549 unsigned int i; 550 int ret, irq; 551 u32 cif_id; 552 553 rkisp1 = devm_kzalloc(dev, sizeof(*rkisp1), GFP_KERNEL); 554 if (!rkisp1) 555 return -ENOMEM; 556 557 info = of_device_get_match_data(dev); 558 rkisp1->info = info; 559 560 dev_set_drvdata(dev, rkisp1); 561 rkisp1->dev = dev; 562 563 mutex_init(&rkisp1->stream_lock); 564 565 rkisp1->base_addr = devm_platform_ioremap_resource(pdev, 0); 566 if (IS_ERR(rkisp1->base_addr)) 567 return PTR_ERR(rkisp1->base_addr); 568 569 for (unsigned int il = 0; il < ARRAY_SIZE(rkisp1->irqs); ++il) 570 rkisp1->irqs[il] = -1; 571 572 for (i = 0; i < info->isr_size; i++) { 573 irq = info->isrs[i].name 574 ? platform_get_irq_byname(pdev, info->isrs[i].name) 575 : platform_get_irq(pdev, i); 576 if (irq < 0) 577 return irq; 578 579 for (unsigned int il = 0; il < ARRAY_SIZE(rkisp1->irqs); ++il) { 580 if (info->isrs[i].line_mask & BIT(il)) 581 rkisp1->irqs[il] = irq; 582 } 583 584 ret = devm_request_irq(dev, irq, info->isrs[i].isr, IRQF_SHARED, 585 dev_driver_string(dev), dev); 586 if (ret) { 587 dev_err(dev, "request irq failed: %d\n", ret); 588 return ret; 589 } 590 } 591 592 for (i = 0; i < info->clk_size; i++) 593 rkisp1->clks[i].id = info->clks[i]; 594 ret = devm_clk_bulk_get(dev, info->clk_size, rkisp1->clks); 595 if (ret) 596 return ret; 597 rkisp1->clk_size = info->clk_size; 598 599 pm_runtime_enable(&pdev->dev); 600 601 ret = pm_runtime_resume_and_get(&pdev->dev); 602 if (ret) 603 goto err_pm_runtime_disable; 604 605 cif_id = rkisp1_read(rkisp1, RKISP1_CIF_VI_ID); 606 dev_dbg(rkisp1->dev, "CIF_ID 0x%08x\n", cif_id); 607 608 pm_runtime_put(&pdev->dev); 609 610 rkisp1->media_dev.hw_revision = info->isp_ver; 611 strscpy(rkisp1->media_dev.model, RKISP1_DRIVER_NAME, 612 sizeof(rkisp1->media_dev.model)); 613 rkisp1->media_dev.dev = &pdev->dev; 614 strscpy(rkisp1->media_dev.bus_info, RKISP1_BUS_INFO, 615 sizeof(rkisp1->media_dev.bus_info)); 616 media_device_init(&rkisp1->media_dev); 617 618 v4l2_dev = &rkisp1->v4l2_dev; 619 v4l2_dev->mdev = &rkisp1->media_dev; 620 strscpy(v4l2_dev->name, RKISP1_DRIVER_NAME, sizeof(v4l2_dev->name)); 621 622 ret = v4l2_device_register(rkisp1->dev, &rkisp1->v4l2_dev); 623 if (ret) 624 goto err_media_dev_cleanup; 625 626 ret = media_device_register(&rkisp1->media_dev); 627 if (ret) { 628 dev_err(dev, "Failed to register media device: %d\n", ret); 629 goto err_unreg_v4l2_dev; 630 } 631 632 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) { 633 ret = rkisp1_csi_init(rkisp1); 634 if (ret) 635 goto err_unreg_media_dev; 636 } 637 638 ret = rkisp1_entities_register(rkisp1); 639 if (ret) 640 goto err_cleanup_csi; 641 642 ret = rkisp1_subdev_notifier_register(rkisp1); 643 if (ret) 644 goto err_unreg_entities; 645 646 rkisp1_debug_init(rkisp1); 647 648 return 0; 649 650 err_unreg_entities: 651 rkisp1_entities_unregister(rkisp1); 652 err_cleanup_csi: 653 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) 654 rkisp1_csi_cleanup(rkisp1); 655 err_unreg_media_dev: 656 media_device_unregister(&rkisp1->media_dev); 657 err_unreg_v4l2_dev: 658 v4l2_device_unregister(&rkisp1->v4l2_dev); 659 err_media_dev_cleanup: 660 media_device_cleanup(&rkisp1->media_dev); 661 err_pm_runtime_disable: 662 pm_runtime_disable(&pdev->dev); 663 return ret; 664 } 665 666 static void rkisp1_remove(struct platform_device *pdev) 667 { 668 struct rkisp1_device *rkisp1 = platform_get_drvdata(pdev); 669 670 v4l2_async_nf_unregister(&rkisp1->notifier); 671 v4l2_async_nf_cleanup(&rkisp1->notifier); 672 673 rkisp1_entities_unregister(rkisp1); 674 if (rkisp1->info->features & RKISP1_FEATURE_MIPI_CSI2) 675 rkisp1_csi_cleanup(rkisp1); 676 rkisp1_debug_cleanup(rkisp1); 677 678 media_device_unregister(&rkisp1->media_dev); 679 v4l2_device_unregister(&rkisp1->v4l2_dev); 680 681 media_device_cleanup(&rkisp1->media_dev); 682 683 pm_runtime_disable(&pdev->dev); 684 } 685 686 static struct platform_driver rkisp1_drv = { 687 .driver = { 688 .name = RKISP1_DRIVER_NAME, 689 .of_match_table = of_match_ptr(rkisp1_of_match), 690 .pm = &rkisp1_pm_ops, 691 }, 692 .probe = rkisp1_probe, 693 .remove_new = rkisp1_remove, 694 }; 695 696 module_platform_driver(rkisp1_drv); 697 MODULE_DESCRIPTION("Rockchip ISP1 platform driver"); 698 MODULE_LICENSE("Dual MIT/GPL"); 699