drivers/staging/media/tegra-video/vi.c

   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  * Find the entity matching a given fwnode in an v4l2_async_notifier list
1459  */
1460 static struct tegra_vi_graph_entity *
1461 tegra_vi_graph_find_entity(struct list_head *list,
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, list, asc_entry) {
1468                 entity = to_tegra_vi_graph_entity(asd);
1469
1470                 if (entity->asd.match.fwnode == fwnode)
1471                         return entity;
1472         }
1473
1474         return NULL;
1475 }
1476
1477 static int tegra_vi_graph_build(struct tegra_vi_channel *chan,
1478                                 struct tegra_vi_graph_entity *entity)
1479 {
1480         struct tegra_vi *vi = chan->vi;
1481         struct tegra_vi_graph_entity *ent;
1482         struct fwnode_handle *ep = NULL;
1483         struct v4l2_fwnode_link link;
1484         struct media_entity *local = entity->entity;
1485         struct media_entity *remote;
1486         struct media_pad *local_pad;
1487         struct media_pad *remote_pad;
1488         u32 link_flags = MEDIA_LNK_FL_ENABLED;
1489         int ret = 0;
1490
1491         dev_dbg(vi->dev, "creating links for entity %s\n", local->name);
1492
1493         while (1) {
1494                 ep = fwnode_graph_get_next_endpoint(entity->asd.match.fwnode,
1495                                                     ep);
1496                 if (!ep)
1497                         break;
1498
1499                 ret = v4l2_fwnode_parse_link(ep, &link);
1500                 if (ret < 0) {
1501                         dev_err(vi->dev, "failed to parse link for %pOF: %d\n",
1502                                 to_of_node(ep), ret);
1503                         continue;
1504                 }
1505
1506                 if (link.local_port >= local->num_pads) {
1507                         dev_err(vi->dev, "invalid port number %u on %pOF\n",
1508                                 link.local_port, to_of_node(link.local_node));
1509                         v4l2_fwnode_put_link(&link);
1510                         ret = -EINVAL;
1511                         break;
1512                 }
1513
1514                 local_pad = &local->pads[link.local_port];
1515                 /* Remote node is vi node. So use channel video entity and pad
1516                  * as remote/sink.
1517                  */
1518                 if (link.remote_node == of_fwnode_handle(vi->dev->of_node)) {
1519                         remote = &chan->video.entity;
1520                         remote_pad = &chan->pad;
1521                         goto create_link;
1522                 }
1523
1524                 /*
1525                  * Skip sink ports, they will be processed from the other end
1526                  * of the link.
1527                  */
1528                 if (local_pad->flags & MEDIA_PAD_FL_SINK) {
1529                         dev_dbg(vi->dev, "skipping sink port %pOF:%u\n",
1530                                 to_of_node(link.local_node), link.local_port);
1531                         v4l2_fwnode_put_link(&link);
1532                         continue;
1533                 }
1534
1535                 /* find the remote entity from notifier list */
1536                 ent = tegra_vi_graph_find_entity(&chan->notifier.done_list,
1537                                                  link.remote_node);
1538                 if (!ent) {
1539                         dev_err(vi->dev, "no entity found for %pOF\n",
1540                                 to_of_node(link.remote_node));
1541                         v4l2_fwnode_put_link(&link);
1542                         ret = -ENODEV;
1543                         break;
1544                 }
1545
1546                 remote = ent->entity;
1547                 if (link.remote_port >= remote->num_pads) {
1548                         dev_err(vi->dev, "invalid port number %u on %pOF\n",
1549                                 link.remote_port,
1550                                 to_of_node(link.remote_node));
1551                         v4l2_fwnode_put_link(&link);
1552                         ret = -EINVAL;
1553                         break;
1554                 }
1555
1556                 remote_pad = &remote->pads[link.remote_port];
1557
1558 create_link:
1559                 dev_dbg(vi->dev, "creating %s:%u -> %s:%u link\n",
1560                         local->name, local_pad->index,
1561                         remote->name, remote_pad->index);
1562
1563                 ret = media_create_pad_link(local, local_pad->index,
1564                                             remote, remote_pad->index,
1565                                             link_flags);
1566                 v4l2_fwnode_put_link(&link);
1567                 if (ret < 0) {
1568                         dev_err(vi->dev,
1569                                 "failed to create %s:%u -> %s:%u link: %d\n",
1570                                 local->name, local_pad->index,
1571                                 remote->name, remote_pad->index, ret);
1572                         break;
1573                 }
1574         }
1575
1576         fwnode_handle_put(ep);
1577         return ret;
1578 }
1579
1580 static int tegra_vi_graph_notify_complete(struct v4l2_async_notifier *notifier)
1581 {
1582         struct tegra_vi_graph_entity *entity;
1583         struct v4l2_async_connection *asd;
1584         struct v4l2_subdev *subdev;
1585         struct tegra_vi_channel *chan;
1586         struct tegra_vi *vi;
1587         int ret;
1588
1589         chan = container_of(notifier, struct tegra_vi_channel, notifier);
1590         vi = chan->vi;
1591
1592         dev_dbg(vi->dev, "notify complete, all subdevs registered\n");
1593
1594         /*
1595          * Video device node should be created at the end of all the device
1596          * related initialization/setup.
1597          * Current video_register_device() does both initialize and register
1598          * video device in same API.
1599          *
1600          * TODO: Update v4l2-dev driver to split initialize and register into
1601          * separate APIs and then update Tegra video driver to do video device
1602          * initialize followed by all video device related setup and then
1603          * register the video device.
1604          */
1605         ret = video_register_device(&chan->video, VFL_TYPE_VIDEO, -1);
1606         if (ret < 0) {
1607                 dev_err(vi->dev,
1608                         "failed to register video device: %d\n", ret);
1609                 goto unregister_video;
1610         }
1611
1612         /* create links between the entities */
1613         list_for_each_entry(asd, &chan->notifier.done_list, asc_entry) {
1614                 entity = to_tegra_vi_graph_entity(asd);
1615                 ret = tegra_vi_graph_build(chan, entity);
1616                 if (ret < 0)
1617                         goto unregister_video;
1618         }
1619
1620         ret = tegra_channel_setup_ctrl_handler(chan);
1621         if (ret < 0) {
1622                 dev_err(vi->dev,
1623                         "failed to setup channel controls: %d\n", ret);
1624                 goto unregister_video;
1625         }
1626
1627         ret = vi_fmts_bitmap_init(chan);
1628         if (ret < 0) {
1629                 dev_err(vi->dev,
1630                         "failed to initialize formats bitmap: %d\n", ret);
1631                 goto unregister_video;
1632         }
1633
1634         subdev = tegra_channel_get_remote_csi_subdev(chan);
1635         if (!subdev) {
1636                 ret = -ENODEV;
1637                 dev_err(vi->dev,
1638                         "failed to get remote csi subdev: %d\n", ret);
1639                 goto unregister_video;
1640         }
1641
1642         v4l2_set_subdev_hostdata(subdev, chan);
1643
1644         subdev = tegra_channel_get_remote_source_subdev(chan);
1645         v4l2_set_subdev_hostdata(subdev, chan);
1646
1647         return 0;
1648
1649 unregister_video:
1650         vb2_video_unregister_device(&chan->video);
1651         return ret;
1652 }
1653
1654 static int tegra_vi_graph_notify_bound(struct v4l2_async_notifier *notifier,
1655                                        struct v4l2_subdev *subdev,
1656                                        struct v4l2_async_connection *asd)
1657 {
1658         struct tegra_vi_graph_entity *entity;
1659         struct tegra_vi *vi;
1660         struct tegra_vi_channel *chan;
1661
1662         chan = container_of(notifier, struct tegra_vi_channel, notifier);
1663         vi = chan->vi;
1664
1665         /*
1666          * Locate the entity corresponding to the bound subdev and store the
1667          * subdev pointer.
1668          */
1669         entity = tegra_vi_graph_find_entity(&chan->notifier.waiting_list,
1670                                             subdev->fwnode);
1671         if (!entity) {
1672                 dev_err(vi->dev, "no entity for subdev %s\n", subdev->name);
1673                 return -EINVAL;
1674         }
1675
1676         if (entity->subdev) {
1677                 dev_err(vi->dev, "duplicate subdev for node %pOF\n",
1678                         to_of_node(entity->asd.match.fwnode));
1679                 return -EINVAL;
1680         }
1681
1682         dev_dbg(vi->dev, "subdev %s bound\n", subdev->name);
1683         entity->entity = &subdev->entity;
1684         entity->subdev = subdev;
1685
1686         return 0;
1687 }
1688
1689 static const struct v4l2_async_notifier_operations tegra_vi_async_ops = {
1690         .bound = tegra_vi_graph_notify_bound,
1691         .complete = tegra_vi_graph_notify_complete,
1692 };
1693
1694 static int tegra_vi_graph_parse_one(struct tegra_vi_channel *chan,
1695                                     struct fwnode_handle *fwnode)
1696 {
1697         struct tegra_vi *vi = chan->vi;
1698         struct fwnode_handle *ep = NULL;
1699         struct fwnode_handle *remote = NULL;
1700         struct tegra_vi_graph_entity *tvge;
1701         struct device_node *node = NULL;
1702         int ret;
1703
1704         dev_dbg(vi->dev, "parsing node %pOF\n", to_of_node(fwnode));
1705
1706         /* parse all the remote entities and put them into the list */
1707         for_each_endpoint_of_node(to_of_node(fwnode), node) {
1708                 ep = of_fwnode_handle(node);
1709                 remote = fwnode_graph_get_remote_port_parent(ep);
1710                 if (!remote) {
1711                         dev_err(vi->dev,
1712                                 "remote device at %pOF not found\n", node);
1713                         ret = -EINVAL;
1714                         goto cleanup;
1715                 }
1716
1717                 /* skip entities that are already processed */
1718                 if (device_match_fwnode(vi->dev, remote) ||
1719                     tegra_vi_graph_find_entity(&chan->notifier.waiting_list,
1720                                                remote)) {
1721                         fwnode_handle_put(remote);
1722                         continue;
1723                 }
1724
1725                 tvge = v4l2_async_nf_add_fwnode(&chan->notifier, remote,
1726                                                 struct tegra_vi_graph_entity);
1727                 if (IS_ERR(tvge)) {
1728                         ret = PTR_ERR(tvge);
1729                         dev_err(vi->dev,
1730                                 "failed to add subdev to notifier: %d\n", ret);
1731                         fwnode_handle_put(remote);
1732                         goto cleanup;
1733                 }
1734
1735                 ret = tegra_vi_graph_parse_one(chan, remote);
1736                 if (ret < 0) {
1737                         fwnode_handle_put(remote);
1738                         goto cleanup;
1739                 }
1740
1741                 fwnode_handle_put(remote);
1742         }
1743
1744         return 0;
1745
1746 cleanup:
1747         dev_err(vi->dev, "failed parsing the graph: %d\n", ret);
1748         v4l2_async_nf_cleanup(&chan->notifier);
1749         of_node_put(node);
1750         return ret;
1751 }
1752
1753 static int tegra_vi_graph_init(struct tegra_vi *vi)
1754 {
1755         struct tegra_vi_channel *chan;
1756         struct fwnode_handle *fwnode = dev_fwnode(vi->dev);
1757         int ret;
1758
1759         /*
1760          * Walk the links to parse the full graph. Each channel will have
1761          * one endpoint of the composite node. Start by parsing the
1762          * composite node and parse the remote entities in turn.
1763          * Each channel will register a v4l2 async notifier to make the graph
1764          * independent between the channels so we can skip the current channel
1765          * in case of something wrong during graph parsing and continue with
1766          * the next channels.
1767          */
1768         list_for_each_entry(chan, &vi->vi_chans, list) {
1769                 struct fwnode_handle *ep, *remote;
1770
1771                 ep = fwnode_graph_get_endpoint_by_id(fwnode,
1772                                                      chan->portnos[0], 0, 0);
1773                 if (!ep)
1774                         continue;
1775
1776                 remote = fwnode_graph_get_remote_port_parent(ep);
1777                 fwnode_handle_put(ep);
1778
1779                 ret = tegra_vi_graph_parse_one(chan, remote);
1780                 fwnode_handle_put(remote);
1781                 if (ret < 0 || list_empty(&chan->notifier.waiting_list))
1782                         continue;
1783
1784                 chan->notifier.ops = &tegra_vi_async_ops;
1785                 ret = v4l2_async_nf_register(&chan->notifier);
1786                 if (ret < 0) {
1787                         dev_err(vi->dev,
1788                                 "failed to register channel %d notifier: %d\n",
1789                                 chan->portnos[0], ret);
1790                         v4l2_async_nf_cleanup(&chan->notifier);
1791                 }
1792         }
1793
1794         return 0;
1795 }
1796
1797 static void tegra_vi_graph_cleanup(struct tegra_vi *vi)
1798 {
1799         struct tegra_vi_channel *chan;
1800
1801         list_for_each_entry(chan, &vi->vi_chans, list) {
1802                 vb2_video_unregister_device(&chan->video);
1803                 v4l2_async_nf_unregister(&chan->notifier);
1804                 v4l2_async_nf_cleanup(&chan->notifier);
1805         }
1806 }
1807
1808 static int tegra_vi_init(struct host1x_client *client)
1809 {
1810         struct tegra_video_device *vid = dev_get_drvdata(client->host);
1811         struct tegra_vi *vi = host1x_client_to_vi(client);
1812         struct tegra_vi_channel *chan, *tmp;
1813         int ret;
1814
1815         vid->media_dev.hw_revision = vi->soc->hw_revision;
1816         snprintf(vid->media_dev.bus_info, sizeof(vid->media_dev.bus_info),
1817                  "platform:%s", dev_name(vi->dev));
1818
1819         INIT_LIST_HEAD(&vi->vi_chans);
1820
1821         if (IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG))
1822                 ret = tegra_vi_tpg_channels_alloc(vi);
1823         else
1824                 ret = tegra_vi_channels_alloc(vi);
1825         if (ret < 0)
1826                 goto free_chans;
1827
1828         ret = tegra_vi_channels_init(vi);
1829         if (ret < 0)
1830                 goto free_chans;
1831
1832         vid->vi = vi;
1833
1834         if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) {
1835                 ret = tegra_vi_graph_init(vi);
1836                 if (ret < 0)
1837                         goto cleanup_chans;
1838         }
1839
1840         return 0;
1841
1842 cleanup_chans:
1843         list_for_each_entry(chan, &vi->vi_chans, list)
1844                 tegra_channel_cleanup(chan);
1845 free_chans:
1846         list_for_each_entry_safe(chan, tmp, &vi->vi_chans, list) {
1847                 list_del(&chan->list);
1848                 kfree(chan);
1849         }
1850
1851         return ret;
1852 }
1853
1854 static int tegra_vi_exit(struct host1x_client *client)
1855 {
1856         struct tegra_vi *vi = host1x_client_to_vi(client);
1857
1858         /*
1859          * Do not cleanup the channels here as application might still be
1860          * holding video device nodes. Channels cleanup will happen during
1861          * v4l2_device release callback which gets called after all video
1862          * device nodes are released.
1863          */
1864
1865         if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG))
1866                 tegra_vi_graph_cleanup(vi);
1867
1868         return 0;
1869 }
1870
1871 static const struct host1x_client_ops vi_client_ops = {
1872         .init = tegra_vi_init,
1873         .exit = tegra_vi_exit,
1874 };
1875
1876 static int tegra_vi_probe(struct platform_device *pdev)
1877 {
1878         struct tegra_vi *vi;
1879         int ret;
1880
1881         vi = devm_kzalloc(&pdev->dev, sizeof(*vi), GFP_KERNEL);
1882         if (!vi)
1883                 return -ENOMEM;
1884
1885         vi->iomem = devm_platform_ioremap_resource(pdev, 0);
1886         if (IS_ERR(vi->iomem))
1887                 return PTR_ERR(vi->iomem);
1888
1889         vi->soc = of_device_get_match_data(&pdev->dev);
1890
1891         vi->clk = devm_clk_get(&pdev->dev, NULL);
1892         if (IS_ERR(vi->clk)) {
1893                 ret = PTR_ERR(vi->clk);
1894                 dev_err(&pdev->dev, "failed to get vi clock: %d\n", ret);
1895                 return ret;
1896         }
1897
1898         vi->vdd = devm_regulator_get(&pdev->dev, "avdd-dsi-csi");
1899         if (IS_ERR(vi->vdd)) {
1900                 ret = PTR_ERR(vi->vdd);
1901                 dev_err(&pdev->dev, "failed to get VDD supply: %d\n", ret);
1902                 return ret;
1903         }
1904
1905         if (!pdev->dev.pm_domain) {
1906                 ret = -ENOENT;
1907                 dev_warn(&pdev->dev, "PM domain is not attached: %d\n", ret);
1908                 return ret;
1909         }
1910
1911         ret = devm_of_platform_populate(&pdev->dev);
1912         if (ret < 0) {
1913                 dev_err(&pdev->dev,
1914                         "failed to populate vi child device: %d\n", ret);
1915                 return ret;
1916         }
1917
1918         vi->dev = &pdev->dev;
1919         vi->ops = vi->soc->ops;
1920         platform_set_drvdata(pdev, vi);
1921         pm_runtime_enable(&pdev->dev);
1922
1923         /* initialize host1x interface */
1924         INIT_LIST_HEAD(&vi->client.list);
1925         vi->client.ops = &vi_client_ops;
1926         vi->client.dev = &pdev->dev;
1927
1928         if (vi->ops->vi_enable)
1929                 vi->ops->vi_enable(vi, true);
1930
1931         ret = host1x_client_register(&vi->client);
1932         if (ret < 0) {
1933                 dev_err(&pdev->dev,
1934                         "failed to register host1x client: %d\n", ret);
1935                 goto rpm_disable;
1936         }
1937
1938         return 0;
1939
1940 rpm_disable:
1941         if (vi->ops->vi_enable)
1942                 vi->ops->vi_enable(vi, false);
1943         pm_runtime_disable(&pdev->dev);
1944         return ret;
1945 }
1946
1947 static int tegra_vi_remove(struct platform_device *pdev)
1948 {
1949         struct tegra_vi *vi = platform_get_drvdata(pdev);
1950
1951         host1x_client_unregister(&vi->client);
1952
1953         if (vi->ops->vi_enable)
1954                 vi->ops->vi_enable(vi, false);
1955         pm_runtime_disable(&pdev->dev);
1956
1957         return 0;
1958 }
1959
1960 static const struct of_device_id tegra_vi_of_id_table[] = {
1961 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
1962         { .compatible = "nvidia,tegra20-vi",  .data = &tegra20_vi_soc },
1963 #endif
1964 #if defined(CONFIG_ARCH_TEGRA_210_SOC)
1965         { .compatible = "nvidia,tegra210-vi", .data = &tegra210_vi_soc },
1966 #endif
1967         { }
1968 };
1969 MODULE_DEVICE_TABLE(of, tegra_vi_of_id_table);
1970
1971 static const struct dev_pm_ops tegra_vi_pm_ops = {
1972         SET_RUNTIME_PM_OPS(vi_runtime_suspend, vi_runtime_resume, NULL)
1973 };
1974
1975 struct platform_driver tegra_vi_driver = {
1976         .driver = {
1977                 .name = "tegra-vi",
1978                 .of_match_table = tegra_vi_of_id_table,
1979                 .pm = &tegra_vi_pm_ops,
1980         },
1981         .probe = tegra_vi_probe,
1982         .remove = tegra_vi_remove,
1983 };