1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for Renesas R-Car VIN 4 * 5 * Copyright (C) 2016 Renesas Electronics Corp. 6 * Copyright (C) 2011-2013 Renesas Solutions Corp. 7 * Copyright (C) 2013 Cogent Embedded, Inc., <source@cogentembedded.com> 8 * Copyright (C) 2008 Magnus Damm 9 * 10 * Based on the soc-camera rcar_vin driver 11 */ 12 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/pm_runtime.h> 18 #include <linux/slab.h> 19 20 #include <media/v4l2-async.h> 21 #include <media/v4l2-fwnode.h> 22 #include <media/v4l2-mc.h> 23 24 #include "rcar-vin.h" 25 26 /* 27 * The companion CSI-2 receiver driver (rcar-csi2) is known 28 * and we know it has one source pad (pad 0) and four sink 29 * pads (pad 1-4). So to translate a pad on the remote 30 * CSI-2 receiver to/from the VIN internal channel number simply 31 * subtract/add one from the pad/channel number. 32 */ 33 #define rvin_group_csi_pad_to_channel(pad) ((pad) - 1) 34 #define rvin_group_csi_channel_to_pad(channel) ((channel) + 1) 35 36 /* 37 * Not all VINs are created equal, master VINs control the 38 * routing for other VIN's. We can figure out which VIN is 39 * master by looking at a VINs id. 40 */ 41 #define rvin_group_id_to_master(vin) ((vin) < 4 ? 0 : 4) 42 43 #define v4l2_dev_to_vin(d) container_of(d, struct rvin_dev, v4l2_dev) 44 45 /* ----------------------------------------------------------------------------- 46 * Gen3 Group Allocator 47 */ 48 49 /* FIXME: This should if we find a system that supports more 50 * than one group for the whole system be replaced with a linked 51 * list of groups. And eventually all of this should be replaced 52 * with a global device allocator API. 53 * 54 * But for now this works as on all supported systems there will 55 * be only one group for all instances. 56 */ 57 58 static DEFINE_MUTEX(rvin_group_lock); 59 static struct rvin_group *rvin_group_data; 60 61 static void rvin_group_cleanup(struct rvin_group *group) 62 { 63 media_device_cleanup(&group->mdev); 64 mutex_destroy(&group->lock); 65 } 66 67 static int rvin_group_init(struct rvin_group *group, struct rvin_dev *vin, 68 int (*link_setup)(struct rvin_dev *), 69 const struct media_device_ops *ops) 70 { 71 struct media_device *mdev = &group->mdev; 72 const struct of_device_id *match; 73 struct device_node *np; 74 75 mutex_init(&group->lock); 76 77 /* Count number of VINs in the system */ 78 group->count = 0; 79 for_each_matching_node(np, vin->dev->driver->of_match_table) 80 if (of_device_is_available(np)) 81 group->count++; 82 83 vin_dbg(vin, "found %u enabled VIN's in DT", group->count); 84 85 group->link_setup = link_setup; 86 87 mdev->dev = vin->dev; 88 mdev->ops = ops; 89 90 match = of_match_node(vin->dev->driver->of_match_table, 91 vin->dev->of_node); 92 93 strscpy(mdev->driver_name, KBUILD_MODNAME, sizeof(mdev->driver_name)); 94 strscpy(mdev->model, match->compatible, sizeof(mdev->model)); 95 96 media_device_init(mdev); 97 98 return 0; 99 } 100 101 static void rvin_group_release(struct kref *kref) 102 { 103 struct rvin_group *group = 104 container_of(kref, struct rvin_group, refcount); 105 106 mutex_lock(&rvin_group_lock); 107 108 rvin_group_data = NULL; 109 110 rvin_group_cleanup(group); 111 112 kfree(group); 113 114 mutex_unlock(&rvin_group_lock); 115 } 116 117 static int rvin_group_get(struct rvin_dev *vin, 118 int (*link_setup)(struct rvin_dev *), 119 const struct media_device_ops *ops) 120 { 121 struct rvin_group *group; 122 u32 id; 123 int ret; 124 125 /* Make sure VIN id is present and sane */ 126 ret = of_property_read_u32(vin->dev->of_node, "renesas,id", &id); 127 if (ret) { 128 vin_err(vin, "%pOF: No renesas,id property found\n", 129 vin->dev->of_node); 130 return -EINVAL; 131 } 132 133 if (id >= RCAR_VIN_NUM) { 134 vin_err(vin, "%pOF: Invalid renesas,id '%u'\n", 135 vin->dev->of_node, id); 136 return -EINVAL; 137 } 138 139 /* Join or create a VIN group */ 140 mutex_lock(&rvin_group_lock); 141 if (rvin_group_data) { 142 group = rvin_group_data; 143 kref_get(&group->refcount); 144 } else { 145 group = kzalloc(sizeof(*group), GFP_KERNEL); 146 if (!group) { 147 ret = -ENOMEM; 148 goto err_group; 149 } 150 151 ret = rvin_group_init(group, vin, link_setup, ops); 152 if (ret) { 153 kfree(group); 154 vin_err(vin, "Failed to initialize group\n"); 155 goto err_group; 156 } 157 158 kref_init(&group->refcount); 159 160 rvin_group_data = group; 161 } 162 mutex_unlock(&rvin_group_lock); 163 164 /* Add VIN to group */ 165 mutex_lock(&group->lock); 166 167 if (group->vin[id]) { 168 vin_err(vin, "Duplicate renesas,id property value %u\n", id); 169 mutex_unlock(&group->lock); 170 kref_put(&group->refcount, rvin_group_release); 171 return -EINVAL; 172 } 173 174 group->vin[id] = vin; 175 176 vin->id = id; 177 vin->group = group; 178 vin->v4l2_dev.mdev = &group->mdev; 179 180 mutex_unlock(&group->lock); 181 182 return 0; 183 err_group: 184 mutex_unlock(&rvin_group_lock); 185 return ret; 186 } 187 188 static void rvin_group_put(struct rvin_dev *vin) 189 { 190 struct rvin_group *group = vin->group; 191 192 mutex_lock(&group->lock); 193 194 vin->group = NULL; 195 vin->v4l2_dev.mdev = NULL; 196 197 if (WARN_ON(group->vin[vin->id] != vin)) 198 goto out; 199 200 group->vin[vin->id] = NULL; 201 out: 202 mutex_unlock(&group->lock); 203 204 kref_put(&group->refcount, rvin_group_release); 205 } 206 207 /* group lock should be held when calling this function. */ 208 static int rvin_group_entity_to_remote_id(struct rvin_group *group, 209 struct media_entity *entity) 210 { 211 struct v4l2_subdev *sd; 212 unsigned int i; 213 214 sd = media_entity_to_v4l2_subdev(entity); 215 216 for (i = 0; i < RVIN_REMOTES_MAX; i++) 217 if (group->remotes[i].subdev == sd) 218 return i; 219 220 return -ENODEV; 221 } 222 223 static int rvin_group_notify_complete(struct v4l2_async_notifier *notifier) 224 { 225 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 226 unsigned int i; 227 int ret; 228 229 ret = media_device_register(&vin->group->mdev); 230 if (ret) 231 return ret; 232 233 ret = v4l2_device_register_subdev_nodes(&vin->v4l2_dev); 234 if (ret) { 235 vin_err(vin, "Failed to register subdev nodes\n"); 236 return ret; 237 } 238 239 /* Register all video nodes for the group. */ 240 for (i = 0; i < RCAR_VIN_NUM; i++) { 241 if (vin->group->vin[i] && 242 !video_is_registered(&vin->group->vin[i]->vdev)) { 243 ret = rvin_v4l2_register(vin->group->vin[i]); 244 if (ret) 245 return ret; 246 } 247 } 248 249 return vin->group->link_setup(vin); 250 } 251 252 static void rvin_group_notify_unbind(struct v4l2_async_notifier *notifier, 253 struct v4l2_subdev *subdev, 254 struct v4l2_async_connection *asc) 255 { 256 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 257 unsigned int i; 258 259 for (i = 0; i < RCAR_VIN_NUM; i++) 260 if (vin->group->vin[i]) 261 rvin_v4l2_unregister(vin->group->vin[i]); 262 263 mutex_lock(&vin->group->lock); 264 265 for (i = 0; i < RVIN_CSI_MAX; i++) { 266 if (vin->group->remotes[i].asc != asc) 267 continue; 268 vin->group->remotes[i].subdev = NULL; 269 vin_dbg(vin, "Unbind %s from slot %u\n", subdev->name, i); 270 break; 271 } 272 273 mutex_unlock(&vin->group->lock); 274 275 media_device_unregister(&vin->group->mdev); 276 } 277 278 static int rvin_group_notify_bound(struct v4l2_async_notifier *notifier, 279 struct v4l2_subdev *subdev, 280 struct v4l2_async_connection *asc) 281 { 282 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 283 unsigned int i; 284 285 mutex_lock(&vin->group->lock); 286 287 for (i = 0; i < RVIN_CSI_MAX; i++) { 288 if (vin->group->remotes[i].asc != asc) 289 continue; 290 vin->group->remotes[i].subdev = subdev; 291 vin_dbg(vin, "Bound %s to slot %u\n", subdev->name, i); 292 break; 293 } 294 295 mutex_unlock(&vin->group->lock); 296 297 return 0; 298 } 299 300 static const struct v4l2_async_notifier_operations rvin_group_notify_ops = { 301 .bound = rvin_group_notify_bound, 302 .unbind = rvin_group_notify_unbind, 303 .complete = rvin_group_notify_complete, 304 }; 305 306 static int rvin_group_parse_of(struct rvin_dev *vin, unsigned int port, 307 unsigned int id) 308 { 309 struct fwnode_handle *ep, *fwnode; 310 struct v4l2_fwnode_endpoint vep = { 311 .bus_type = V4L2_MBUS_CSI2_DPHY, 312 }; 313 struct v4l2_async_connection *asc; 314 int ret; 315 316 ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(vin->dev), port, id, 0); 317 if (!ep) 318 return 0; 319 320 fwnode = fwnode_graph_get_remote_endpoint(ep); 321 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 322 fwnode_handle_put(ep); 323 if (ret) { 324 vin_err(vin, "Failed to parse %pOF\n", to_of_node(fwnode)); 325 ret = -EINVAL; 326 goto out; 327 } 328 329 asc = v4l2_async_nf_add_fwnode(&vin->group->notifier, fwnode, 330 struct v4l2_async_connection); 331 if (IS_ERR(asc)) { 332 ret = PTR_ERR(asc); 333 goto out; 334 } 335 336 vin->group->remotes[vep.base.id].asc = asc; 337 338 vin_dbg(vin, "Add group OF device %pOF to slot %u\n", 339 to_of_node(fwnode), vep.base.id); 340 out: 341 fwnode_handle_put(fwnode); 342 343 return ret; 344 } 345 346 static void rvin_group_notifier_cleanup(struct rvin_dev *vin) 347 { 348 if (&vin->v4l2_dev == vin->group->notifier.v4l2_dev) { 349 v4l2_async_nf_unregister(&vin->group->notifier); 350 v4l2_async_nf_cleanup(&vin->group->notifier); 351 } 352 } 353 354 static int rvin_group_notifier_init(struct rvin_dev *vin, unsigned int port, 355 unsigned int max_id) 356 { 357 unsigned int count = 0, vin_mask = 0; 358 unsigned int i, id; 359 int ret; 360 361 mutex_lock(&vin->group->lock); 362 363 /* If not all VIN's are registered don't register the notifier. */ 364 for (i = 0; i < RCAR_VIN_NUM; i++) { 365 if (vin->group->vin[i]) { 366 count++; 367 vin_mask |= BIT(i); 368 } 369 } 370 371 if (vin->group->count != count) { 372 mutex_unlock(&vin->group->lock); 373 return 0; 374 } 375 376 mutex_unlock(&vin->group->lock); 377 378 v4l2_async_nf_init(&vin->group->notifier, &vin->v4l2_dev); 379 380 /* 381 * Some subdevices may overlap but the parser function can handle it and 382 * each subdevice will only be registered once with the group notifier. 383 */ 384 for (i = 0; i < RCAR_VIN_NUM; i++) { 385 if (!(vin_mask & BIT(i))) 386 continue; 387 388 for (id = 0; id < max_id; id++) { 389 if (vin->group->remotes[id].asc) 390 continue; 391 392 ret = rvin_group_parse_of(vin->group->vin[i], port, id); 393 if (ret) 394 return ret; 395 } 396 } 397 398 if (list_empty(&vin->group->notifier.waiting_list)) 399 return 0; 400 401 vin->group->notifier.ops = &rvin_group_notify_ops; 402 ret = v4l2_async_nf_register(&vin->group->notifier); 403 if (ret < 0) { 404 vin_err(vin, "Notifier registration failed\n"); 405 v4l2_async_nf_cleanup(&vin->group->notifier); 406 return ret; 407 } 408 409 return 0; 410 } 411 412 /* ----------------------------------------------------------------------------- 413 * Controls 414 */ 415 416 static int rvin_s_ctrl(struct v4l2_ctrl *ctrl) 417 { 418 struct rvin_dev *vin = 419 container_of(ctrl->handler, struct rvin_dev, ctrl_handler); 420 421 switch (ctrl->id) { 422 case V4L2_CID_ALPHA_COMPONENT: 423 rvin_set_alpha(vin, ctrl->val); 424 break; 425 } 426 427 return 0; 428 } 429 430 static const struct v4l2_ctrl_ops rvin_ctrl_ops = { 431 .s_ctrl = rvin_s_ctrl, 432 }; 433 434 static void rvin_free_controls(struct rvin_dev *vin) 435 { 436 v4l2_ctrl_handler_free(&vin->ctrl_handler); 437 vin->vdev.ctrl_handler = NULL; 438 } 439 440 static int rvin_create_controls(struct rvin_dev *vin, struct v4l2_subdev *subdev) 441 { 442 int ret; 443 444 ret = v4l2_ctrl_handler_init(&vin->ctrl_handler, 16); 445 if (ret < 0) 446 return ret; 447 448 /* The VIN directly deals with alpha component. */ 449 v4l2_ctrl_new_std(&vin->ctrl_handler, &rvin_ctrl_ops, 450 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 255); 451 452 if (vin->ctrl_handler.error) { 453 ret = vin->ctrl_handler.error; 454 rvin_free_controls(vin); 455 return ret; 456 } 457 458 /* For the non-MC mode add controls from the subdevice. */ 459 if (subdev) { 460 ret = v4l2_ctrl_add_handler(&vin->ctrl_handler, 461 subdev->ctrl_handler, NULL, true); 462 if (ret < 0) { 463 rvin_free_controls(vin); 464 return ret; 465 } 466 } 467 468 vin->vdev.ctrl_handler = &vin->ctrl_handler; 469 470 return 0; 471 } 472 473 /* ----------------------------------------------------------------------------- 474 * Async notifier 475 */ 476 477 static int rvin_find_pad(struct v4l2_subdev *sd, int direction) 478 { 479 unsigned int pad; 480 481 if (sd->entity.num_pads <= 1) 482 return 0; 483 484 for (pad = 0; pad < sd->entity.num_pads; pad++) 485 if (sd->entity.pads[pad].flags & direction) 486 return pad; 487 488 return -EINVAL; 489 } 490 491 /* ----------------------------------------------------------------------------- 492 * Parallel async notifier 493 */ 494 495 /* The vin lock should be held when calling the subdevice attach and detach */ 496 static int rvin_parallel_subdevice_attach(struct rvin_dev *vin, 497 struct v4l2_subdev *subdev) 498 { 499 struct v4l2_subdev_mbus_code_enum code = { 500 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 501 }; 502 int ret; 503 504 /* Find source and sink pad of remote subdevice */ 505 ret = rvin_find_pad(subdev, MEDIA_PAD_FL_SOURCE); 506 if (ret < 0) 507 return ret; 508 vin->parallel.source_pad = ret; 509 510 ret = rvin_find_pad(subdev, MEDIA_PAD_FL_SINK); 511 vin->parallel.sink_pad = ret < 0 ? 0 : ret; 512 513 if (vin->info->use_mc) { 514 vin->parallel.subdev = subdev; 515 return 0; 516 } 517 518 /* Find compatible subdevices mbus format */ 519 vin->mbus_code = 0; 520 code.index = 0; 521 code.pad = vin->parallel.source_pad; 522 while (!vin->mbus_code && 523 !v4l2_subdev_call(subdev, pad, enum_mbus_code, NULL, &code)) { 524 code.index++; 525 switch (code.code) { 526 case MEDIA_BUS_FMT_YUYV8_1X16: 527 case MEDIA_BUS_FMT_UYVY8_1X16: 528 case MEDIA_BUS_FMT_UYVY8_2X8: 529 case MEDIA_BUS_FMT_UYVY10_2X10: 530 case MEDIA_BUS_FMT_RGB888_1X24: 531 vin->mbus_code = code.code; 532 vin_dbg(vin, "Found media bus format for %s: %d\n", 533 subdev->name, vin->mbus_code); 534 break; 535 default: 536 break; 537 } 538 } 539 540 if (!vin->mbus_code) { 541 vin_err(vin, "Unsupported media bus format for %s\n", 542 subdev->name); 543 return -EINVAL; 544 } 545 546 /* Read tvnorms */ 547 ret = v4l2_subdev_call(subdev, video, g_tvnorms, &vin->vdev.tvnorms); 548 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV) 549 return ret; 550 551 /* Read standard */ 552 vin->std = V4L2_STD_UNKNOWN; 553 ret = v4l2_subdev_call(subdev, video, g_std, &vin->std); 554 if (ret < 0 && ret != -ENOIOCTLCMD) 555 return ret; 556 557 /* Add the controls */ 558 ret = rvin_create_controls(vin, subdev); 559 if (ret < 0) 560 return ret; 561 562 vin->parallel.subdev = subdev; 563 564 return 0; 565 } 566 567 static void rvin_parallel_subdevice_detach(struct rvin_dev *vin) 568 { 569 rvin_v4l2_unregister(vin); 570 vin->parallel.subdev = NULL; 571 572 if (!vin->info->use_mc) 573 rvin_free_controls(vin); 574 } 575 576 static int rvin_parallel_notify_complete(struct v4l2_async_notifier *notifier) 577 { 578 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 579 struct media_entity *source; 580 struct media_entity *sink; 581 int ret; 582 583 ret = v4l2_device_register_subdev_nodes(&vin->v4l2_dev); 584 if (ret < 0) { 585 vin_err(vin, "Failed to register subdev nodes\n"); 586 return ret; 587 } 588 589 if (!video_is_registered(&vin->vdev)) { 590 ret = rvin_v4l2_register(vin); 591 if (ret < 0) 592 return ret; 593 } 594 595 if (!vin->info->use_mc) 596 return 0; 597 598 /* If we're running with media-controller, link the subdevs. */ 599 source = &vin->parallel.subdev->entity; 600 sink = &vin->vdev.entity; 601 602 ret = media_create_pad_link(source, vin->parallel.source_pad, 603 sink, vin->parallel.sink_pad, 0); 604 if (ret) 605 vin_err(vin, "Error adding link from %s to %s: %d\n", 606 source->name, sink->name, ret); 607 608 return ret; 609 } 610 611 static void rvin_parallel_notify_unbind(struct v4l2_async_notifier *notifier, 612 struct v4l2_subdev *subdev, 613 struct v4l2_async_connection *asc) 614 { 615 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 616 617 vin_dbg(vin, "unbind parallel subdev %s\n", subdev->name); 618 619 mutex_lock(&vin->lock); 620 rvin_parallel_subdevice_detach(vin); 621 mutex_unlock(&vin->lock); 622 } 623 624 static int rvin_parallel_notify_bound(struct v4l2_async_notifier *notifier, 625 struct v4l2_subdev *subdev, 626 struct v4l2_async_connection *asc) 627 { 628 struct rvin_dev *vin = v4l2_dev_to_vin(notifier->v4l2_dev); 629 int ret; 630 631 mutex_lock(&vin->lock); 632 ret = rvin_parallel_subdevice_attach(vin, subdev); 633 mutex_unlock(&vin->lock); 634 if (ret) 635 return ret; 636 637 v4l2_set_subdev_hostdata(subdev, vin); 638 639 vin_dbg(vin, "bound subdev %s source pad: %u sink pad: %u\n", 640 subdev->name, vin->parallel.source_pad, 641 vin->parallel.sink_pad); 642 643 return 0; 644 } 645 646 static const struct v4l2_async_notifier_operations rvin_parallel_notify_ops = { 647 .bound = rvin_parallel_notify_bound, 648 .unbind = rvin_parallel_notify_unbind, 649 .complete = rvin_parallel_notify_complete, 650 }; 651 652 static int rvin_parallel_parse_of(struct rvin_dev *vin) 653 { 654 struct fwnode_handle *ep, *fwnode; 655 struct v4l2_fwnode_endpoint vep = { 656 .bus_type = V4L2_MBUS_UNKNOWN, 657 }; 658 struct v4l2_async_connection *asc; 659 int ret; 660 661 ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(vin->dev), 0, 0, 0); 662 if (!ep) 663 return 0; 664 665 fwnode = fwnode_graph_get_remote_endpoint(ep); 666 ret = v4l2_fwnode_endpoint_parse(ep, &vep); 667 fwnode_handle_put(ep); 668 if (ret) { 669 vin_err(vin, "Failed to parse %pOF\n", to_of_node(fwnode)); 670 ret = -EINVAL; 671 goto out; 672 } 673 674 switch (vep.bus_type) { 675 case V4L2_MBUS_PARALLEL: 676 case V4L2_MBUS_BT656: 677 vin_dbg(vin, "Found %s media bus\n", 678 vep.bus_type == V4L2_MBUS_PARALLEL ? 679 "PARALLEL" : "BT656"); 680 vin->parallel.mbus_type = vep.bus_type; 681 vin->parallel.bus = vep.bus.parallel; 682 break; 683 default: 684 vin_err(vin, "Unknown media bus type\n"); 685 ret = -EINVAL; 686 goto out; 687 } 688 689 asc = v4l2_async_nf_add_fwnode(&vin->notifier, fwnode, 690 struct v4l2_async_connection); 691 if (IS_ERR(asc)) { 692 ret = PTR_ERR(asc); 693 goto out; 694 } 695 696 vin->parallel.asc = asc; 697 698 vin_dbg(vin, "Add parallel OF device %pOF\n", to_of_node(fwnode)); 699 out: 700 fwnode_handle_put(fwnode); 701 702 return ret; 703 } 704 705 static void rvin_parallel_cleanup(struct rvin_dev *vin) 706 { 707 v4l2_async_nf_unregister(&vin->notifier); 708 v4l2_async_nf_cleanup(&vin->notifier); 709 } 710 711 static int rvin_parallel_init(struct rvin_dev *vin) 712 { 713 int ret; 714 715 v4l2_async_nf_init(&vin->notifier, &vin->v4l2_dev); 716 717 ret = rvin_parallel_parse_of(vin); 718 if (ret) 719 return ret; 720 721 if (!vin->parallel.asc) 722 return -ENODEV; 723 724 vin_dbg(vin, "Found parallel subdevice %pOF\n", 725 to_of_node(vin->parallel.asc->match.fwnode)); 726 727 vin->notifier.ops = &rvin_parallel_notify_ops; 728 ret = v4l2_async_nf_register(&vin->notifier); 729 if (ret < 0) { 730 vin_err(vin, "Notifier registration failed\n"); 731 v4l2_async_nf_cleanup(&vin->notifier); 732 return ret; 733 } 734 735 return 0; 736 } 737 738 /* ----------------------------------------------------------------------------- 739 * CSI-2 740 */ 741 742 /* 743 * Link setup for the links between a VIN and a CSI-2 receiver is a bit 744 * complex. The reason for this is that the register controlling routing 745 * is not present in each VIN instance. There are special VINs which 746 * control routing for themselves and other VINs. There are not many 747 * different possible links combinations that can be enabled at the same 748 * time, therefor all already enabled links which are controlled by a 749 * master VIN need to be taken into account when making the decision 750 * if a new link can be enabled or not. 751 * 752 * 1. Find out which VIN the link the user tries to enable is connected to. 753 * 2. Lookup which master VIN controls the links for this VIN. 754 * 3. Start with a bitmask with all bits set. 755 * 4. For each previously enabled link from the master VIN bitwise AND its 756 * route mask (see documentation for mask in struct rvin_group_route) 757 * with the bitmask. 758 * 5. Bitwise AND the mask for the link the user tries to enable to the bitmask. 759 * 6. If the bitmask is not empty at this point the new link can be enabled 760 * while keeping all previous links enabled. Update the CHSEL value of the 761 * master VIN and inform the user that the link could be enabled. 762 * 763 * Please note that no link can be enabled if any VIN in the group is 764 * currently open. 765 */ 766 static int rvin_csi2_link_notify(struct media_link *link, u32 flags, 767 unsigned int notification) 768 { 769 struct rvin_group *group = container_of(link->graph_obj.mdev, 770 struct rvin_group, mdev); 771 struct media_entity *entity; 772 struct video_device *vdev; 773 struct rvin_dev *vin; 774 unsigned int i; 775 int csi_id, ret; 776 777 ret = v4l2_pipeline_link_notify(link, flags, notification); 778 if (ret) 779 return ret; 780 781 /* Only care about link enablement for VIN nodes. */ 782 if (!(flags & MEDIA_LNK_FL_ENABLED) || 783 !is_media_entity_v4l2_video_device(link->sink->entity)) 784 return 0; 785 786 /* 787 * Don't allow link changes if any stream in the graph is active as 788 * modifying the CHSEL register fields can disrupt running streams. 789 */ 790 media_device_for_each_entity(entity, &group->mdev) 791 if (media_entity_is_streaming(entity)) 792 return -EBUSY; 793 794 /* Find the master VIN that controls the routes. */ 795 vdev = media_entity_to_video_device(link->sink->entity); 796 vin = container_of(vdev, struct rvin_dev, vdev); 797 798 mutex_lock(&group->lock); 799 800 csi_id = rvin_group_entity_to_remote_id(group, link->source->entity); 801 if (csi_id == -ENODEV) { 802 struct v4l2_subdev *sd; 803 804 /* 805 * Make sure the source entity subdevice is registered as 806 * a parallel input of one of the enabled VINs if it is not 807 * one of the CSI-2 subdevices. 808 * 809 * No hardware configuration required for parallel inputs, 810 * we can return here. 811 */ 812 sd = media_entity_to_v4l2_subdev(link->source->entity); 813 for (i = 0; i < RCAR_VIN_NUM; i++) { 814 if (group->vin[i] && 815 group->vin[i]->parallel.subdev == sd) { 816 group->vin[i]->is_csi = false; 817 ret = 0; 818 goto out; 819 } 820 } 821 822 vin_err(vin, "Subdevice %s not registered to any VIN\n", 823 link->source->entity->name); 824 ret = -ENODEV; 825 } else { 826 const struct rvin_group_route *route; 827 unsigned int chsel = UINT_MAX; 828 unsigned int master_id; 829 830 master_id = rvin_group_id_to_master(vin->id); 831 832 if (WARN_ON(!group->vin[master_id])) { 833 ret = -ENODEV; 834 goto out; 835 } 836 837 /* Make sure group is connected to same CSI-2 */ 838 for (i = master_id; i < master_id + 4; i++) { 839 struct media_pad *csi_pad; 840 841 if (!group->vin[i]) 842 continue; 843 844 /* Get remote CSI-2, if any. */ 845 csi_pad = media_pad_remote_pad_first( 846 &group->vin[i]->vdev.entity.pads[0]); 847 if (!csi_pad) 848 continue; 849 850 if (csi_pad->entity != link->source->entity) { 851 vin_dbg(vin, "Already attached to %s\n", 852 csi_pad->entity->name); 853 ret = -EBUSY; 854 goto out; 855 } 856 } 857 858 for (route = vin->info->routes; route->chsel; route++) { 859 if (route->master == master_id && route->csi == csi_id) { 860 chsel = route->chsel; 861 break; 862 } 863 } 864 865 if (chsel == UINT_MAX) { 866 vin_err(vin, "No CHSEL value found\n"); 867 ret = -EINVAL; 868 goto out; 869 } 870 871 ret = rvin_set_channel_routing(group->vin[master_id], chsel); 872 if (ret) 873 goto out; 874 875 vin->is_csi = true; 876 } 877 out: 878 mutex_unlock(&group->lock); 879 880 return ret; 881 } 882 883 static const struct media_device_ops rvin_csi2_media_ops = { 884 .link_notify = rvin_csi2_link_notify, 885 }; 886 887 static int rvin_csi2_create_link(struct rvin_group *group, unsigned int id, 888 const struct rvin_group_route *route) 889 { 890 struct media_entity *source = &group->remotes[route->csi].subdev->entity; 891 struct media_entity *sink = &group->vin[id]->vdev.entity; 892 struct media_pad *sink_pad = &sink->pads[0]; 893 unsigned int channel; 894 int ret; 895 896 for (channel = 0; channel < 4; channel++) { 897 unsigned int source_idx = rvin_group_csi_channel_to_pad(channel); 898 struct media_pad *source_pad = &source->pads[source_idx]; 899 900 /* Skip if link already exists. */ 901 if (media_entity_find_link(source_pad, sink_pad)) 902 continue; 903 904 ret = media_create_pad_link(source, source_idx, sink, 0, 0); 905 if (ret) 906 return ret; 907 } 908 909 return 0; 910 } 911 912 static int rvin_csi2_setup_links(struct rvin_dev *vin) 913 { 914 const struct rvin_group_route *route; 915 unsigned int id; 916 int ret = -EINVAL; 917 918 /* Create all media device links between VINs and CSI-2's. */ 919 mutex_lock(&vin->group->lock); 920 for (route = vin->info->routes; route->chsel; route++) { 921 /* Check that VIN' master is part of the group. */ 922 if (!vin->group->vin[route->master]) 923 continue; 924 925 /* Check that CSI-2 is part of the group. */ 926 if (!vin->group->remotes[route->csi].subdev) 927 continue; 928 929 for (id = route->master; id < route->master + 4; id++) { 930 /* Check that VIN is part of the group. */ 931 if (!vin->group->vin[id]) 932 continue; 933 934 ret = rvin_csi2_create_link(vin->group, id, route); 935 if (ret) 936 goto out; 937 } 938 } 939 out: 940 mutex_unlock(&vin->group->lock); 941 942 return ret; 943 } 944 945 static void rvin_csi2_cleanup(struct rvin_dev *vin) 946 { 947 rvin_parallel_cleanup(vin); 948 rvin_group_notifier_cleanup(vin); 949 rvin_group_put(vin); 950 rvin_free_controls(vin); 951 } 952 953 static int rvin_csi2_init(struct rvin_dev *vin) 954 { 955 int ret; 956 957 vin->pad.flags = MEDIA_PAD_FL_SINK; 958 ret = media_entity_pads_init(&vin->vdev.entity, 1, &vin->pad); 959 if (ret) 960 return ret; 961 962 ret = rvin_create_controls(vin, NULL); 963 if (ret < 0) 964 return ret; 965 966 ret = rvin_group_get(vin, rvin_csi2_setup_links, &rvin_csi2_media_ops); 967 if (ret) 968 goto err_controls; 969 970 /* It's OK to not have a parallel subdevice. */ 971 ret = rvin_parallel_init(vin); 972 if (ret && ret != -ENODEV) 973 goto err_group; 974 975 ret = rvin_group_notifier_init(vin, 1, RVIN_CSI_MAX); 976 if (ret) 977 goto err_parallel; 978 979 return 0; 980 err_parallel: 981 rvin_parallel_cleanup(vin); 982 err_group: 983 rvin_group_put(vin); 984 err_controls: 985 rvin_free_controls(vin); 986 987 return ret; 988 } 989 990 /* ----------------------------------------------------------------------------- 991 * ISP 992 */ 993 994 static int rvin_isp_setup_links(struct rvin_dev *vin) 995 { 996 unsigned int i; 997 int ret = -EINVAL; 998 999 /* Create all media device links between VINs and ISP's. */ 1000 mutex_lock(&vin->group->lock); 1001 for (i = 0; i < RCAR_VIN_NUM; i++) { 1002 struct media_pad *source_pad, *sink_pad; 1003 struct media_entity *source, *sink; 1004 unsigned int source_slot = i / 8; 1005 unsigned int source_idx = i % 8 + 1; 1006 1007 if (!vin->group->vin[i]) 1008 continue; 1009 1010 /* Check that ISP is part of the group. */ 1011 if (!vin->group->remotes[source_slot].subdev) 1012 continue; 1013 1014 source = &vin->group->remotes[source_slot].subdev->entity; 1015 source_pad = &source->pads[source_idx]; 1016 1017 sink = &vin->group->vin[i]->vdev.entity; 1018 sink_pad = &sink->pads[0]; 1019 1020 /* Skip if link already exists. */ 1021 if (media_entity_find_link(source_pad, sink_pad)) 1022 continue; 1023 1024 ret = media_create_pad_link(source, source_idx, sink, 0, 1025 MEDIA_LNK_FL_ENABLED | 1026 MEDIA_LNK_FL_IMMUTABLE); 1027 if (ret) { 1028 vin_err(vin, "Error adding link from %s to %s\n", 1029 source->name, sink->name); 1030 break; 1031 } 1032 } 1033 mutex_unlock(&vin->group->lock); 1034 1035 return ret; 1036 } 1037 1038 static void rvin_isp_cleanup(struct rvin_dev *vin) 1039 { 1040 rvin_group_notifier_cleanup(vin); 1041 rvin_group_put(vin); 1042 rvin_free_controls(vin); 1043 } 1044 1045 static int rvin_isp_init(struct rvin_dev *vin) 1046 { 1047 int ret; 1048 1049 vin->pad.flags = MEDIA_PAD_FL_SINK; 1050 ret = media_entity_pads_init(&vin->vdev.entity, 1, &vin->pad); 1051 if (ret) 1052 return ret; 1053 1054 ret = rvin_create_controls(vin, NULL); 1055 if (ret < 0) 1056 return ret; 1057 1058 ret = rvin_group_get(vin, rvin_isp_setup_links, NULL); 1059 if (ret) 1060 goto err_controls; 1061 1062 ret = rvin_group_notifier_init(vin, 2, RVIN_ISP_MAX); 1063 if (ret) 1064 goto err_group; 1065 1066 return 0; 1067 err_group: 1068 rvin_group_put(vin); 1069 err_controls: 1070 rvin_free_controls(vin); 1071 1072 return ret; 1073 } 1074 1075 /* ----------------------------------------------------------------------------- 1076 * Suspend / Resume 1077 */ 1078 1079 static int __maybe_unused rvin_suspend(struct device *dev) 1080 { 1081 struct rvin_dev *vin = dev_get_drvdata(dev); 1082 1083 if (vin->state != RUNNING) 1084 return 0; 1085 1086 rvin_stop_streaming(vin); 1087 1088 vin->state = SUSPENDED; 1089 1090 return 0; 1091 } 1092 1093 static int __maybe_unused rvin_resume(struct device *dev) 1094 { 1095 struct rvin_dev *vin = dev_get_drvdata(dev); 1096 1097 if (vin->state != SUSPENDED) 1098 return 0; 1099 1100 /* 1101 * Restore group master CHSEL setting. 1102 * 1103 * This needs to be done by every VIN resuming not only the master 1104 * as we don't know if and in which order the master VINs will 1105 * be resumed. 1106 */ 1107 if (vin->info->use_mc) { 1108 unsigned int master_id = rvin_group_id_to_master(vin->id); 1109 struct rvin_dev *master = vin->group->vin[master_id]; 1110 int ret; 1111 1112 if (WARN_ON(!master)) 1113 return -ENODEV; 1114 1115 ret = rvin_set_channel_routing(master, master->chsel); 1116 if (ret) 1117 return ret; 1118 } 1119 1120 return rvin_start_streaming(vin); 1121 } 1122 1123 /* ----------------------------------------------------------------------------- 1124 * Platform Device Driver 1125 */ 1126 1127 static const struct rvin_info rcar_info_h1 = { 1128 .model = RCAR_H1, 1129 .use_mc = false, 1130 .max_width = 2048, 1131 .max_height = 2048, 1132 .scaler = rvin_scaler_gen2, 1133 }; 1134 1135 static const struct rvin_info rcar_info_m1 = { 1136 .model = RCAR_M1, 1137 .use_mc = false, 1138 .max_width = 2048, 1139 .max_height = 2048, 1140 .scaler = rvin_scaler_gen2, 1141 }; 1142 1143 static const struct rvin_info rcar_info_gen2 = { 1144 .model = RCAR_GEN2, 1145 .use_mc = false, 1146 .max_width = 2048, 1147 .max_height = 2048, 1148 .scaler = rvin_scaler_gen2, 1149 }; 1150 1151 static const struct rvin_group_route rcar_info_r8a774e1_routes[] = { 1152 { .master = 0, .csi = RVIN_CSI20, .chsel = 0x04 }, 1153 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1154 { .master = 4, .csi = RVIN_CSI20, .chsel = 0x04 }, 1155 { /* Sentinel */ } 1156 }; 1157 1158 static const struct rvin_info rcar_info_r8a774e1 = { 1159 .model = RCAR_GEN3, 1160 .use_mc = true, 1161 .max_width = 4096, 1162 .max_height = 4096, 1163 .routes = rcar_info_r8a774e1_routes, 1164 }; 1165 1166 static const struct rvin_group_route rcar_info_r8a7795_routes[] = { 1167 { .master = 0, .csi = RVIN_CSI20, .chsel = 0x04 }, 1168 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1169 { .master = 4, .csi = RVIN_CSI20, .chsel = 0x04 }, 1170 { .master = 4, .csi = RVIN_CSI41, .chsel = 0x03 }, 1171 { /* Sentinel */ } 1172 }; 1173 1174 static const struct rvin_info rcar_info_r8a7795 = { 1175 .model = RCAR_GEN3, 1176 .use_mc = true, 1177 .nv12 = true, 1178 .max_width = 4096, 1179 .max_height = 4096, 1180 .routes = rcar_info_r8a7795_routes, 1181 .scaler = rvin_scaler_gen3, 1182 }; 1183 1184 static const struct rvin_group_route rcar_info_r8a7796_routes[] = { 1185 { .master = 0, .csi = RVIN_CSI20, .chsel = 0x04 }, 1186 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1187 { .master = 4, .csi = RVIN_CSI20, .chsel = 0x04 }, 1188 { .master = 4, .csi = RVIN_CSI40, .chsel = 0x03 }, 1189 { /* Sentinel */ } 1190 }; 1191 1192 static const struct rvin_info rcar_info_r8a7796 = { 1193 .model = RCAR_GEN3, 1194 .use_mc = true, 1195 .nv12 = true, 1196 .max_width = 4096, 1197 .max_height = 4096, 1198 .routes = rcar_info_r8a7796_routes, 1199 .scaler = rvin_scaler_gen3, 1200 }; 1201 1202 static const struct rvin_group_route rcar_info_r8a77965_routes[] = { 1203 { .master = 0, .csi = RVIN_CSI20, .chsel = 0x04 }, 1204 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1205 { .master = 4, .csi = RVIN_CSI20, .chsel = 0x04 }, 1206 { .master = 4, .csi = RVIN_CSI40, .chsel = 0x03 }, 1207 { /* Sentinel */ } 1208 }; 1209 1210 static const struct rvin_info rcar_info_r8a77965 = { 1211 .model = RCAR_GEN3, 1212 .use_mc = true, 1213 .nv12 = true, 1214 .max_width = 4096, 1215 .max_height = 4096, 1216 .routes = rcar_info_r8a77965_routes, 1217 .scaler = rvin_scaler_gen3, 1218 }; 1219 1220 static const struct rvin_group_route rcar_info_r8a77970_routes[] = { 1221 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1222 { /* Sentinel */ } 1223 }; 1224 1225 static const struct rvin_info rcar_info_r8a77970 = { 1226 .model = RCAR_GEN3, 1227 .use_mc = true, 1228 .max_width = 4096, 1229 .max_height = 4096, 1230 .routes = rcar_info_r8a77970_routes, 1231 }; 1232 1233 static const struct rvin_group_route rcar_info_r8a77980_routes[] = { 1234 { .master = 0, .csi = RVIN_CSI40, .chsel = 0x03 }, 1235 { .master = 4, .csi = RVIN_CSI41, .chsel = 0x03 }, 1236 { /* Sentinel */ } 1237 }; 1238 1239 static const struct rvin_info rcar_info_r8a77980 = { 1240 .model = RCAR_GEN3, 1241 .use_mc = true, 1242 .nv12 = true, 1243 .max_width = 4096, 1244 .max_height = 4096, 1245 .routes = rcar_info_r8a77980_routes, 1246 }; 1247 1248 static const struct rvin_group_route rcar_info_r8a77990_routes[] = { 1249 { .master = 4, .csi = RVIN_CSI40, .chsel = 0x03 }, 1250 { /* Sentinel */ } 1251 }; 1252 1253 static const struct rvin_info rcar_info_r8a77990 = { 1254 .model = RCAR_GEN3, 1255 .use_mc = true, 1256 .nv12 = true, 1257 .max_width = 4096, 1258 .max_height = 4096, 1259 .routes = rcar_info_r8a77990_routes, 1260 .scaler = rvin_scaler_gen3, 1261 }; 1262 1263 static const struct rvin_group_route rcar_info_r8a77995_routes[] = { 1264 { /* Sentinel */ } 1265 }; 1266 1267 static const struct rvin_info rcar_info_r8a77995 = { 1268 .model = RCAR_GEN3, 1269 .use_mc = true, 1270 .nv12 = true, 1271 .max_width = 4096, 1272 .max_height = 4096, 1273 .routes = rcar_info_r8a77995_routes, 1274 .scaler = rvin_scaler_gen3, 1275 }; 1276 1277 static const struct rvin_info rcar_info_r8a779a0 = { 1278 .model = RCAR_GEN3, 1279 .use_mc = true, 1280 .use_isp = true, 1281 .nv12 = true, 1282 .max_width = 4096, 1283 .max_height = 4096, 1284 }; 1285 1286 static const struct rvin_info rcar_info_r8a779g0 = { 1287 .model = RCAR_GEN3, 1288 .use_mc = true, 1289 .use_isp = true, 1290 .nv12 = true, 1291 .max_width = 4096, 1292 .max_height = 4096, 1293 }; 1294 1295 static const struct of_device_id rvin_of_id_table[] = { 1296 { 1297 .compatible = "renesas,vin-r8a774a1", 1298 .data = &rcar_info_r8a7796, 1299 }, 1300 { 1301 .compatible = "renesas,vin-r8a774b1", 1302 .data = &rcar_info_r8a77965, 1303 }, 1304 { 1305 .compatible = "renesas,vin-r8a774c0", 1306 .data = &rcar_info_r8a77990, 1307 }, 1308 { 1309 .compatible = "renesas,vin-r8a774e1", 1310 .data = &rcar_info_r8a774e1, 1311 }, 1312 { 1313 .compatible = "renesas,vin-r8a7778", 1314 .data = &rcar_info_m1, 1315 }, 1316 { 1317 .compatible = "renesas,vin-r8a7779", 1318 .data = &rcar_info_h1, 1319 }, 1320 { 1321 .compatible = "renesas,rcar-gen2-vin", 1322 .data = &rcar_info_gen2, 1323 }, 1324 { 1325 .compatible = "renesas,vin-r8a7795", 1326 .data = &rcar_info_r8a7795, 1327 }, 1328 { 1329 .compatible = "renesas,vin-r8a7796", 1330 .data = &rcar_info_r8a7796, 1331 }, 1332 { 1333 .compatible = "renesas,vin-r8a77961", 1334 .data = &rcar_info_r8a7796, 1335 }, 1336 { 1337 .compatible = "renesas,vin-r8a77965", 1338 .data = &rcar_info_r8a77965, 1339 }, 1340 { 1341 .compatible = "renesas,vin-r8a77970", 1342 .data = &rcar_info_r8a77970, 1343 }, 1344 { 1345 .compatible = "renesas,vin-r8a77980", 1346 .data = &rcar_info_r8a77980, 1347 }, 1348 { 1349 .compatible = "renesas,vin-r8a77990", 1350 .data = &rcar_info_r8a77990, 1351 }, 1352 { 1353 .compatible = "renesas,vin-r8a77995", 1354 .data = &rcar_info_r8a77995, 1355 }, 1356 { 1357 .compatible = "renesas,vin-r8a779a0", 1358 .data = &rcar_info_r8a779a0, 1359 }, 1360 { 1361 .compatible = "renesas,vin-r8a779g0", 1362 .data = &rcar_info_r8a779g0, 1363 }, 1364 { /* Sentinel */ }, 1365 }; 1366 MODULE_DEVICE_TABLE(of, rvin_of_id_table); 1367 1368 static int rcar_vin_probe(struct platform_device *pdev) 1369 { 1370 struct rvin_dev *vin; 1371 int irq, ret; 1372 1373 vin = devm_kzalloc(&pdev->dev, sizeof(*vin), GFP_KERNEL); 1374 if (!vin) 1375 return -ENOMEM; 1376 1377 vin->dev = &pdev->dev; 1378 vin->info = of_device_get_match_data(&pdev->dev); 1379 vin->alpha = 0xff; 1380 1381 vin->base = devm_platform_ioremap_resource(pdev, 0); 1382 if (IS_ERR(vin->base)) 1383 return PTR_ERR(vin->base); 1384 1385 irq = platform_get_irq(pdev, 0); 1386 if (irq < 0) 1387 return irq; 1388 1389 ret = rvin_dma_register(vin, irq); 1390 if (ret) 1391 return ret; 1392 1393 platform_set_drvdata(pdev, vin); 1394 1395 if (vin->info->use_isp) { 1396 ret = rvin_isp_init(vin); 1397 } else if (vin->info->use_mc) { 1398 ret = rvin_csi2_init(vin); 1399 1400 if (vin->info->scaler && 1401 rvin_group_id_to_master(vin->id) == vin->id) 1402 vin->scaler = vin->info->scaler; 1403 } else { 1404 ret = rvin_parallel_init(vin); 1405 1406 if (vin->info->scaler) 1407 vin->scaler = vin->info->scaler; 1408 } 1409 1410 if (ret) { 1411 rvin_dma_unregister(vin); 1412 return ret; 1413 } 1414 1415 pm_suspend_ignore_children(&pdev->dev, true); 1416 pm_runtime_enable(&pdev->dev); 1417 1418 return 0; 1419 } 1420 1421 static void rcar_vin_remove(struct platform_device *pdev) 1422 { 1423 struct rvin_dev *vin = platform_get_drvdata(pdev); 1424 1425 pm_runtime_disable(&pdev->dev); 1426 1427 rvin_v4l2_unregister(vin); 1428 1429 if (vin->info->use_isp) 1430 rvin_isp_cleanup(vin); 1431 else if (vin->info->use_mc) 1432 rvin_csi2_cleanup(vin); 1433 else 1434 rvin_parallel_cleanup(vin); 1435 1436 rvin_dma_unregister(vin); 1437 } 1438 1439 static SIMPLE_DEV_PM_OPS(rvin_pm_ops, rvin_suspend, rvin_resume); 1440 1441 static struct platform_driver rcar_vin_driver = { 1442 .driver = { 1443 .name = "rcar-vin", 1444 .suppress_bind_attrs = true, 1445 .pm = &rvin_pm_ops, 1446 .of_match_table = rvin_of_id_table, 1447 }, 1448 .probe = rcar_vin_probe, 1449 .remove_new = rcar_vin_remove, 1450 }; 1451 1452 module_platform_driver(rcar_vin_driver); 1453 1454 MODULE_AUTHOR("Niklas Söderlund <niklas.soderlund@ragnatech.se>"); 1455 MODULE_DESCRIPTION("Renesas R-Car VIN camera host driver"); 1456 MODULE_LICENSE("GPL"); 1457