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
rkisp1_subdev_notifier_bound(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct v4l2_async_connection * asc)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
rkisp1_subdev_notifier_complete(struct v4l2_async_notifier * notifier)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
rkisp1_subdev_notifier_destroy(struct v4l2_async_connection * asc)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
rkisp1_subdev_notifier_register(struct rkisp1_device * rkisp1)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
rkisp1_runtime_suspend(struct device * dev)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
rkisp1_runtime_resume(struct device * dev)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
rkisp1_create_links(struct rkisp1_device * rkisp1)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
rkisp1_entities_unregister(struct rkisp1_device * rkisp1)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
rkisp1_entities_register(struct rkisp1_device * rkisp1)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
rkisp1_isr(int irq,void * ctx)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
rkisp1_probe(struct platform_device * pdev)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
rkisp1_remove(struct platform_device * pdev)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