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