drivers/media/platform/xilinx/xilinx-vipp.c

   1 /*
   2  * Xilinx Video IP Composite Device
   3  *
   4  * Copyright (C) 2013-2015 Ideas on Board
   5  * Copyright (C) 2013-2015 Xilinx, Inc.
   6  *
   7  * Contacts: Hyun Kwon <hyun.kwon@xilinx.com>
   8  *           Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  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  * struct xvip_graph_entity - Entity in the video graph
  35  * @list: list entry in a graph entities list
  36  * @node: the entity's DT node
  37  * @entity: media entity, from the corresponding V4L2 subdev
  38  * @asd: subdev asynchronous registration information
  39  * @subdev: V4L2 subdev
  40  */
  41 struct 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  * Graph Management
  52  */
  53
  54 static struct xvip_graph_entity *
  55 xvip_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
  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 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                 /* Get the next endpoint and parse its link. */
  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                 /* Skip sink ports, they will be processed from the other end of
  99                  * the link.
 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                 /* Skip DMA engines, they will be processed separately. */
 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                 /* Find the remote entity. */
 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                 /* Create the media link. */
 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
 175 static struct xvip_dma *
 176 xvip_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
 188 static 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                 /* Get the next endpoint and parse its link. */
 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                 /* Find the DMA engine. */
 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                 /* Find the remote entity. */
 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                 /* Create the media link. */
 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
 287 static 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         /* Create links for every entity. */
 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         /* 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_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         /* Locate the entity corresponding to the bound subdev and store the
 324          * subdev pointer.
 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
 346 static const struct v4l2_async_notifier_operations xvip_graph_notify_ops = {
 347         .bound = xvip_graph_notify_bound,
 348         .complete = xvip_graph_notify_complete,
 349 };
 350
 351 static 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                 /* Skip entities that we have already processed. */
 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
 399 static int xvip_graph_parse(struct xvip_composite_device *xdev)
 400 {
 401         struct xvip_graph_entity *entity;
 402         int ret;
 403
 404         /*
 405          * Walk the links to parse the full graph. Start by parsing the
 406          * composite node and then parse entities in turn. The list_for_each
 407          * loop will handle entities added at the end of the list while walking
 408          * the links.
 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
 423 static 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
 463 static int xvip_graph_dma_init(struct xvip_composite_device *xdev)
 464 {
 465         struct device_node *ports;
 466         struct device_node *port;
 467         int ret = 0;
 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) {
 478                         of_node_put(port);
 479                         break;
 480                 }
 481         }
 482
 483         of_node_put(ports);
 484         return ret;
 485 }
 486
 487 static void xvip_graph_cleanup(struct xvip_composite_device *xdev)
 488 {
 489         struct xvip_graph_entity *entityp;
 490         struct xvip_graph_entity *entity;
 491         struct xvip_dma *dmap;
 492         struct xvip_dma *dma;
 493
 494         v4l2_async_notifier_unregister(&xdev->notifier);
 495
 496         list_for_each_entry_safe(entity, entityp, &xdev->entities, list) {
 497                 of_node_put(entity->node);
 498                 list_del(&entity->list);
 499         }
 500
 501         list_for_each_entry_safe(dma, dmap, &xdev->dmas, list) {
 502                 xvip_dma_cleanup(dma);
 503                 list_del(&dma->list);
 504         }
 505 }
 506
 507 static int xvip_graph_init(struct xvip_composite_device *xdev)
 508 {
 509         struct xvip_graph_entity *entity;
 510         struct v4l2_async_subdev **subdevs = NULL;
 511         unsigned int num_subdevs;
 512         unsigned int i;
 513         int ret;
 514
 515         /* Init the DMA channels. */
 516         ret = xvip_graph_dma_init(xdev);
 517         if (ret < 0) {
 518                 dev_err(xdev->dev, "DMA initialization failed\n");
 519                 goto done;
 520         }
 521
 522         /* Parse the graph to extract a list of subdevice DT nodes. */
 523         ret = xvip_graph_parse(xdev);
 524         if (ret < 0) {
 525                 dev_err(xdev->dev, "graph parsing failed\n");
 526                 goto done;
 527         }
 528
 529         if (!xdev->num_subdevs) {
 530                 dev_err(xdev->dev, "no subdev found in graph\n");
 531                 goto done;
 532         }
 533
 534         /* Register the subdevices notifier. */
 535         num_subdevs = xdev->num_subdevs;
 536         subdevs = devm_kcalloc(xdev->dev, num_subdevs, sizeof(*subdevs),
 537                                GFP_KERNEL);
 538         if (subdevs == NULL) {
 539                 ret = -ENOMEM;
 540                 goto done;
 541         }
 542
 543         i = 0;
 544         list_for_each_entry(entity, &xdev->entities, list)
 545                 subdevs[i++] = &entity->asd;
 546
 547         xdev->notifier.subdevs = subdevs;
 548         xdev->notifier.num_subdevs = num_subdevs;
 549         xdev->notifier.ops = &xvip_graph_notify_ops;
 550
 551         ret = v4l2_async_notifier_register(&xdev->v4l2_dev, &xdev->notifier);
 552         if (ret < 0) {
 553                 dev_err(xdev->dev, "notifier registration failed\n");
 554                 goto done;
 555         }
 556
 557         ret = 0;
 558
 559 done:
 560         if (ret < 0)
 561                 xvip_graph_cleanup(xdev);
 562
 563         return ret;
 564 }
 565
 566 /* -----------------------------------------------------------------------------
 567  * Media Controller and V4L2
 568  */
 569
 570 static void xvip_composite_v4l2_cleanup(struct xvip_composite_device *xdev)
 571 {
 572         v4l2_device_unregister(&xdev->v4l2_dev);
 573         media_device_unregister(&xdev->media_dev);
 574         media_device_cleanup(&xdev->media_dev);
 575 }
 576
 577 static int xvip_composite_v4l2_init(struct xvip_composite_device *xdev)
 578 {
 579         int ret;
 580
 581         xdev->media_dev.dev = xdev->dev;
 582         strlcpy(xdev->media_dev.model, "Xilinx Video Composite Device",
 583                 sizeof(xdev->media_dev.model));
 584         xdev->media_dev.hw_revision = 0;
 585
 586         media_device_init(&xdev->media_dev);
 587
 588         xdev->v4l2_dev.mdev = &xdev->media_dev;
 589         ret = v4l2_device_register(xdev->dev, &xdev->v4l2_dev);
 590         if (ret < 0) {
 591                 dev_err(xdev->dev, "V4L2 device registration failed (%d)\n",
 592                         ret);
 593                 media_device_cleanup(&xdev->media_dev);
 594                 return ret;
 595         }
 596
 597         return 0;
 598 }
 599
 600 /* -----------------------------------------------------------------------------
 601  * Platform Device Driver
 602  */
 603
 604 static int xvip_composite_probe(struct platform_device *pdev)
 605 {
 606         struct xvip_composite_device *xdev;
 607         int ret;
 608
 609         xdev = devm_kzalloc(&pdev->dev, sizeof(*xdev), GFP_KERNEL);
 610         if (!xdev)
 611                 return -ENOMEM;
 612
 613         xdev->dev = &pdev->dev;
 614         INIT_LIST_HEAD(&xdev->entities);
 615         INIT_LIST_HEAD(&xdev->dmas);
 616
 617         ret = xvip_composite_v4l2_init(xdev);
 618         if (ret < 0)
 619                 return ret;
 620
 621         ret = xvip_graph_init(xdev);
 622         if (ret < 0)
 623                 goto error;
 624
 625         platform_set_drvdata(pdev, xdev);
 626
 627         dev_info(xdev->dev, "device registered\n");
 628
 629         return 0;
 630
 631 error:
 632         xvip_composite_v4l2_cleanup(xdev);
 633         return ret;
 634 }
 635
 636 static int xvip_composite_remove(struct platform_device *pdev)
 637 {
 638         struct xvip_composite_device *xdev = platform_get_drvdata(pdev);
 639
 640         xvip_graph_cleanup(xdev);
 641         xvip_composite_v4l2_cleanup(xdev);
 642
 643         return 0;
 644 }
 645
 646 static const struct of_device_id xvip_composite_of_id_table[] = {
 647         { .compatible = "xlnx,video" },
 648         { }
 649 };
 650 MODULE_DEVICE_TABLE(of, xvip_composite_of_id_table);
 651
 652 static struct platform_driver xvip_composite_driver = {
 653         .driver = {
 654                 .name = "xilinx-video",
 655                 .of_match_table = xvip_composite_of_id_table,
 656         },
 657         .probe = xvip_composite_probe,
 658         .remove = xvip_composite_remove,
 659 };
 660
 661 module_platform_driver(xvip_composite_driver);
 662
 663 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
 664 MODULE_DESCRIPTION("Xilinx Video IP Composite Driver");
 665 MODULE_LICENSE("GPL v2");