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