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