1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/list.h>
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/of_graph.h>
19#include <linux/platform_device.h>
20#include <linux/slab.h>
21
22#include <media/v4l2-async.h>
23#include <media/v4l2-common.h>
24#include <media/v4l2-device.h>
25#include <media/v4l2-fwnode.h>
26
27#include "xilinx-dma.h"
28#include "xilinx-vipp.h"
29
30#define XVIPP_DMA_S2MM 0
31#define XVIPP_DMA_MM2S 1
32
33
34
35
36
37
38
39
40
41struct xvip_graph_entity {
42 struct list_head list;
43 struct device_node *node;
44 struct media_entity *entity;
45
46 struct v4l2_async_subdev asd;
47 struct v4l2_subdev *subdev;
48};
49
50
51
52
53
54static struct xvip_graph_entity *
55xvip_graph_find_entity(struct xvip_composite_device *xdev,
56 const struct device_node *node)
57{
58 struct xvip_graph_entity *entity;
59
60 list_for_each_entry(entity, &xdev->entities, list) {
61 if (entity->node == node)
62 return entity;
63 }
64
65 return NULL;
66}
67
68static int xvip_graph_build_one(struct xvip_composite_device *xdev,
69 struct xvip_graph_entity *entity)
70{
71 u32 link_flags = MEDIA_LNK_FL_ENABLED;
72 struct media_entity *local = entity->entity;
73 struct media_entity *remote;
74 struct media_pad *local_pad;
75 struct media_pad *remote_pad;
76 struct xvip_graph_entity *ent;
77 struct v4l2_fwnode_link link;
78 struct device_node *ep = NULL;
79 int ret = 0;
80
81 dev_dbg(xdev->dev, "creating links for entity %s\n", local->name);
82
83 while (1) {
84
85 ep = of_graph_get_next_endpoint(entity->node, ep);
86 if (ep == NULL)
87 break;
88
89 dev_dbg(xdev->dev, "processing endpoint %pOF\n", ep);
90
91 ret = v4l2_fwnode_parse_link(of_fwnode_handle(ep), &link);
92 if (ret < 0) {
93 dev_err(xdev->dev, "failed to parse link for %pOF\n",
94 ep);
95 continue;
96 }
97
98
99
100
101 if (link.local_port >= local->num_pads) {
102 dev_err(xdev->dev, "invalid port number %u for %pOF\n",
103 link.local_port,
104 to_of_node(link.local_node));
105 v4l2_fwnode_put_link(&link);
106 ret = -EINVAL;
107 break;
108 }
109
110 local_pad = &local->pads[link.local_port];
111
112 if (local_pad->flags & MEDIA_PAD_FL_SINK) {
113 dev_dbg(xdev->dev, "skipping sink port %pOF:%u\n",
114 to_of_node(link.local_node),
115 link.local_port);
116 v4l2_fwnode_put_link(&link);
117 continue;
118 }
119
120
121 if (link.remote_node == of_fwnode_handle(xdev->dev->of_node)) {
122 dev_dbg(xdev->dev, "skipping DMA port %pOF:%u\n",
123 to_of_node(link.local_node),
124 link.local_port);
125 v4l2_fwnode_put_link(&link);
126 continue;
127 }
128
129
130 ent = xvip_graph_find_entity(xdev,
131 to_of_node(link.remote_node));
132 if (ent == NULL) {
133 dev_err(xdev->dev, "no entity found for %pOF\n",
134 to_of_node(link.remote_node));
135 v4l2_fwnode_put_link(&link);
136 ret = -ENODEV;
137 break;
138 }
139
140 remote = ent->entity;
141
142 if (link.remote_port >= remote->num_pads) {
143 dev_err(xdev->dev, "invalid port number %u on %pOF\n",
144 link.remote_port, to_of_node(link.remote_node));
145 v4l2_fwnode_put_link(&link);
146 ret = -EINVAL;
147 break;
148 }
149
150 remote_pad = &remote->pads[link.remote_port];
151
152 v4l2_fwnode_put_link(&link);
153
154
155 dev_dbg(xdev->dev, "creating %s:%u -> %s:%u link\n",
156 local->name, local_pad->index,
157 remote->name, remote_pad->index);
158
159 ret = media_create_pad_link(local, local_pad->index,
160 remote, remote_pad->index,
161 link_flags);
162 if (ret < 0) {
163 dev_err(xdev->dev,
164 "failed to create %s:%u -> %s:%u link\n",
165 local->name, local_pad->index,
166 remote->name, remote_pad->index);
167 break;
168 }
169 }
170
171 of_node_put(ep);
172 return ret;
173}
174
175static struct xvip_dma *
176xvip_graph_find_dma(struct xvip_composite_device *xdev, unsigned int port)
177{
178 struct xvip_dma *dma;
179
180 list_for_each_entry(dma, &xdev->dmas, list) {
181 if (dma->port == port)
182 return dma;
183 }
184
185 return NULL;
186}
187
188static int xvip_graph_build_dma(struct xvip_composite_device *xdev)
189{
190 u32 link_flags = MEDIA_LNK_FL_ENABLED;
191 struct device_node *node = xdev->dev->of_node;
192 struct media_entity *source;
193 struct media_entity *sink;
194 struct media_pad *source_pad;
195 struct media_pad *sink_pad;
196 struct xvip_graph_entity *ent;
197 struct v4l2_fwnode_link link;
198 struct device_node *ep = NULL;
199 struct xvip_dma *dma;
200 int ret = 0;
201
202 dev_dbg(xdev->dev, "creating links for DMA engines\n");
203
204 while (1) {
205
206 ep = of_graph_get_next_endpoint(node, ep);
207 if (ep == NULL)
208 break;
209
210 dev_dbg(xdev->dev, "processing endpoint %pOF\n", ep);
211
212 ret = v4l2_fwnode_parse_link(of_fwnode_handle(ep), &link);
213 if (ret < 0) {
214 dev_err(xdev->dev, "failed to parse link for %pOF\n",
215 ep);
216 continue;
217 }
218
219
220 dma = xvip_graph_find_dma(xdev, link.local_port);
221 if (dma == NULL) {
222 dev_err(xdev->dev, "no DMA engine found for port %u\n",
223 link.local_port);
224 v4l2_fwnode_put_link(&link);
225 ret = -EINVAL;
226 break;
227 }
228
229 dev_dbg(xdev->dev, "creating link for DMA engine %s\n",
230 dma->video.name);
231
232
233 ent = xvip_graph_find_entity(xdev,
234 to_of_node(link.remote_node));
235 if (ent == NULL) {
236 dev_err(xdev->dev, "no entity found for %pOF\n",
237 to_of_node(link.remote_node));
238 v4l2_fwnode_put_link(&link);
239 ret = -ENODEV;
240 break;
241 }
242
243 if (link.remote_port >= ent->entity->num_pads) {
244 dev_err(xdev->dev, "invalid port number %u on %pOF\n",
245 link.remote_port,
246 to_of_node(link.remote_node));
247 v4l2_fwnode_put_link(&link);
248 ret = -EINVAL;
249 break;
250 }
251
252 if (dma->pad.flags & MEDIA_PAD_FL_SOURCE) {
253 source = &dma->video.entity;
254 source_pad = &dma->pad;
255 sink = ent->entity;
256 sink_pad = &sink->pads[link.remote_port];
257 } else {
258 source = ent->entity;
259 source_pad = &source->pads[link.remote_port];
260 sink = &dma->video.entity;
261 sink_pad = &dma->pad;
262 }
263
264 v4l2_fwnode_put_link(&link);
265
266
267 dev_dbg(xdev->dev, "creating %s:%u -> %s:%u link\n",
268 source->name, source_pad->index,
269 sink->name, sink_pad->index);
270
271 ret = media_create_pad_link(source, source_pad->index,
272 sink, sink_pad->index,
273 link_flags);
274 if (ret < 0) {
275 dev_err(xdev->dev,
276 "failed to create %s:%u -> %s:%u link\n",
277 source->name, source_pad->index,
278 sink->name, sink_pad->index);
279 break;
280 }
281 }
282
283 of_node_put(ep);
284 return ret;
285}
286
287static int xvip_graph_notify_complete(struct v4l2_async_notifier *notifier)
288{
289 struct xvip_composite_device *xdev =
290 container_of(notifier, struct xvip_composite_device, notifier);
291 struct xvip_graph_entity *entity;
292 int ret;
293
294 dev_dbg(xdev->dev, "notify complete, all subdevs registered\n");
295
296
297 list_for_each_entry(entity, &xdev->entities, list) {
298 ret = xvip_graph_build_one(xdev, entity);
299 if (ret < 0)
300 return ret;
301 }
302
303
304 ret = xvip_graph_build_dma(xdev);
305 if (ret < 0)
306 return ret;
307
308 ret = v4l2_device_register_subdev_nodes(&xdev->v4l2_dev);
309 if (ret < 0)
310 dev_err(xdev->dev, "failed to register subdev nodes\n");
311
312 return media_device_register(&xdev->media_dev);
313}
314
315static int xvip_graph_notify_bound(struct v4l2_async_notifier *notifier,
316 struct v4l2_subdev *subdev,
317 struct v4l2_async_subdev *asd)
318{
319 struct xvip_composite_device *xdev =
320 container_of(notifier, struct xvip_composite_device, notifier);
321 struct xvip_graph_entity *entity;
322
323
324
325
326 list_for_each_entry(entity, &xdev->entities, list) {
327 if (entity->node != subdev->dev->of_node)
328 continue;
329
330 if (entity->subdev) {
331 dev_err(xdev->dev, "duplicate subdev for node %pOF\n",
332 entity->node);
333 return -EINVAL;
334 }
335
336 dev_dbg(xdev->dev, "subdev %s bound\n", subdev->name);
337 entity->entity = &subdev->entity;
338 entity->subdev = subdev;
339 return 0;
340 }
341
342 dev_err(xdev->dev, "no entity for subdev %s\n", subdev->name);
343 return -EINVAL;
344}
345
346static const struct v4l2_async_notifier_operations xvip_graph_notify_ops = {
347 .bound = xvip_graph_notify_bound,
348 .complete = xvip_graph_notify_complete,
349};
350
351static int xvip_graph_parse_one(struct xvip_composite_device *xdev,
352 struct device_node *node)
353{
354 struct xvip_graph_entity *entity;
355 struct device_node *remote;
356 struct device_node *ep = NULL;
357 int ret = 0;
358
359 dev_dbg(xdev->dev, "parsing node %pOF\n", node);
360
361 while (1) {
362 ep = of_graph_get_next_endpoint(node, ep);
363 if (ep == NULL)
364 break;
365
366 dev_dbg(xdev->dev, "handling endpoint %pOF\n", ep);
367
368 remote = of_graph_get_remote_port_parent(ep);
369 if (remote == NULL) {
370 ret = -EINVAL;
371 break;
372 }
373
374
375 if (remote == xdev->dev->of_node ||
376 xvip_graph_find_entity(xdev, remote)) {
377 of_node_put(remote);
378 continue;
379 }
380
381 entity = devm_kzalloc(xdev->dev, sizeof(*entity), GFP_KERNEL);
382 if (entity == NULL) {
383 of_node_put(remote);
384 ret = -ENOMEM;
385 break;
386 }
387
388 entity->node = remote;
389 entity->asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
390 entity->asd.match.fwnode = of_fwnode_handle(remote);
391 list_add_tail(&entity->list, &xdev->entities);
392 xdev->num_subdevs++;
393 }
394
395 of_node_put(ep);
396 return ret;
397}
398
399static int xvip_graph_parse(struct xvip_composite_device *xdev)
400{
401 struct xvip_graph_entity *entity;
402 int ret;
403
404
405
406
407
408
409
410 ret = xvip_graph_parse_one(xdev, xdev->dev->of_node);
411 if (ret < 0)
412 return 0;
413
414 list_for_each_entry(entity, &xdev->entities, list) {
415 ret = xvip_graph_parse_one(xdev, entity->node);
416 if (ret < 0)
417 break;
418 }
419
420 return ret;
421}
422
423static int xvip_graph_dma_init_one(struct xvip_composite_device *xdev,
424 struct device_node *node)
425{
426 struct xvip_dma *dma;
427 enum v4l2_buf_type type;
428 const char *direction;
429 unsigned int index;
430 int ret;
431
432 ret = of_property_read_string(node, "direction", &direction);
433 if (ret < 0)
434 return ret;
435
436 if (strcmp(direction, "input") == 0)
437 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
438 else if (strcmp(direction, "output") == 0)
439 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
440 else
441 return -EINVAL;
442
443 of_property_read_u32(node, "reg", &index);
444
445 dma = devm_kzalloc(xdev->dev, sizeof(*dma), GFP_KERNEL);
446 if (dma == NULL)
447 return -ENOMEM;
448
449 ret = xvip_dma_init(xdev, dma, type, index);
450 if (ret < 0) {
451 dev_err(xdev->dev, "%pOF initialization failed\n", node);
452 return ret;
453 }
454
455 list_add_tail(&dma->list, &xdev->dmas);
456
457 xdev->v4l2_caps |= type == V4L2_BUF_TYPE_VIDEO_CAPTURE
458 ? V4L2_CAP_VIDEO_CAPTURE : V4L2_CAP_VIDEO_OUTPUT;
459
460 return 0;
461}
462
463static int xvip_graph_dma_init(struct xvip_composite_device *xdev)
464{
465 struct device_node *ports;
466 struct device_node *port;
467 int ret;
468
469 ports = of_get_child_by_name(xdev->dev->of_node, "ports");
470 if (ports == NULL) {
471 dev_err(xdev->dev, "ports node not present\n");
472 return -EINVAL;
473 }
474
475 for_each_child_of_node(ports, port) {
476 ret = xvip_graph_dma_init_one(xdev, port);
477 if (ret < 0) {
478 of_node_put(port);
479 return ret;
480 }
481 }
482
483 return 0;
484}
485
486static void xvip_graph_cleanup(struct xvip_composite_device *xdev)
487{
488 struct xvip_graph_entity *entityp;
489 struct xvip_graph_entity *entity;
490 struct xvip_dma *dmap;
491 struct xvip_dma *dma;
492
493 v4l2_async_notifier_unregister(&xdev->notifier);
494
495 list_for_each_entry_safe(entity, entityp, &xdev->entities, list) {
496 of_node_put(entity->node);
497 list_del(&entity->list);
498 }
499
500 list_for_each_entry_safe(dma, dmap, &xdev->dmas, list) {
501 xvip_dma_cleanup(dma);
502 list_del(&dma->list);
503 }
504}
505
506static int xvip_graph_init(struct xvip_composite_device *xdev)
507{
508 struct xvip_graph_entity *entity;
509 struct v4l2_async_subdev **subdevs = NULL;
510 unsigned int num_subdevs;
511 unsigned int i;
512 int ret;
513
514
515 ret = xvip_graph_dma_init(xdev);
516 if (ret < 0) {
517 dev_err(xdev->dev, "DMA initialization failed\n");
518 goto done;
519 }
520
521
522 ret = xvip_graph_parse(xdev);
523 if (ret < 0) {
524 dev_err(xdev->dev, "graph parsing failed\n");
525 goto done;
526 }
527
528 if (!xdev->num_subdevs) {
529 dev_err(xdev->dev, "no subdev found in graph\n");
530 goto done;
531 }
532
533
534 num_subdevs = xdev->num_subdevs;
535 subdevs = devm_kzalloc(xdev->dev, sizeof(*subdevs) * num_subdevs,
536 GFP_KERNEL);
537 if (subdevs == NULL) {
538 ret = -ENOMEM;
539 goto done;
540 }
541
542 i = 0;
543 list_for_each_entry(entity, &xdev->entities, list)
544 subdevs[i++] = &entity->asd;
545
546 xdev->notifier.subdevs = subdevs;
547 xdev->notifier.num_subdevs = num_subdevs;
548 xdev->notifier.ops = &xvip_graph_notify_ops;
549
550 ret = v4l2_async_notifier_register(&xdev->v4l2_dev, &xdev->notifier);
551 if (ret < 0) {
552 dev_err(xdev->dev, "notifier registration failed\n");
553 goto done;
554 }
555
556 ret = 0;
557
558done:
559 if (ret < 0)
560 xvip_graph_cleanup(xdev);
561
562 return ret;
563}
564
565
566
567
568
569static void xvip_composite_v4l2_cleanup(struct xvip_composite_device *xdev)
570{
571 v4l2_device_unregister(&xdev->v4l2_dev);
572 media_device_unregister(&xdev->media_dev);
573 media_device_cleanup(&xdev->media_dev);
574}
575
576static int xvip_composite_v4l2_init(struct xvip_composite_device *xdev)
577{
578 int ret;
579
580 xdev->media_dev.dev = xdev->dev;
581 strlcpy(xdev->media_dev.model, "Xilinx Video Composite Device",
582 sizeof(xdev->media_dev.model));
583 xdev->media_dev.hw_revision = 0;
584
585 media_device_init(&xdev->media_dev);
586
587 xdev->v4l2_dev.mdev = &xdev->media_dev;
588 ret = v4l2_device_register(xdev->dev, &xdev->v4l2_dev);
589 if (ret < 0) {
590 dev_err(xdev->dev, "V4L2 device registration failed (%d)\n",
591 ret);
592 media_device_cleanup(&xdev->media_dev);
593 return ret;
594 }
595
596 return 0;
597}
598
599
600
601
602
603static int xvip_composite_probe(struct platform_device *pdev)
604{
605 struct xvip_composite_device *xdev;
606 int ret;
607
608 xdev = devm_kzalloc(&pdev->dev, sizeof(*xdev), GFP_KERNEL);
609 if (!xdev)
610 return -ENOMEM;
611
612 xdev->dev = &pdev->dev;
613 INIT_LIST_HEAD(&xdev->entities);
614 INIT_LIST_HEAD(&xdev->dmas);
615
616 ret = xvip_composite_v4l2_init(xdev);
617 if (ret < 0)
618 return ret;
619
620 ret = xvip_graph_init(xdev);
621 if (ret < 0)
622 goto error;
623
624 platform_set_drvdata(pdev, xdev);
625
626 dev_info(xdev->dev, "device registered\n");
627
628 return 0;
629
630error:
631 xvip_composite_v4l2_cleanup(xdev);
632 return ret;
633}
634
635static int xvip_composite_remove(struct platform_device *pdev)
636{
637 struct xvip_composite_device *xdev = platform_get_drvdata(pdev);
638
639 xvip_graph_cleanup(xdev);
640 xvip_composite_v4l2_cleanup(xdev);
641
642 return 0;
643}
644
645static const struct of_device_id xvip_composite_of_id_table[] = {
646 { .compatible = "xlnx,video" },
647 { }
648};
649MODULE_DEVICE_TABLE(of, xvip_composite_of_id_table);
650
651static struct platform_driver xvip_composite_driver = {
652 .driver = {
653 .name = "xilinx-video",
654 .of_match_table = xvip_composite_of_id_table,
655 },
656 .probe = xvip_composite_probe,
657 .remove = xvip_composite_remove,
658};
659
660module_platform_driver(xvip_composite_driver);
661
662MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
663MODULE_DESCRIPTION("Xilinx Video IP Composite Driver");
664MODULE_LICENSE("GPL v2");
665
