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