1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020 NVIDIA CORPORATION. All rights reserved. 4 */ 5 6 #include <linux/bitmap.h> 7 #include <linux/clk.h> 8 #include <linux/delay.h> 9 #include <linux/host1x.h> 10 #include <linux/lcm.h> 11 #include <linux/list.h> 12 #include <linux/module.h> 13 #include <linux/of.h> 14 #include <linux/of_graph.h> 15 #include <linux/of_platform.h> 16 #include <linux/platform_device.h> 17 #include <linux/regulator/consumer.h> 18 #include <linux/pm_runtime.h> 19 #include <linux/slab.h> 20 21 #include <media/v4l2-dv-timings.h> 22 #include <media/v4l2-event.h> 23 #include <media/v4l2-fh.h> 24 #include <media/v4l2-fwnode.h> 25 #include <media/v4l2-ioctl.h> 26 #include <media/videobuf2-dma-contig.h> 27 28 #include <soc/tegra/pmc.h> 29 30 #include "vi.h" 31 #include "video.h" 32 33 #define MAX_CID_CONTROLS 3 34 35 /** 36 * struct tegra_vi_graph_entity - Entity in the video graph 37 * 38 * @asd: subdev asynchronous registration information 39 * @entity: media entity from the corresponding V4L2 subdev 40 * @subdev: V4L2 subdev 41 */ 42 struct tegra_vi_graph_entity { 43 struct v4l2_async_connection asd; 44 struct media_entity *entity; 45 struct v4l2_subdev *subdev; 46 }; 47 48 static inline struct tegra_vi * 49 host1x_client_to_vi(struct host1x_client *client) 50 { 51 return container_of(client, struct tegra_vi, client); 52 } 53 54 static inline struct tegra_channel_buffer * 55 to_tegra_channel_buffer(struct vb2_v4l2_buffer *vb) 56 { 57 return container_of(vb, struct tegra_channel_buffer, buf); 58 } 59 60 static inline struct tegra_vi_graph_entity * 61 to_tegra_vi_graph_entity(struct v4l2_async_connection *asd) 62 { 63 return container_of(asd, struct tegra_vi_graph_entity, asd); 64 } 65 66 static int tegra_get_format_idx_by_code(struct tegra_vi *vi, 67 unsigned int code, 68 unsigned int offset) 69 { 70 unsigned int i; 71 72 for (i = offset; i < vi->soc->nformats; ++i) { 73 if (vi->soc->video_formats[i].code == code) 74 return i; 75 } 76 77 return -1; 78 } 79 80 static u32 tegra_get_format_fourcc_by_idx(struct tegra_vi *vi, 81 unsigned int index) 82 { 83 if (index >= vi->soc->nformats) 84 return -EINVAL; 85 86 return vi->soc->video_formats[index].fourcc; 87 } 88 89 static const struct tegra_video_format * 90 tegra_get_format_by_fourcc(struct tegra_vi *vi, u32 fourcc) 91 { 92 unsigned int i; 93 94 for (i = 0; i < vi->soc->nformats; ++i) { 95 if (vi->soc->video_formats[i].fourcc == fourcc) 96 return &vi->soc->video_formats[i]; 97 } 98 99 return NULL; 100 } 101 102 /* 103 * videobuf2 queue operations 104 */ 105 106 static int tegra_channel_queue_setup(struct vb2_queue *vq, 107 unsigned int *nbuffers, 108 unsigned int *nplanes, 109 unsigned int sizes[], 110 struct device *alloc_devs[]) 111 { 112 struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); 113 114 if (*nplanes) 115 return sizes[0] < chan->format.sizeimage ? -EINVAL : 0; 116 117 *nplanes = 1; 118 sizes[0] = chan->format.sizeimage; 119 alloc_devs[0] = chan->vi->dev; 120 121 if (chan->vi->ops->channel_queue_setup) 122 chan->vi->ops->channel_queue_setup(chan); 123 124 return 0; 125 } 126 127 static int tegra_channel_buffer_prepare(struct vb2_buffer *vb) 128 { 129 struct tegra_vi_channel *chan = vb2_get_drv_priv(vb->vb2_queue); 130 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 131 struct tegra_channel_buffer *buf = to_tegra_channel_buffer(vbuf); 132 unsigned long size = chan->format.sizeimage; 133 134 if (vb2_plane_size(vb, 0) < size) { 135 v4l2_err(chan->video.v4l2_dev, 136 "buffer too small (%lu < %lu)\n", 137 vb2_plane_size(vb, 0), size); 138 return -EINVAL; 139 } 140 141 vb2_set_plane_payload(vb, 0, size); 142 buf->chan = chan; 143 buf->addr = vb2_dma_contig_plane_dma_addr(vb, 0); 144 145 return 0; 146 } 147 148 static void tegra_channel_buffer_queue(struct vb2_buffer *vb) 149 { 150 struct tegra_vi_channel *chan = vb2_get_drv_priv(vb->vb2_queue); 151 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 152 struct tegra_channel_buffer *buf = to_tegra_channel_buffer(vbuf); 153 154 /* put buffer into the capture queue */ 155 spin_lock(&chan->start_lock); 156 list_add_tail(&buf->queue, &chan->capture); 157 spin_unlock(&chan->start_lock); 158 159 /* wait up kthread for capture */ 160 wake_up_interruptible(&chan->start_wait); 161 } 162 163 struct v4l2_subdev * 164 tegra_channel_get_remote_csi_subdev(struct tegra_vi_channel *chan) 165 { 166 struct media_pad *pad; 167 168 pad = media_pad_remote_pad_first(&chan->pad); 169 if (!pad) 170 return NULL; 171 172 return media_entity_to_v4l2_subdev(pad->entity); 173 } 174 175 /* 176 * Walk up the chain until the initial source (e.g. image sensor) 177 */ 178 struct v4l2_subdev * 179 tegra_channel_get_remote_source_subdev(struct tegra_vi_channel *chan) 180 { 181 struct media_pad *pad; 182 struct v4l2_subdev *subdev; 183 struct media_entity *entity; 184 185 subdev = tegra_channel_get_remote_csi_subdev(chan); 186 if (!subdev) 187 return NULL; 188 189 pad = &subdev->entity.pads[0]; 190 while (!(pad->flags & MEDIA_PAD_FL_SOURCE)) { 191 pad = media_pad_remote_pad_first(pad); 192 if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) 193 break; 194 entity = pad->entity; 195 pad = &entity->pads[0]; 196 subdev = media_entity_to_v4l2_subdev(entity); 197 } 198 199 return subdev; 200 } 201 202 static int tegra_channel_enable_stream(struct tegra_vi_channel *chan) 203 { 204 struct v4l2_subdev *subdev; 205 int ret; 206 207 subdev = tegra_channel_get_remote_csi_subdev(chan); 208 ret = v4l2_subdev_call(subdev, video, s_stream, true); 209 if (ret < 0 && ret != -ENOIOCTLCMD) 210 return ret; 211 212 return 0; 213 } 214 215 static int tegra_channel_disable_stream(struct tegra_vi_channel *chan) 216 { 217 struct v4l2_subdev *subdev; 218 int ret; 219 220 subdev = tegra_channel_get_remote_csi_subdev(chan); 221 ret = v4l2_subdev_call(subdev, video, s_stream, false); 222 if (ret < 0 && ret != -ENOIOCTLCMD) 223 return ret; 224 225 return 0; 226 } 227 228 int tegra_channel_set_stream(struct tegra_vi_channel *chan, bool on) 229 { 230 int ret; 231 232 if (on) 233 ret = tegra_channel_enable_stream(chan); 234 else 235 ret = tegra_channel_disable_stream(chan); 236 237 return ret; 238 } 239 240 void tegra_channel_release_buffers(struct tegra_vi_channel *chan, 241 enum vb2_buffer_state state) 242 { 243 struct tegra_channel_buffer *buf, *nbuf; 244 245 spin_lock(&chan->start_lock); 246 list_for_each_entry_safe(buf, nbuf, &chan->capture, queue) { 247 vb2_buffer_done(&buf->buf.vb2_buf, state); 248 list_del(&buf->queue); 249 } 250 spin_unlock(&chan->start_lock); 251 252 spin_lock(&chan->done_lock); 253 list_for_each_entry_safe(buf, nbuf, &chan->done, queue) { 254 vb2_buffer_done(&buf->buf.vb2_buf, state); 255 list_del(&buf->queue); 256 } 257 spin_unlock(&chan->done_lock); 258 } 259 260 static int tegra_channel_start_streaming(struct vb2_queue *vq, u32 count) 261 { 262 struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); 263 int ret; 264 265 ret = pm_runtime_resume_and_get(chan->vi->dev); 266 if (ret < 0) { 267 dev_err(chan->vi->dev, "failed to get runtime PM: %d\n", ret); 268 return ret; 269 } 270 271 ret = chan->vi->ops->vi_start_streaming(vq, count); 272 if (ret < 0) 273 pm_runtime_put(chan->vi->dev); 274 275 return ret; 276 } 277 278 static void tegra_channel_stop_streaming(struct vb2_queue *vq) 279 { 280 struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); 281 282 chan->vi->ops->vi_stop_streaming(vq); 283 pm_runtime_put(chan->vi->dev); 284 } 285 286 static const struct vb2_ops tegra_channel_queue_qops = { 287 .queue_setup = tegra_channel_queue_setup, 288 .buf_prepare = tegra_channel_buffer_prepare, 289 .buf_queue = tegra_channel_buffer_queue, 290 .wait_prepare = vb2_ops_wait_prepare, 291 .wait_finish = vb2_ops_wait_finish, 292 .start_streaming = tegra_channel_start_streaming, 293 .stop_streaming = tegra_channel_stop_streaming, 294 }; 295 296 /* 297 * V4L2 ioctl operations 298 */ 299 static int tegra_channel_querycap(struct file *file, void *fh, 300 struct v4l2_capability *cap) 301 { 302 struct tegra_vi_channel *chan = video_drvdata(file); 303 304 strscpy(cap->driver, "tegra-video", sizeof(cap->driver)); 305 strscpy(cap->card, chan->video.name, sizeof(cap->card)); 306 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", 307 dev_name(chan->vi->dev)); 308 309 return 0; 310 } 311 312 static int tegra_channel_g_parm(struct file *file, void *fh, 313 struct v4l2_streamparm *a) 314 { 315 struct tegra_vi_channel *chan = video_drvdata(file); 316 struct v4l2_subdev *subdev; 317 318 subdev = tegra_channel_get_remote_source_subdev(chan); 319 return v4l2_g_parm_cap(&chan->video, subdev, a); 320 } 321 322 static int tegra_channel_s_parm(struct file *file, void *fh, 323 struct v4l2_streamparm *a) 324 { 325 struct tegra_vi_channel *chan = video_drvdata(file); 326 struct v4l2_subdev *subdev; 327 328 subdev = tegra_channel_get_remote_source_subdev(chan); 329 return v4l2_s_parm_cap(&chan->video, subdev, a); 330 } 331 332 static int tegra_channel_enum_framesizes(struct file *file, void *fh, 333 struct v4l2_frmsizeenum *sizes) 334 { 335 int ret; 336 struct tegra_vi_channel *chan = video_drvdata(file); 337 struct v4l2_subdev *subdev; 338 const struct tegra_video_format *fmtinfo; 339 struct v4l2_subdev_frame_size_enum fse = { 340 .index = sizes->index, 341 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 342 }; 343 344 fmtinfo = tegra_get_format_by_fourcc(chan->vi, sizes->pixel_format); 345 if (!fmtinfo) 346 return -EINVAL; 347 348 fse.code = fmtinfo->code; 349 350 subdev = tegra_channel_get_remote_source_subdev(chan); 351 ret = v4l2_subdev_call(subdev, pad, enum_frame_size, NULL, &fse); 352 if (ret) 353 return ret; 354 355 sizes->type = V4L2_FRMSIZE_TYPE_DISCRETE; 356 sizes->discrete.width = fse.max_width; 357 sizes->discrete.height = fse.max_height; 358 359 return 0; 360 } 361 362 static int tegra_channel_enum_frameintervals(struct file *file, void *fh, 363 struct v4l2_frmivalenum *ivals) 364 { 365 int ret; 366 struct tegra_vi_channel *chan = video_drvdata(file); 367 struct v4l2_subdev *subdev; 368 const struct tegra_video_format *fmtinfo; 369 struct v4l2_subdev_frame_interval_enum fie = { 370 .index = ivals->index, 371 .width = ivals->width, 372 .height = ivals->height, 373 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 374 }; 375 376 fmtinfo = tegra_get_format_by_fourcc(chan->vi, ivals->pixel_format); 377 if (!fmtinfo) 378 return -EINVAL; 379 380 fie.code = fmtinfo->code; 381 382 subdev = tegra_channel_get_remote_source_subdev(chan); 383 ret = v4l2_subdev_call(subdev, pad, enum_frame_interval, NULL, &fie); 384 if (ret) 385 return ret; 386 387 ivals->type = V4L2_FRMIVAL_TYPE_DISCRETE; 388 ivals->discrete.numerator = fie.interval.numerator; 389 ivals->discrete.denominator = fie.interval.denominator; 390 391 return 0; 392 } 393 394 static int tegra_channel_enum_format(struct file *file, void *fh, 395 struct v4l2_fmtdesc *f) 396 { 397 struct tegra_vi_channel *chan = video_drvdata(file); 398 unsigned int index = 0, i; 399 unsigned long *fmts_bitmap = chan->tpg_fmts_bitmap; 400 401 if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) 402 fmts_bitmap = chan->fmts_bitmap; 403 404 if (f->index >= bitmap_weight(fmts_bitmap, MAX_FORMAT_NUM)) 405 return -EINVAL; 406 407 for (i = 0; i < f->index + 1; i++, index++) 408 index = find_next_bit(fmts_bitmap, MAX_FORMAT_NUM, index); 409 410 f->pixelformat = tegra_get_format_fourcc_by_idx(chan->vi, index - 1); 411 412 return 0; 413 } 414 415 static int tegra_channel_get_format(struct file *file, void *fh, 416 struct v4l2_format *format) 417 { 418 struct tegra_vi_channel *chan = video_drvdata(file); 419 420 format->fmt.pix = chan->format; 421 422 return 0; 423 } 424 425 static int __tegra_channel_try_format(struct tegra_vi_channel *chan, 426 struct v4l2_pix_format *pix) 427 { 428 const struct tegra_video_format *fmtinfo; 429 static struct lock_class_key key; 430 struct v4l2_subdev *subdev; 431 struct v4l2_subdev_format fmt = { 432 .which = V4L2_SUBDEV_FORMAT_TRY, 433 }; 434 struct v4l2_subdev_state *sd_state; 435 struct v4l2_subdev_frame_size_enum fse = { 436 .which = V4L2_SUBDEV_FORMAT_TRY, 437 }; 438 struct v4l2_subdev_selection sdsel = { 439 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 440 .target = V4L2_SEL_TGT_CROP_BOUNDS, 441 }; 442 int ret; 443 444 subdev = tegra_channel_get_remote_source_subdev(chan); 445 if (!subdev) 446 return -ENODEV; 447 448 /* 449 * FIXME: Drop this call, drivers are not supposed to use 450 * __v4l2_subdev_state_alloc(). 451 */ 452 sd_state = __v4l2_subdev_state_alloc(subdev, "tegra:state->lock", 453 &key); 454 if (IS_ERR(sd_state)) 455 return PTR_ERR(sd_state); 456 /* 457 * Retrieve the format information and if requested format isn't 458 * supported, keep the current format. 459 */ 460 fmtinfo = tegra_get_format_by_fourcc(chan->vi, pix->pixelformat); 461 if (!fmtinfo) { 462 pix->pixelformat = chan->format.pixelformat; 463 pix->colorspace = chan->format.colorspace; 464 fmtinfo = tegra_get_format_by_fourcc(chan->vi, 465 pix->pixelformat); 466 } 467 468 pix->field = V4L2_FIELD_NONE; 469 fmt.pad = 0; 470 v4l2_fill_mbus_format(&fmt.format, pix, fmtinfo->code); 471 472 /* 473 * Attempt to obtain the format size from subdev. 474 * If not available, try to get crop boundary from subdev. 475 */ 476 fse.code = fmtinfo->code; 477 ret = v4l2_subdev_call(subdev, pad, enum_frame_size, sd_state, &fse); 478 if (ret) { 479 if (!v4l2_subdev_has_op(subdev, pad, get_selection)) { 480 sd_state->pads->try_crop.width = 0; 481 sd_state->pads->try_crop.height = 0; 482 } else { 483 ret = v4l2_subdev_call(subdev, pad, get_selection, 484 NULL, &sdsel); 485 if (ret) 486 return -EINVAL; 487 488 sd_state->pads->try_crop.width = sdsel.r.width; 489 sd_state->pads->try_crop.height = sdsel.r.height; 490 } 491 } else { 492 sd_state->pads->try_crop.width = fse.max_width; 493 sd_state->pads->try_crop.height = fse.max_height; 494 } 495 496 ret = v4l2_subdev_call(subdev, pad, set_fmt, sd_state, &fmt); 497 if (ret < 0) 498 return ret; 499 500 v4l2_fill_pix_format(pix, &fmt.format); 501 chan->vi->ops->vi_fmt_align(pix, fmtinfo->bpp); 502 503 __v4l2_subdev_state_free(sd_state); 504 505 return 0; 506 } 507 508 static int tegra_channel_try_format(struct file *file, void *fh, 509 struct v4l2_format *format) 510 { 511 struct tegra_vi_channel *chan = video_drvdata(file); 512 513 return __tegra_channel_try_format(chan, &format->fmt.pix); 514 } 515 516 static void tegra_channel_update_gangports(struct tegra_vi_channel *chan) 517 { 518 if (chan->format.width <= 1920) 519 chan->numgangports = 1; 520 else 521 chan->numgangports = chan->totalports; 522 } 523 524 static int tegra_channel_set_format(struct file *file, void *fh, 525 struct v4l2_format *format) 526 { 527 struct tegra_vi_channel *chan = video_drvdata(file); 528 const struct tegra_video_format *fmtinfo; 529 struct v4l2_subdev_format fmt = { 530 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 531 }; 532 struct v4l2_subdev *subdev; 533 struct v4l2_pix_format *pix = &format->fmt.pix; 534 int ret; 535 536 if (vb2_is_busy(&chan->queue)) 537 return -EBUSY; 538 539 /* get supported format by try_fmt */ 540 ret = __tegra_channel_try_format(chan, pix); 541 if (ret) 542 return ret; 543 544 fmtinfo = tegra_get_format_by_fourcc(chan->vi, pix->pixelformat); 545 546 fmt.pad = 0; 547 v4l2_fill_mbus_format(&fmt.format, pix, fmtinfo->code); 548 subdev = tegra_channel_get_remote_source_subdev(chan); 549 ret = v4l2_subdev_call(subdev, pad, set_fmt, NULL, &fmt); 550 if (ret < 0) 551 return ret; 552 553 v4l2_fill_pix_format(pix, &fmt.format); 554 chan->vi->ops->vi_fmt_align(pix, fmtinfo->bpp); 555 556 chan->format = *pix; 557 chan->fmtinfo = fmtinfo; 558 tegra_channel_update_gangports(chan); 559 560 return 0; 561 } 562 563 static int tegra_channel_set_subdev_active_fmt(struct tegra_vi_channel *chan) 564 { 565 int ret, index; 566 struct v4l2_subdev *subdev; 567 struct v4l2_subdev_format fmt = { 568 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 569 }; 570 571 /* 572 * Initialize channel format to the sub-device active format if there 573 * is corresponding match in the Tegra supported video formats. 574 */ 575 subdev = tegra_channel_get_remote_source_subdev(chan); 576 ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); 577 if (ret) 578 return ret; 579 580 index = tegra_get_format_idx_by_code(chan->vi, fmt.format.code, 0); 581 if (index < 0) 582 return -EINVAL; 583 584 chan->fmtinfo = &chan->vi->soc->video_formats[index]; 585 v4l2_fill_pix_format(&chan->format, &fmt.format); 586 chan->format.pixelformat = chan->fmtinfo->fourcc; 587 chan->format.bytesperline = chan->format.width * chan->fmtinfo->bpp; 588 chan->format.sizeimage = chan->format.bytesperline * 589 chan->format.height; 590 chan->vi->ops->vi_fmt_align(&chan->format, chan->fmtinfo->bpp); 591 tegra_channel_update_gangports(chan); 592 593 return 0; 594 } 595 596 static int 597 tegra_channel_subscribe_event(struct v4l2_fh *fh, 598 const struct v4l2_event_subscription *sub) 599 { 600 switch (sub->type) { 601 case V4L2_EVENT_SOURCE_CHANGE: 602 return v4l2_event_subscribe(fh, sub, 4, NULL); 603 } 604 605 return v4l2_ctrl_subscribe_event(fh, sub); 606 } 607 608 static int tegra_channel_g_selection(struct file *file, void *priv, 609 struct v4l2_selection *sel) 610 { 611 struct tegra_vi_channel *chan = video_drvdata(file); 612 struct v4l2_subdev *subdev; 613 struct v4l2_subdev_format fmt = { 614 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 615 }; 616 struct v4l2_subdev_selection sdsel = { 617 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 618 .target = sel->target, 619 }; 620 int ret; 621 622 subdev = tegra_channel_get_remote_source_subdev(chan); 623 if (!v4l2_subdev_has_op(subdev, pad, get_selection)) 624 return -ENOTTY; 625 626 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 627 return -EINVAL; 628 /* 629 * Try the get selection operation and fallback to get format if not 630 * implemented. 631 */ 632 ret = v4l2_subdev_call(subdev, pad, get_selection, NULL, &sdsel); 633 if (!ret) 634 sel->r = sdsel.r; 635 if (ret != -ENOIOCTLCMD) 636 return ret; 637 638 ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); 639 if (ret < 0) 640 return ret; 641 642 sel->r.left = 0; 643 sel->r.top = 0; 644 sel->r.width = fmt.format.width; 645 sel->r.height = fmt.format.height; 646 647 return 0; 648 } 649 650 static int tegra_channel_s_selection(struct file *file, void *fh, 651 struct v4l2_selection *sel) 652 { 653 struct tegra_vi_channel *chan = video_drvdata(file); 654 struct v4l2_subdev *subdev; 655 int ret; 656 struct v4l2_subdev_selection sdsel = { 657 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 658 .target = sel->target, 659 .flags = sel->flags, 660 .r = sel->r, 661 }; 662 663 subdev = tegra_channel_get_remote_source_subdev(chan); 664 if (!v4l2_subdev_has_op(subdev, pad, set_selection)) 665 return -ENOTTY; 666 667 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 668 return -EINVAL; 669 670 if (vb2_is_busy(&chan->queue)) 671 return -EBUSY; 672 673 ret = v4l2_subdev_call(subdev, pad, set_selection, NULL, &sdsel); 674 if (!ret) { 675 sel->r = sdsel.r; 676 /* 677 * Subdev active format resolution may have changed during 678 * set selection operation. So, update channel format to 679 * the sub-device active format. 680 */ 681 return tegra_channel_set_subdev_active_fmt(chan); 682 } 683 684 return ret; 685 } 686 687 static int tegra_channel_g_edid(struct file *file, void *fh, 688 struct v4l2_edid *edid) 689 { 690 struct tegra_vi_channel *chan = video_drvdata(file); 691 struct v4l2_subdev *subdev; 692 693 subdev = tegra_channel_get_remote_source_subdev(chan); 694 if (!v4l2_subdev_has_op(subdev, pad, get_edid)) 695 return -ENOTTY; 696 697 return v4l2_subdev_call(subdev, pad, get_edid, edid); 698 } 699 700 static int tegra_channel_s_edid(struct file *file, void *fh, 701 struct v4l2_edid *edid) 702 { 703 struct tegra_vi_channel *chan = video_drvdata(file); 704 struct v4l2_subdev *subdev; 705 706 subdev = tegra_channel_get_remote_source_subdev(chan); 707 if (!v4l2_subdev_has_op(subdev, pad, set_edid)) 708 return -ENOTTY; 709 710 return v4l2_subdev_call(subdev, pad, set_edid, edid); 711 } 712 713 static int tegra_channel_g_dv_timings(struct file *file, void *fh, 714 struct v4l2_dv_timings *timings) 715 { 716 struct tegra_vi_channel *chan = video_drvdata(file); 717 struct v4l2_subdev *subdev; 718 719 subdev = tegra_channel_get_remote_source_subdev(chan); 720 if (!v4l2_subdev_has_op(subdev, video, g_dv_timings)) 721 return -ENOTTY; 722 723 return v4l2_device_call_until_err(chan->video.v4l2_dev, 0, 724 video, g_dv_timings, timings); 725 } 726 727 static int tegra_channel_s_dv_timings(struct file *file, void *fh, 728 struct v4l2_dv_timings *timings) 729 { 730 struct tegra_vi_channel *chan = video_drvdata(file); 731 struct v4l2_subdev *subdev; 732 struct v4l2_bt_timings *bt = &timings->bt; 733 struct v4l2_dv_timings curr_timings; 734 int ret; 735 736 subdev = tegra_channel_get_remote_source_subdev(chan); 737 if (!v4l2_subdev_has_op(subdev, video, s_dv_timings)) 738 return -ENOTTY; 739 740 ret = tegra_channel_g_dv_timings(file, fh, &curr_timings); 741 if (ret) 742 return ret; 743 744 if (v4l2_match_dv_timings(timings, &curr_timings, 0, false)) 745 return 0; 746 747 if (vb2_is_busy(&chan->queue)) 748 return -EBUSY; 749 750 ret = v4l2_device_call_until_err(chan->video.v4l2_dev, 0, 751 video, s_dv_timings, timings); 752 if (ret) 753 return ret; 754 755 chan->format.width = bt->width; 756 chan->format.height = bt->height; 757 chan->format.bytesperline = bt->width * chan->fmtinfo->bpp; 758 chan->format.sizeimage = chan->format.bytesperline * bt->height; 759 chan->vi->ops->vi_fmt_align(&chan->format, chan->fmtinfo->bpp); 760 tegra_channel_update_gangports(chan); 761 762 return 0; 763 } 764 765 static int tegra_channel_query_dv_timings(struct file *file, void *fh, 766 struct v4l2_dv_timings *timings) 767 { 768 struct tegra_vi_channel *chan = video_drvdata(file); 769 struct v4l2_subdev *subdev; 770 771 subdev = tegra_channel_get_remote_source_subdev(chan); 772 if (!v4l2_subdev_has_op(subdev, video, query_dv_timings)) 773 return -ENOTTY; 774 775 return v4l2_device_call_until_err(chan->video.v4l2_dev, 0, 776 video, query_dv_timings, timings); 777 } 778 779 static int tegra_channel_enum_dv_timings(struct file *file, void *fh, 780 struct v4l2_enum_dv_timings *timings) 781 { 782 struct tegra_vi_channel *chan = video_drvdata(file); 783 struct v4l2_subdev *subdev; 784 785 subdev = tegra_channel_get_remote_source_subdev(chan); 786 if (!v4l2_subdev_has_op(subdev, pad, enum_dv_timings)) 787 return -ENOTTY; 788 789 return v4l2_subdev_call(subdev, pad, enum_dv_timings, timings); 790 } 791 792 static int tegra_channel_dv_timings_cap(struct file *file, void *fh, 793 struct v4l2_dv_timings_cap *cap) 794 { 795 struct tegra_vi_channel *chan = video_drvdata(file); 796 struct v4l2_subdev *subdev; 797 798 subdev = tegra_channel_get_remote_source_subdev(chan); 799 if (!v4l2_subdev_has_op(subdev, pad, dv_timings_cap)) 800 return -ENOTTY; 801 802 return v4l2_subdev_call(subdev, pad, dv_timings_cap, cap); 803 } 804 805 static int tegra_channel_log_status(struct file *file, void *fh) 806 { 807 struct tegra_vi_channel *chan = video_drvdata(file); 808 809 v4l2_device_call_all(chan->video.v4l2_dev, 0, core, log_status); 810 811 return 0; 812 } 813 814 static int tegra_channel_enum_input(struct file *file, void *fh, 815 struct v4l2_input *inp) 816 { 817 struct tegra_vi_channel *chan = video_drvdata(file); 818 struct v4l2_subdev *subdev; 819 820 if (inp->index) 821 return -EINVAL; 822 823 inp->type = V4L2_INPUT_TYPE_CAMERA; 824 subdev = tegra_channel_get_remote_source_subdev(chan); 825 strscpy(inp->name, subdev->name, sizeof(inp->name)); 826 if (v4l2_subdev_has_op(subdev, pad, dv_timings_cap)) 827 inp->capabilities = V4L2_IN_CAP_DV_TIMINGS; 828 829 return 0; 830 } 831 832 static int tegra_channel_g_input(struct file *file, void *priv, 833 unsigned int *i) 834 { 835 *i = 0; 836 837 return 0; 838 } 839 840 static int tegra_channel_s_input(struct file *file, void *priv, 841 unsigned int input) 842 { 843 if (input > 0) 844 return -EINVAL; 845 846 return 0; 847 } 848 849 static const struct v4l2_ioctl_ops tegra_channel_ioctl_ops = { 850 .vidioc_querycap = tegra_channel_querycap, 851 .vidioc_g_parm = tegra_channel_g_parm, 852 .vidioc_s_parm = tegra_channel_s_parm, 853 .vidioc_enum_framesizes = tegra_channel_enum_framesizes, 854 .vidioc_enum_frameintervals = tegra_channel_enum_frameintervals, 855 .vidioc_enum_fmt_vid_cap = tegra_channel_enum_format, 856 .vidioc_g_fmt_vid_cap = tegra_channel_get_format, 857 .vidioc_s_fmt_vid_cap = tegra_channel_set_format, 858 .vidioc_try_fmt_vid_cap = tegra_channel_try_format, 859 .vidioc_enum_input = tegra_channel_enum_input, 860 .vidioc_g_input = tegra_channel_g_input, 861 .vidioc_s_input = tegra_channel_s_input, 862 .vidioc_reqbufs = vb2_ioctl_reqbufs, 863 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 864 .vidioc_querybuf = vb2_ioctl_querybuf, 865 .vidioc_qbuf = vb2_ioctl_qbuf, 866 .vidioc_dqbuf = vb2_ioctl_dqbuf, 867 .vidioc_create_bufs = vb2_ioctl_create_bufs, 868 .vidioc_expbuf = vb2_ioctl_expbuf, 869 .vidioc_streamon = vb2_ioctl_streamon, 870 .vidioc_streamoff = vb2_ioctl_streamoff, 871 .vidioc_subscribe_event = tegra_channel_subscribe_event, 872 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 873 .vidioc_g_selection = tegra_channel_g_selection, 874 .vidioc_s_selection = tegra_channel_s_selection, 875 .vidioc_g_edid = tegra_channel_g_edid, 876 .vidioc_s_edid = tegra_channel_s_edid, 877 .vidioc_g_dv_timings = tegra_channel_g_dv_timings, 878 .vidioc_s_dv_timings = tegra_channel_s_dv_timings, 879 .vidioc_query_dv_timings = tegra_channel_query_dv_timings, 880 .vidioc_enum_dv_timings = tegra_channel_enum_dv_timings, 881 .vidioc_dv_timings_cap = tegra_channel_dv_timings_cap, 882 .vidioc_log_status = tegra_channel_log_status, 883 }; 884 885 /* 886 * V4L2 file operations 887 */ 888 static const struct v4l2_file_operations tegra_channel_fops = { 889 .owner = THIS_MODULE, 890 .unlocked_ioctl = video_ioctl2, 891 .open = v4l2_fh_open, 892 .release = vb2_fop_release, 893 .read = vb2_fop_read, 894 .poll = vb2_fop_poll, 895 .mmap = vb2_fop_mmap, 896 }; 897 898 /* 899 * V4L2 control operations 900 */ 901 static int vi_s_ctrl(struct v4l2_ctrl *ctrl) 902 { 903 struct tegra_vi_channel *chan = container_of(ctrl->handler, 904 struct tegra_vi_channel, 905 ctrl_handler); 906 907 switch (ctrl->id) { 908 case V4L2_CID_TEST_PATTERN: 909 /* pattern change takes effect on next stream */ 910 chan->pg_mode = ctrl->val + 1; 911 break; 912 case V4L2_CID_TEGRA_SYNCPT_TIMEOUT_RETRY: 913 chan->syncpt_timeout_retry = ctrl->val; 914 break; 915 case V4L2_CID_HFLIP: 916 chan->hflip = ctrl->val; 917 break; 918 case V4L2_CID_VFLIP: 919 chan->vflip = ctrl->val; 920 break; 921 default: 922 return -EINVAL; 923 } 924 925 return 0; 926 } 927 928 static const struct v4l2_ctrl_ops vi_ctrl_ops = { 929 .s_ctrl = vi_s_ctrl, 930 }; 931 932 #if IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG) 933 static const char *const vi_pattern_strings[] = { 934 "Black/White Direct Mode", 935 "Color Patch Mode", 936 }; 937 #else 938 static const struct v4l2_ctrl_config syncpt_timeout_ctrl = { 939 .ops = &vi_ctrl_ops, 940 .id = V4L2_CID_TEGRA_SYNCPT_TIMEOUT_RETRY, 941 .name = "Syncpt timeout retry", 942 .type = V4L2_CTRL_TYPE_INTEGER, 943 .min = 1, 944 .max = 10000, 945 .step = 1, 946 .def = 5, 947 }; 948 #endif 949 950 static int tegra_channel_setup_ctrl_handler(struct tegra_vi_channel *chan) 951 { 952 int ret; 953 954 #if IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG) 955 /* add test pattern control handler to v4l2 device */ 956 v4l2_ctrl_new_std_menu_items(&chan->ctrl_handler, &vi_ctrl_ops, 957 V4L2_CID_TEST_PATTERN, 958 ARRAY_SIZE(vi_pattern_strings) - 1, 959 0, 0, vi_pattern_strings); 960 if (chan->ctrl_handler.error) { 961 dev_err(chan->vi->dev, "failed to add TPG ctrl handler: %d\n", 962 chan->ctrl_handler.error); 963 v4l2_ctrl_handler_free(&chan->ctrl_handler); 964 return chan->ctrl_handler.error; 965 } 966 #else 967 struct v4l2_subdev *subdev; 968 969 /* custom control */ 970 v4l2_ctrl_new_custom(&chan->ctrl_handler, &syncpt_timeout_ctrl, NULL); 971 if (chan->ctrl_handler.error) { 972 dev_err(chan->vi->dev, "failed to add %s ctrl handler: %d\n", 973 syncpt_timeout_ctrl.name, 974 chan->ctrl_handler.error); 975 v4l2_ctrl_handler_free(&chan->ctrl_handler); 976 return chan->ctrl_handler.error; 977 } 978 979 subdev = tegra_channel_get_remote_source_subdev(chan); 980 if (!subdev) 981 return -ENODEV; 982 983 ret = v4l2_ctrl_add_handler(&chan->ctrl_handler, subdev->ctrl_handler, 984 NULL, true); 985 if (ret < 0) { 986 dev_err(chan->vi->dev, 987 "failed to add subdev %s ctrl handler: %d\n", 988 subdev->name, ret); 989 v4l2_ctrl_handler_free(&chan->ctrl_handler); 990 return ret; 991 } 992 993 if (chan->vi->soc->has_h_v_flip) { 994 v4l2_ctrl_new_std(&chan->ctrl_handler, &vi_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0); 995 v4l2_ctrl_new_std(&chan->ctrl_handler, &vi_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0); 996 } 997 998 #endif 999 1000 /* setup the controls */ 1001 ret = v4l2_ctrl_handler_setup(&chan->ctrl_handler); 1002 if (ret < 0) { 1003 dev_err(chan->vi->dev, 1004 "failed to setup v4l2 ctrl handler: %d\n", ret); 1005 return ret; 1006 } 1007 1008 return 0; 1009 } 1010 1011 /* VI only support 2 formats in TPG mode */ 1012 static void vi_tpg_fmts_bitmap_init(struct tegra_vi_channel *chan) 1013 { 1014 int index; 1015 1016 bitmap_zero(chan->tpg_fmts_bitmap, MAX_FORMAT_NUM); 1017 1018 index = tegra_get_format_idx_by_code(chan->vi, 1019 MEDIA_BUS_FMT_SRGGB10_1X10, 0); 1020 bitmap_set(chan->tpg_fmts_bitmap, index, 1); 1021 1022 index = tegra_get_format_idx_by_code(chan->vi, 1023 MEDIA_BUS_FMT_RGB888_1X32_PADHI, 1024 0); 1025 bitmap_set(chan->tpg_fmts_bitmap, index, 1); 1026 } 1027 1028 static int vi_fmts_bitmap_init(struct tegra_vi_channel *chan) 1029 { 1030 int index, ret, match_code = 0; 1031 struct v4l2_subdev *subdev; 1032 struct v4l2_subdev_mbus_code_enum code = { 1033 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 1034 }; 1035 1036 bitmap_zero(chan->fmts_bitmap, MAX_FORMAT_NUM); 1037 1038 /* 1039 * Set the bitmap bits based on all the matched formats between the 1040 * available media bus formats of sub-device and the pre-defined Tegra 1041 * supported video formats. 1042 */ 1043 subdev = tegra_channel_get_remote_source_subdev(chan); 1044 while (1) { 1045 ret = v4l2_subdev_call(subdev, pad, enum_mbus_code, 1046 NULL, &code); 1047 if (ret < 0) 1048 break; 1049 1050 index = tegra_get_format_idx_by_code(chan->vi, code.code, 0); 1051 while (index >= 0) { 1052 bitmap_set(chan->fmts_bitmap, index, 1); 1053 if (!match_code) 1054 match_code = code.code; 1055 /* look for other formats with same mbus code */ 1056 index = tegra_get_format_idx_by_code(chan->vi, 1057 code.code, 1058 index + 1); 1059 } 1060 1061 code.index++; 1062 } 1063 1064 /* 1065 * Set the bitmap bit corresponding to default tegra video format if 1066 * there are no matched formats. 1067 */ 1068 if (!match_code) { 1069 match_code = chan->vi->soc->default_video_format->code; 1070 index = tegra_get_format_idx_by_code(chan->vi, match_code, 0); 1071 if (WARN_ON(index < 0)) 1072 return -EINVAL; 1073 1074 bitmap_set(chan->fmts_bitmap, index, 1); 1075 } 1076 1077 /* initialize channel format to the sub-device active format */ 1078 tegra_channel_set_subdev_active_fmt(chan); 1079 1080 return 0; 1081 } 1082 1083 static void tegra_channel_cleanup(struct tegra_vi_channel *chan) 1084 { 1085 v4l2_ctrl_handler_free(&chan->ctrl_handler); 1086 media_entity_cleanup(&chan->video.entity); 1087 chan->vi->ops->channel_host1x_syncpt_free(chan); 1088 mutex_destroy(&chan->video_lock); 1089 } 1090 1091 void tegra_channels_cleanup(struct tegra_vi *vi) 1092 { 1093 struct tegra_vi_channel *chan, *tmp; 1094 1095 if (!vi) 1096 return; 1097 1098 list_for_each_entry_safe(chan, tmp, &vi->vi_chans, list) { 1099 tegra_channel_cleanup(chan); 1100 list_del(&chan->list); 1101 kfree(chan); 1102 } 1103 } 1104 1105 static int tegra_channel_init(struct tegra_vi_channel *chan) 1106 { 1107 struct tegra_vi *vi = chan->vi; 1108 struct tegra_video_device *vid = dev_get_drvdata(vi->client.host); 1109 int ret; 1110 1111 mutex_init(&chan->video_lock); 1112 INIT_LIST_HEAD(&chan->capture); 1113 INIT_LIST_HEAD(&chan->done); 1114 spin_lock_init(&chan->start_lock); 1115 spin_lock_init(&chan->done_lock); 1116 init_waitqueue_head(&chan->start_wait); 1117 init_waitqueue_head(&chan->done_wait); 1118 1119 /* initialize the video format */ 1120 chan->fmtinfo = chan->vi->soc->default_video_format; 1121 chan->format.pixelformat = chan->fmtinfo->fourcc; 1122 chan->format.colorspace = V4L2_COLORSPACE_SRGB; 1123 chan->format.field = V4L2_FIELD_NONE; 1124 chan->format.width = TEGRA_DEF_WIDTH; 1125 chan->format.height = TEGRA_DEF_HEIGHT; 1126 chan->format.bytesperline = TEGRA_DEF_WIDTH * chan->fmtinfo->bpp; 1127 chan->format.sizeimage = chan->format.bytesperline * TEGRA_DEF_HEIGHT; 1128 vi->ops->vi_fmt_align(&chan->format, chan->fmtinfo->bpp); 1129 1130 ret = vi->ops->channel_host1x_syncpt_init(chan); 1131 if (ret) 1132 return ret; 1133 1134 /* initialize the media entity */ 1135 chan->pad.flags = MEDIA_PAD_FL_SINK; 1136 ret = media_entity_pads_init(&chan->video.entity, 1, &chan->pad); 1137 if (ret < 0) { 1138 dev_err(vi->dev, 1139 "failed to initialize media entity: %d\n", ret); 1140 goto free_syncpts; 1141 } 1142 1143 ret = v4l2_ctrl_handler_init(&chan->ctrl_handler, MAX_CID_CONTROLS); 1144 if (chan->ctrl_handler.error) { 1145 dev_err(vi->dev, 1146 "failed to initialize v4l2 ctrl handler: %d\n", ret); 1147 goto cleanup_media; 1148 } 1149 1150 /* initialize the video_device */ 1151 chan->video.fops = &tegra_channel_fops; 1152 chan->video.v4l2_dev = &vid->v4l2_dev; 1153 chan->video.release = video_device_release_empty; 1154 chan->video.queue = &chan->queue; 1155 snprintf(chan->video.name, sizeof(chan->video.name), "%s-%s-%u", 1156 dev_name(vi->dev), "output", chan->portnos[0]); 1157 chan->video.vfl_type = VFL_TYPE_VIDEO; 1158 chan->video.vfl_dir = VFL_DIR_RX; 1159 chan->video.ioctl_ops = &tegra_channel_ioctl_ops; 1160 chan->video.ctrl_handler = &chan->ctrl_handler; 1161 chan->video.lock = &chan->video_lock; 1162 chan->video.device_caps = V4L2_CAP_VIDEO_CAPTURE | 1163 V4L2_CAP_STREAMING | 1164 V4L2_CAP_READWRITE; 1165 video_set_drvdata(&chan->video, chan); 1166 1167 chan->queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1168 chan->queue.io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ; 1169 chan->queue.lock = &chan->video_lock; 1170 chan->queue.drv_priv = chan; 1171 chan->queue.buf_struct_size = sizeof(struct tegra_channel_buffer); 1172 chan->queue.ops = &tegra_channel_queue_qops; 1173 chan->queue.mem_ops = &vb2_dma_contig_memops; 1174 chan->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1175 chan->queue.min_buffers_needed = 2; 1176 chan->queue.dev = vi->dev; 1177 ret = vb2_queue_init(&chan->queue); 1178 if (ret < 0) { 1179 dev_err(vi->dev, "failed to initialize vb2 queue: %d\n", ret); 1180 goto free_v4l2_ctrl_hdl; 1181 } 1182 1183 if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) 1184 v4l2_async_nf_init(&chan->notifier, &vid->v4l2_dev); 1185 1186 return 0; 1187 1188 free_v4l2_ctrl_hdl: 1189 v4l2_ctrl_handler_free(&chan->ctrl_handler); 1190 cleanup_media: 1191 media_entity_cleanup(&chan->video.entity); 1192 free_syncpts: 1193 vi->ops->channel_host1x_syncpt_free(chan); 1194 return ret; 1195 } 1196 1197 static int tegra_vi_channel_alloc(struct tegra_vi *vi, unsigned int port_num, 1198 struct device_node *node, unsigned int lanes) 1199 { 1200 struct tegra_vi_channel *chan; 1201 unsigned int i; 1202 1203 /* 1204 * Do not use devm_kzalloc as memory is freed immediately 1205 * when device instance is unbound but application might still 1206 * be holding the device node open. Channel memory allocated 1207 * with kzalloc is freed during video device release callback. 1208 */ 1209 chan = kzalloc(sizeof(*chan), GFP_KERNEL); 1210 if (!chan) 1211 return -ENOMEM; 1212 1213 chan->vi = vi; 1214 chan->portnos[0] = port_num; 1215 /* 1216 * For data lanes more than maximum csi lanes per brick, multiple of 1217 * x4 ports are used simultaneously for capture. 1218 */ 1219 if (lanes <= CSI_LANES_PER_BRICK) 1220 chan->totalports = 1; 1221 else 1222 chan->totalports = lanes / CSI_LANES_PER_BRICK; 1223 chan->numgangports = chan->totalports; 1224 1225 for (i = 1; i < chan->totalports; i++) 1226 chan->portnos[i] = chan->portnos[0] + i * CSI_PORTS_PER_BRICK; 1227 1228 chan->of_node = node; 1229 list_add_tail(&chan->list, &vi->vi_chans); 1230 1231 return 0; 1232 } 1233 1234 static int tegra_vi_tpg_channels_alloc(struct tegra_vi *vi) 1235 { 1236 unsigned int port_num; 1237 unsigned int nchannels = vi->soc->vi_max_channels; 1238 int ret; 1239 1240 for (port_num = 0; port_num < nchannels; port_num++) { 1241 ret = tegra_vi_channel_alloc(vi, port_num, 1242 vi->dev->of_node, 2); 1243 if (ret < 0) 1244 return ret; 1245 } 1246 1247 return 0; 1248 } 1249 1250 static int tegra_vi_channels_alloc(struct tegra_vi *vi) 1251 { 1252 struct device_node *node = vi->dev->of_node; 1253 struct device_node *ep = NULL; 1254 struct device_node *ports; 1255 struct device_node *port = NULL; 1256 unsigned int port_num; 1257 struct device_node *parent; 1258 struct v4l2_fwnode_endpoint v4l2_ep = { .bus_type = 0 }; 1259 unsigned int lanes; 1260 int ret = 0; 1261 1262 ports = of_get_child_by_name(node, "ports"); 1263 if (!ports) 1264 return dev_err_probe(vi->dev, -ENODEV, "%pOF: missing 'ports' node\n", node); 1265 1266 for_each_child_of_node(ports, port) { 1267 if (!of_node_name_eq(port, "port")) 1268 continue; 1269 1270 ret = of_property_read_u32(port, "reg", &port_num); 1271 if (ret < 0) 1272 continue; 1273 1274 if (port_num > vi->soc->vi_max_channels) { 1275 dev_err(vi->dev, "invalid port num %d for %pOF\n", 1276 port_num, port); 1277 ret = -EINVAL; 1278 goto cleanup; 1279 } 1280 1281 ep = of_get_child_by_name(port, "endpoint"); 1282 if (!ep) 1283 continue; 1284 1285 parent = of_graph_get_remote_port_parent(ep); 1286 of_node_put(ep); 1287 if (!parent) 1288 continue; 1289 1290 ep = of_graph_get_endpoint_by_regs(parent, 0, 0); 1291 of_node_put(parent); 1292 ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), 1293 &v4l2_ep); 1294 of_node_put(ep); 1295 if (ret) 1296 continue; 1297 1298 lanes = v4l2_ep.bus.mipi_csi2.num_data_lanes; 1299 ret = tegra_vi_channel_alloc(vi, port_num, port, lanes); 1300 if (ret < 0) 1301 goto cleanup; 1302 } 1303 1304 cleanup: 1305 of_node_put(port); 1306 of_node_put(ports); 1307 return ret; 1308 } 1309 1310 static int tegra_vi_channels_init(struct tegra_vi *vi) 1311 { 1312 struct tegra_vi_channel *chan; 1313 int ret; 1314 1315 list_for_each_entry(chan, &vi->vi_chans, list) { 1316 ret = tegra_channel_init(chan); 1317 if (ret < 0) { 1318 dev_err(vi->dev, 1319 "failed to initialize channel-%d: %d\n", 1320 chan->portnos[0], ret); 1321 goto cleanup; 1322 } 1323 } 1324 1325 return 0; 1326 1327 cleanup: 1328 list_for_each_entry_continue_reverse(chan, &vi->vi_chans, list) 1329 tegra_channel_cleanup(chan); 1330 1331 return ret; 1332 } 1333 1334 void tegra_v4l2_nodes_cleanup_tpg(struct tegra_video_device *vid) 1335 { 1336 struct tegra_vi *vi = vid->vi; 1337 struct tegra_csi *csi = vid->csi; 1338 struct tegra_csi_channel *csi_chan; 1339 struct tegra_vi_channel *chan; 1340 1341 list_for_each_entry(chan, &vi->vi_chans, list) 1342 vb2_video_unregister_device(&chan->video); 1343 1344 list_for_each_entry(csi_chan, &csi->csi_chans, list) 1345 v4l2_device_unregister_subdev(&csi_chan->subdev); 1346 } 1347 1348 int tegra_v4l2_nodes_setup_tpg(struct tegra_video_device *vid) 1349 { 1350 struct tegra_vi *vi = vid->vi; 1351 struct tegra_csi *csi = vid->csi; 1352 struct tegra_vi_channel *vi_chan; 1353 struct tegra_csi_channel *csi_chan; 1354 u32 link_flags = MEDIA_LNK_FL_ENABLED; 1355 int ret; 1356 1357 if (!vi || !csi) 1358 return -ENODEV; 1359 1360 csi_chan = list_first_entry(&csi->csi_chans, 1361 struct tegra_csi_channel, list); 1362 1363 list_for_each_entry(vi_chan, &vi->vi_chans, list) { 1364 struct media_entity *source = &csi_chan->subdev.entity; 1365 struct media_entity *sink = &vi_chan->video.entity; 1366 struct media_pad *source_pad = csi_chan->pads; 1367 struct media_pad *sink_pad = &vi_chan->pad; 1368 1369 ret = v4l2_device_register_subdev(&vid->v4l2_dev, 1370 &csi_chan->subdev); 1371 if (ret) { 1372 dev_err(vi->dev, 1373 "failed to register subdev: %d\n", ret); 1374 goto cleanup; 1375 } 1376 1377 ret = video_register_device(&vi_chan->video, 1378 VFL_TYPE_VIDEO, -1); 1379 if (ret < 0) { 1380 dev_err(vi->dev, 1381 "failed to register video device: %d\n", ret); 1382 goto cleanup; 1383 } 1384 1385 dev_dbg(vi->dev, "creating %s:%u -> %s:%u link\n", 1386 source->name, source_pad->index, 1387 sink->name, sink_pad->index); 1388 1389 ret = media_create_pad_link(source, source_pad->index, 1390 sink, sink_pad->index, 1391 link_flags); 1392 if (ret < 0) { 1393 dev_err(vi->dev, 1394 "failed to create %s:%u -> %s:%u link: %d\n", 1395 source->name, source_pad->index, 1396 sink->name, sink_pad->index, ret); 1397 goto cleanup; 1398 } 1399 1400 ret = tegra_channel_setup_ctrl_handler(vi_chan); 1401 if (ret < 0) 1402 goto cleanup; 1403 1404 v4l2_set_subdev_hostdata(&csi_chan->subdev, vi_chan); 1405 vi_tpg_fmts_bitmap_init(vi_chan); 1406 csi_chan = list_next_entry(csi_chan, list); 1407 } 1408 1409 return 0; 1410 1411 cleanup: 1412 tegra_v4l2_nodes_cleanup_tpg(vid); 1413 return ret; 1414 } 1415 1416 static int __maybe_unused vi_runtime_resume(struct device *dev) 1417 { 1418 struct tegra_vi *vi = dev_get_drvdata(dev); 1419 int ret; 1420 1421 ret = regulator_enable(vi->vdd); 1422 if (ret) { 1423 dev_err(dev, "failed to enable VDD supply: %d\n", ret); 1424 return ret; 1425 } 1426 1427 ret = clk_set_rate(vi->clk, vi->soc->vi_max_clk_hz); 1428 if (ret) { 1429 dev_err(dev, "failed to set vi clock rate: %d\n", ret); 1430 goto disable_vdd; 1431 } 1432 1433 ret = clk_prepare_enable(vi->clk); 1434 if (ret) { 1435 dev_err(dev, "failed to enable vi clock: %d\n", ret); 1436 goto disable_vdd; 1437 } 1438 1439 return 0; 1440 1441 disable_vdd: 1442 regulator_disable(vi->vdd); 1443 return ret; 1444 } 1445 1446 static int __maybe_unused vi_runtime_suspend(struct device *dev) 1447 { 1448 struct tegra_vi *vi = dev_get_drvdata(dev); 1449 1450 clk_disable_unprepare(vi->clk); 1451 1452 regulator_disable(vi->vdd); 1453 1454 return 0; 1455 } 1456 1457 /* 1458 * Graph Management 1459 */ 1460 static struct tegra_vi_graph_entity * 1461 tegra_vi_graph_find_entity(struct tegra_vi_channel *chan, 1462 const struct fwnode_handle *fwnode) 1463 { 1464 struct tegra_vi_graph_entity *entity; 1465 struct v4l2_async_connection *asd; 1466 1467 list_for_each_entry(asd, &chan->notifier.done_list, asc_entry) { 1468 entity = to_tegra_vi_graph_entity(asd); 1469 if (entity->asd.match.fwnode == fwnode) 1470 return entity; 1471 } 1472 1473 return NULL; 1474 } 1475 1476 static int tegra_vi_graph_build(struct tegra_vi_channel *chan, 1477 struct tegra_vi_graph_entity *entity) 1478 { 1479 struct tegra_vi *vi = chan->vi; 1480 struct tegra_vi_graph_entity *ent; 1481 struct fwnode_handle *ep = NULL; 1482 struct v4l2_fwnode_link link; 1483 struct media_entity *local = entity->entity; 1484 struct media_entity *remote; 1485 struct media_pad *local_pad; 1486 struct media_pad *remote_pad; 1487 u32 link_flags = MEDIA_LNK_FL_ENABLED; 1488 int ret = 0; 1489 1490 dev_dbg(vi->dev, "creating links for entity %s\n", local->name); 1491 1492 while (1) { 1493 ep = fwnode_graph_get_next_endpoint(entity->asd.match.fwnode, 1494 ep); 1495 if (!ep) 1496 break; 1497 1498 ret = v4l2_fwnode_parse_link(ep, &link); 1499 if (ret < 0) { 1500 dev_err(vi->dev, "failed to parse link for %pOF: %d\n", 1501 to_of_node(ep), ret); 1502 continue; 1503 } 1504 1505 if (link.local_port >= local->num_pads) { 1506 dev_err(vi->dev, "invalid port number %u on %pOF\n", 1507 link.local_port, to_of_node(link.local_node)); 1508 v4l2_fwnode_put_link(&link); 1509 ret = -EINVAL; 1510 break; 1511 } 1512 1513 local_pad = &local->pads[link.local_port]; 1514 /* Remote node is vi node. So use channel video entity and pad 1515 * as remote/sink. 1516 */ 1517 if (link.remote_node == of_fwnode_handle(vi->dev->of_node)) { 1518 remote = &chan->video.entity; 1519 remote_pad = &chan->pad; 1520 goto create_link; 1521 } 1522 1523 /* 1524 * Skip sink ports, they will be processed from the other end 1525 * of the link. 1526 */ 1527 if (local_pad->flags & MEDIA_PAD_FL_SINK) { 1528 dev_dbg(vi->dev, "skipping sink port %pOF:%u\n", 1529 to_of_node(link.local_node), link.local_port); 1530 v4l2_fwnode_put_link(&link); 1531 continue; 1532 } 1533 1534 /* find the remote entity from notifier list */ 1535 ent = tegra_vi_graph_find_entity(chan, link.remote_node); 1536 if (!ent) { 1537 dev_err(vi->dev, "no entity found for %pOF\n", 1538 to_of_node(link.remote_node)); 1539 v4l2_fwnode_put_link(&link); 1540 ret = -ENODEV; 1541 break; 1542 } 1543 1544 remote = ent->entity; 1545 if (link.remote_port >= remote->num_pads) { 1546 dev_err(vi->dev, "invalid port number %u on %pOF\n", 1547 link.remote_port, 1548 to_of_node(link.remote_node)); 1549 v4l2_fwnode_put_link(&link); 1550 ret = -EINVAL; 1551 break; 1552 } 1553 1554 remote_pad = &remote->pads[link.remote_port]; 1555 1556 create_link: 1557 dev_dbg(vi->dev, "creating %s:%u -> %s:%u link\n", 1558 local->name, local_pad->index, 1559 remote->name, remote_pad->index); 1560 1561 ret = media_create_pad_link(local, local_pad->index, 1562 remote, remote_pad->index, 1563 link_flags); 1564 v4l2_fwnode_put_link(&link); 1565 if (ret < 0) { 1566 dev_err(vi->dev, 1567 "failed to create %s:%u -> %s:%u link: %d\n", 1568 local->name, local_pad->index, 1569 remote->name, remote_pad->index, ret); 1570 break; 1571 } 1572 } 1573 1574 fwnode_handle_put(ep); 1575 return ret; 1576 } 1577 1578 static int tegra_vi_graph_notify_complete(struct v4l2_async_notifier *notifier) 1579 { 1580 struct tegra_vi_graph_entity *entity; 1581 struct v4l2_async_connection *asd; 1582 struct v4l2_subdev *subdev; 1583 struct tegra_vi_channel *chan; 1584 struct tegra_vi *vi; 1585 int ret; 1586 1587 chan = container_of(notifier, struct tegra_vi_channel, notifier); 1588 vi = chan->vi; 1589 1590 dev_dbg(vi->dev, "notify complete, all subdevs registered\n"); 1591 1592 /* 1593 * Video device node should be created at the end of all the device 1594 * related initialization/setup. 1595 * Current video_register_device() does both initialize and register 1596 * video device in same API. 1597 * 1598 * TODO: Update v4l2-dev driver to split initialize and register into 1599 * separate APIs and then update Tegra video driver to do video device 1600 * initialize followed by all video device related setup and then 1601 * register the video device. 1602 */ 1603 ret = video_register_device(&chan->video, VFL_TYPE_VIDEO, -1); 1604 if (ret < 0) { 1605 dev_err(vi->dev, 1606 "failed to register video device: %d\n", ret); 1607 goto unregister_video; 1608 } 1609 1610 /* create links between the entities */ 1611 list_for_each_entry(asd, &chan->notifier.done_list, asc_entry) { 1612 entity = to_tegra_vi_graph_entity(asd); 1613 ret = tegra_vi_graph_build(chan, entity); 1614 if (ret < 0) 1615 goto unregister_video; 1616 } 1617 1618 ret = tegra_channel_setup_ctrl_handler(chan); 1619 if (ret < 0) { 1620 dev_err(vi->dev, 1621 "failed to setup channel controls: %d\n", ret); 1622 goto unregister_video; 1623 } 1624 1625 ret = vi_fmts_bitmap_init(chan); 1626 if (ret < 0) { 1627 dev_err(vi->dev, 1628 "failed to initialize formats bitmap: %d\n", ret); 1629 goto unregister_video; 1630 } 1631 1632 subdev = tegra_channel_get_remote_csi_subdev(chan); 1633 if (!subdev) { 1634 ret = -ENODEV; 1635 dev_err(vi->dev, 1636 "failed to get remote csi subdev: %d\n", ret); 1637 goto unregister_video; 1638 } 1639 1640 v4l2_set_subdev_hostdata(subdev, chan); 1641 1642 subdev = tegra_channel_get_remote_source_subdev(chan); 1643 v4l2_set_subdev_hostdata(subdev, chan); 1644 1645 return 0; 1646 1647 unregister_video: 1648 vb2_video_unregister_device(&chan->video); 1649 return ret; 1650 } 1651 1652 static int tegra_vi_graph_notify_bound(struct v4l2_async_notifier *notifier, 1653 struct v4l2_subdev *subdev, 1654 struct v4l2_async_connection *asd) 1655 { 1656 struct tegra_vi_graph_entity *entity; 1657 struct tegra_vi *vi; 1658 struct tegra_vi_channel *chan; 1659 1660 chan = container_of(notifier, struct tegra_vi_channel, notifier); 1661 vi = chan->vi; 1662 1663 /* 1664 * Locate the entity corresponding to the bound subdev and store the 1665 * subdev pointer. 1666 */ 1667 entity = tegra_vi_graph_find_entity(chan, subdev->fwnode); 1668 if (!entity) { 1669 dev_err(vi->dev, "no entity for subdev %s\n", subdev->name); 1670 return -EINVAL; 1671 } 1672 1673 if (entity->subdev) { 1674 dev_err(vi->dev, "duplicate subdev for node %pOF\n", 1675 to_of_node(entity->asd.match.fwnode)); 1676 return -EINVAL; 1677 } 1678 1679 dev_dbg(vi->dev, "subdev %s bound\n", subdev->name); 1680 entity->entity = &subdev->entity; 1681 entity->subdev = subdev; 1682 1683 return 0; 1684 } 1685 1686 static const struct v4l2_async_notifier_operations tegra_vi_async_ops = { 1687 .bound = tegra_vi_graph_notify_bound, 1688 .complete = tegra_vi_graph_notify_complete, 1689 }; 1690 1691 static int tegra_vi_graph_parse_one(struct tegra_vi_channel *chan, 1692 struct fwnode_handle *fwnode) 1693 { 1694 struct tegra_vi *vi = chan->vi; 1695 struct fwnode_handle *ep = NULL; 1696 struct fwnode_handle *remote = NULL; 1697 struct tegra_vi_graph_entity *tvge; 1698 struct device_node *node = NULL; 1699 int ret; 1700 1701 dev_dbg(vi->dev, "parsing node %pOF\n", to_of_node(fwnode)); 1702 1703 /* parse all the remote entities and put them into the list */ 1704 for_each_endpoint_of_node(to_of_node(fwnode), node) { 1705 ep = of_fwnode_handle(node); 1706 remote = fwnode_graph_get_remote_port_parent(ep); 1707 if (!remote) { 1708 dev_err(vi->dev, 1709 "remote device at %pOF not found\n", node); 1710 ret = -EINVAL; 1711 goto cleanup; 1712 } 1713 1714 /* skip entities that are already processed */ 1715 if (device_match_fwnode(vi->dev, remote) || 1716 tegra_vi_graph_find_entity(chan, remote)) { 1717 fwnode_handle_put(remote); 1718 continue; 1719 } 1720 1721 tvge = v4l2_async_nf_add_fwnode(&chan->notifier, remote, 1722 struct tegra_vi_graph_entity); 1723 if (IS_ERR(tvge)) { 1724 ret = PTR_ERR(tvge); 1725 dev_err(vi->dev, 1726 "failed to add subdev to notifier: %d\n", ret); 1727 fwnode_handle_put(remote); 1728 goto cleanup; 1729 } 1730 1731 ret = tegra_vi_graph_parse_one(chan, remote); 1732 if (ret < 0) { 1733 fwnode_handle_put(remote); 1734 goto cleanup; 1735 } 1736 1737 fwnode_handle_put(remote); 1738 } 1739 1740 return 0; 1741 1742 cleanup: 1743 dev_err(vi->dev, "failed parsing the graph: %d\n", ret); 1744 v4l2_async_nf_cleanup(&chan->notifier); 1745 of_node_put(node); 1746 return ret; 1747 } 1748 1749 static int tegra_vi_graph_init(struct tegra_vi *vi) 1750 { 1751 struct tegra_vi_channel *chan; 1752 struct fwnode_handle *fwnode = dev_fwnode(vi->dev); 1753 int ret; 1754 1755 /* 1756 * Walk the links to parse the full graph. Each channel will have 1757 * one endpoint of the composite node. Start by parsing the 1758 * composite node and parse the remote entities in turn. 1759 * Each channel will register a v4l2 async notifier to make the graph 1760 * independent between the channels so we can skip the current channel 1761 * in case of something wrong during graph parsing and continue with 1762 * the next channels. 1763 */ 1764 list_for_each_entry(chan, &vi->vi_chans, list) { 1765 struct fwnode_handle *ep, *remote; 1766 1767 ep = fwnode_graph_get_endpoint_by_id(fwnode, 1768 chan->portnos[0], 0, 0); 1769 if (!ep) 1770 continue; 1771 1772 remote = fwnode_graph_get_remote_port_parent(ep); 1773 fwnode_handle_put(ep); 1774 1775 ret = tegra_vi_graph_parse_one(chan, remote); 1776 fwnode_handle_put(remote); 1777 if (ret < 0 || list_empty(&chan->notifier.waiting_list)) 1778 continue; 1779 1780 chan->notifier.ops = &tegra_vi_async_ops; 1781 ret = v4l2_async_nf_register(&chan->notifier); 1782 if (ret < 0) { 1783 dev_err(vi->dev, 1784 "failed to register channel %d notifier: %d\n", 1785 chan->portnos[0], ret); 1786 v4l2_async_nf_cleanup(&chan->notifier); 1787 } 1788 } 1789 1790 return 0; 1791 } 1792 1793 static void tegra_vi_graph_cleanup(struct tegra_vi *vi) 1794 { 1795 struct tegra_vi_channel *chan; 1796 1797 list_for_each_entry(chan, &vi->vi_chans, list) { 1798 vb2_video_unregister_device(&chan->video); 1799 v4l2_async_nf_unregister(&chan->notifier); 1800 v4l2_async_nf_cleanup(&chan->notifier); 1801 } 1802 } 1803 1804 static int tegra_vi_init(struct host1x_client *client) 1805 { 1806 struct tegra_video_device *vid = dev_get_drvdata(client->host); 1807 struct tegra_vi *vi = host1x_client_to_vi(client); 1808 struct tegra_vi_channel *chan, *tmp; 1809 int ret; 1810 1811 vid->media_dev.hw_revision = vi->soc->hw_revision; 1812 snprintf(vid->media_dev.bus_info, sizeof(vid->media_dev.bus_info), 1813 "platform:%s", dev_name(vi->dev)); 1814 1815 INIT_LIST_HEAD(&vi->vi_chans); 1816 1817 if (IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) 1818 ret = tegra_vi_tpg_channels_alloc(vi); 1819 else 1820 ret = tegra_vi_channels_alloc(vi); 1821 if (ret < 0) 1822 goto free_chans; 1823 1824 ret = tegra_vi_channels_init(vi); 1825 if (ret < 0) 1826 goto free_chans; 1827 1828 vid->vi = vi; 1829 1830 if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) { 1831 ret = tegra_vi_graph_init(vi); 1832 if (ret < 0) 1833 goto cleanup_chans; 1834 } 1835 1836 return 0; 1837 1838 cleanup_chans: 1839 list_for_each_entry(chan, &vi->vi_chans, list) 1840 tegra_channel_cleanup(chan); 1841 free_chans: 1842 list_for_each_entry_safe(chan, tmp, &vi->vi_chans, list) { 1843 list_del(&chan->list); 1844 kfree(chan); 1845 } 1846 1847 return ret; 1848 } 1849 1850 static int tegra_vi_exit(struct host1x_client *client) 1851 { 1852 struct tegra_vi *vi = host1x_client_to_vi(client); 1853 1854 /* 1855 * Do not cleanup the channels here as application might still be 1856 * holding video device nodes. Channels cleanup will happen during 1857 * v4l2_device release callback which gets called after all video 1858 * device nodes are released. 1859 */ 1860 1861 if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) 1862 tegra_vi_graph_cleanup(vi); 1863 1864 return 0; 1865 } 1866 1867 static const struct host1x_client_ops vi_client_ops = { 1868 .init = tegra_vi_init, 1869 .exit = tegra_vi_exit, 1870 }; 1871 1872 static int tegra_vi_probe(struct platform_device *pdev) 1873 { 1874 struct tegra_vi *vi; 1875 int ret; 1876 1877 vi = devm_kzalloc(&pdev->dev, sizeof(*vi), GFP_KERNEL); 1878 if (!vi) 1879 return -ENOMEM; 1880 1881 vi->iomem = devm_platform_ioremap_resource(pdev, 0); 1882 if (IS_ERR(vi->iomem)) 1883 return PTR_ERR(vi->iomem); 1884 1885 vi->soc = of_device_get_match_data(&pdev->dev); 1886 1887 vi->clk = devm_clk_get(&pdev->dev, NULL); 1888 if (IS_ERR(vi->clk)) { 1889 ret = PTR_ERR(vi->clk); 1890 dev_err(&pdev->dev, "failed to get vi clock: %d\n", ret); 1891 return ret; 1892 } 1893 1894 vi->vdd = devm_regulator_get(&pdev->dev, "avdd-dsi-csi"); 1895 if (IS_ERR(vi->vdd)) { 1896 ret = PTR_ERR(vi->vdd); 1897 dev_err(&pdev->dev, "failed to get VDD supply: %d\n", ret); 1898 return ret; 1899 } 1900 1901 if (!pdev->dev.pm_domain) { 1902 ret = -ENOENT; 1903 dev_warn(&pdev->dev, "PM domain is not attached: %d\n", ret); 1904 return ret; 1905 } 1906 1907 ret = devm_of_platform_populate(&pdev->dev); 1908 if (ret < 0) { 1909 dev_err(&pdev->dev, 1910 "failed to populate vi child device: %d\n", ret); 1911 return ret; 1912 } 1913 1914 vi->dev = &pdev->dev; 1915 vi->ops = vi->soc->ops; 1916 platform_set_drvdata(pdev, vi); 1917 pm_runtime_enable(&pdev->dev); 1918 1919 /* initialize host1x interface */ 1920 INIT_LIST_HEAD(&vi->client.list); 1921 vi->client.ops = &vi_client_ops; 1922 vi->client.dev = &pdev->dev; 1923 1924 if (vi->ops->vi_enable) 1925 vi->ops->vi_enable(vi, true); 1926 1927 ret = host1x_client_register(&vi->client); 1928 if (ret < 0) { 1929 dev_err(&pdev->dev, 1930 "failed to register host1x client: %d\n", ret); 1931 goto rpm_disable; 1932 } 1933 1934 return 0; 1935 1936 rpm_disable: 1937 if (vi->ops->vi_enable) 1938 vi->ops->vi_enable(vi, false); 1939 pm_runtime_disable(&pdev->dev); 1940 return ret; 1941 } 1942 1943 static int tegra_vi_remove(struct platform_device *pdev) 1944 { 1945 struct tegra_vi *vi = platform_get_drvdata(pdev); 1946 1947 host1x_client_unregister(&vi->client); 1948 1949 if (vi->ops->vi_enable) 1950 vi->ops->vi_enable(vi, false); 1951 pm_runtime_disable(&pdev->dev); 1952 1953 return 0; 1954 } 1955 1956 static const struct of_device_id tegra_vi_of_id_table[] = { 1957 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) 1958 { .compatible = "nvidia,tegra20-vi", .data = &tegra20_vi_soc }, 1959 #endif 1960 #if defined(CONFIG_ARCH_TEGRA_210_SOC) 1961 { .compatible = "nvidia,tegra210-vi", .data = &tegra210_vi_soc }, 1962 #endif 1963 { } 1964 }; 1965 MODULE_DEVICE_TABLE(of, tegra_vi_of_id_table); 1966 1967 static const struct dev_pm_ops tegra_vi_pm_ops = { 1968 SET_RUNTIME_PM_OPS(vi_runtime_suspend, vi_runtime_resume, NULL) 1969 }; 1970 1971 struct platform_driver tegra_vi_driver = { 1972 .driver = { 1973 .name = "tegra-vi", 1974 .of_match_table = tegra_vi_of_id_table, 1975 .pm = &tegra_vi_pm_ops, 1976 }, 1977 .probe = tegra_vi_probe, 1978 .remove = tegra_vi_remove, 1979 }; 1980