| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Sowjanya Komatineni | 9643 | 99.55% | 17 | 73.91% |
| Tomi Valkeinen | 27 | 0.28% | 1 | 4.35% |
| Dan Carpenter | 7 | 0.07% | 1 | 4.35% |
| Laurent Pinchart | 5 | 0.05% | 1 | 4.35% |
| Mikko Perttunen | 3 | 0.03% | 1 | 4.35% |
| Hans Verkuil | 1 | 0.01% | 1 | 4.35% |
| Mauro Carvalho Chehab | 1 | 0.01% | 1 | 4.35% |
| Total | 9687 | 23 |
// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2020 NVIDIA CORPORATION. All rights reserved. */ #include <linux/bitmap.h> #include <linux/clk.h> #include <linux/delay.h> #include <linux/host1x.h> #include <linux/lcm.h> #include <linux/list.h> #include <linux/module.h> #include <linux/of.h> #include <linux/of_device.h> #include <linux/of_graph.h> #include <linux/platform_device.h> #include <linux/regulator/consumer.h> #include <linux/pm_runtime.h> #include <linux/slab.h> #include <media/v4l2-dv-timings.h> #include <media/v4l2-event.h> #include <media/v4l2-fh.h> #include <media/v4l2-fwnode.h> #include <media/v4l2-ioctl.h> #include <media/videobuf2-dma-contig.h> #include <soc/tegra/pmc.h> #include "vi.h" #include "video.h" #define MAX_CID_CONTROLS 1 static const struct tegra_video_format tegra_default_format = { .img_dt = TEGRA_IMAGE_DT_RAW10, .bit_width = 10, .code = MEDIA_BUS_FMT_SRGGB10_1X10, .bpp = 2, .img_fmt = TEGRA_IMAGE_FORMAT_DEF, .fourcc = V4L2_PIX_FMT_SRGGB10, }; static inline struct tegra_vi * host1x_client_to_vi(struct host1x_client *client) { return container_of(client, struct tegra_vi, client); } static inline struct tegra_channel_buffer * to_tegra_channel_buffer(struct vb2_v4l2_buffer *vb) { return container_of(vb, struct tegra_channel_buffer, buf); } static inline struct tegra_vi_graph_entity * to_tegra_vi_graph_entity(struct v4l2_async_subdev *asd) { return container_of(asd, struct tegra_vi_graph_entity, asd); } static int tegra_get_format_idx_by_code(struct tegra_vi *vi, unsigned int code, unsigned int offset) { unsigned int i; for (i = offset; i < vi->soc->nformats; ++i) { if (vi->soc->video_formats[i].code == code) return i; } return -1; } static u32 tegra_get_format_fourcc_by_idx(struct tegra_vi *vi, unsigned int index) { if (index >= vi->soc->nformats) return -EINVAL; return vi->soc->video_formats[index].fourcc; } static const struct tegra_video_format * tegra_get_format_by_fourcc(struct tegra_vi *vi, u32 fourcc) { unsigned int i; for (i = 0; i < vi->soc->nformats; ++i) { if (vi->soc->video_formats[i].fourcc == fourcc) return &vi->soc->video_formats[i]; } return NULL; } /* * videobuf2 queue operations */ static int tegra_channel_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[]) { struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); if (*nplanes) return sizes[0] < chan->format.sizeimage ? -EINVAL : 0; *nplanes = 1; sizes[0] = chan->format.sizeimage; alloc_devs[0] = chan->vi->dev; return 0; } static int tegra_channel_buffer_prepare(struct vb2_buffer *vb) { struct tegra_vi_channel *chan = vb2_get_drv_priv(vb->vb2_queue); struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); struct tegra_channel_buffer *buf = to_tegra_channel_buffer(vbuf); unsigned long size = chan->format.sizeimage; if (vb2_plane_size(vb, 0) < size) { v4l2_err(chan->video.v4l2_dev, "buffer too small (%lu < %lu)\n", vb2_plane_size(vb, 0), size); return -EINVAL; } vb2_set_plane_payload(vb, 0, size); buf->chan = chan; buf->addr = vb2_dma_contig_plane_dma_addr(vb, 0); return 0; } static void tegra_channel_buffer_queue(struct vb2_buffer *vb) { struct tegra_vi_channel *chan = vb2_get_drv_priv(vb->vb2_queue); struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); struct tegra_channel_buffer *buf = to_tegra_channel_buffer(vbuf); /* put buffer into the capture queue */ spin_lock(&chan->start_lock); list_add_tail(&buf->queue, &chan->capture); spin_unlock(&chan->start_lock); /* wait up kthread for capture */ wake_up_interruptible(&chan->start_wait); } struct v4l2_subdev * tegra_channel_get_remote_csi_subdev(struct tegra_vi_channel *chan) { struct media_pad *pad; pad = media_entity_remote_pad(&chan->pad); if (!pad) return NULL; return media_entity_to_v4l2_subdev(pad->entity); } struct v4l2_subdev * tegra_channel_get_remote_source_subdev(struct tegra_vi_channel *chan) { struct media_pad *pad; struct v4l2_subdev *subdev; struct media_entity *entity; subdev = tegra_channel_get_remote_csi_subdev(chan); if (!subdev) return NULL; pad = &subdev->entity.pads[0]; while (!(pad->flags & MEDIA_PAD_FL_SOURCE)) { pad = media_entity_remote_pad(pad); if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) break; entity = pad->entity; pad = &entity->pads[0]; subdev = media_entity_to_v4l2_subdev(entity); } return subdev; } static int tegra_channel_enable_stream(struct tegra_vi_channel *chan) { struct v4l2_subdev *csi_subdev, *src_subdev; struct tegra_csi_channel *csi_chan; int ret, err; /* * Tegra CSI receiver can detect the first LP to HS transition. * So, start the CSI stream-on prior to sensor stream-on and * vice-versa for stream-off. */ csi_subdev = tegra_channel_get_remote_csi_subdev(chan); ret = v4l2_subdev_call(csi_subdev, video, s_stream, true); if (ret < 0 && ret != -ENOIOCTLCMD) return ret; if (IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) return 0; csi_chan = v4l2_get_subdevdata(csi_subdev); /* * TRM has incorrectly documented to wait for done status from * calibration logic after CSI interface power on. * As per the design, calibration results are latched and applied * to the pads only when the link is in LP11 state which will happen * during the sensor stream-on. * CSI subdev stream-on triggers start of MIPI pads calibration. * Wait for calibration to finish here after sensor subdev stream-on. */ src_subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(src_subdev, video, s_stream, true); err = tegra_mipi_finish_calibration(csi_chan->mipi); if (ret < 0 && ret != -ENOIOCTLCMD) goto err_disable_csi_stream; if (err < 0) dev_warn(csi_chan->csi->dev, "MIPI calibration failed: %d\n", err); return 0; err_disable_csi_stream: v4l2_subdev_call(csi_subdev, video, s_stream, false); return ret; } static int tegra_channel_disable_stream(struct tegra_vi_channel *chan) { struct v4l2_subdev *subdev; int ret; /* * Stream-off subdevices in reverse order to stream-on. * Remote source subdev in TPG mode is same as CSI subdev. */ subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(subdev, video, s_stream, false); if (ret < 0 && ret != -ENOIOCTLCMD) return ret; if (IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) return 0; subdev = tegra_channel_get_remote_csi_subdev(chan); ret = v4l2_subdev_call(subdev, video, s_stream, false); if (ret < 0 && ret != -ENOIOCTLCMD) return ret; return 0; } int tegra_channel_set_stream(struct tegra_vi_channel *chan, bool on) { int ret; if (on) ret = tegra_channel_enable_stream(chan); else ret = tegra_channel_disable_stream(chan); return ret; } void tegra_channel_release_buffers(struct tegra_vi_channel *chan, enum vb2_buffer_state state) { struct tegra_channel_buffer *buf, *nbuf; spin_lock(&chan->start_lock); list_for_each_entry_safe(buf, nbuf, &chan->capture, queue) { vb2_buffer_done(&buf->buf.vb2_buf, state); list_del(&buf->queue); } spin_unlock(&chan->start_lock); spin_lock(&chan->done_lock); list_for_each_entry_safe(buf, nbuf, &chan->done, queue) { vb2_buffer_done(&buf->buf.vb2_buf, state); list_del(&buf->queue); } spin_unlock(&chan->done_lock); } static int tegra_channel_start_streaming(struct vb2_queue *vq, u32 count) { struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); int ret; ret = pm_runtime_resume_and_get(chan->vi->dev); if (ret < 0) { dev_err(chan->vi->dev, "failed to get runtime PM: %d\n", ret); return ret; } ret = chan->vi->ops->vi_start_streaming(vq, count); if (ret < 0) pm_runtime_put(chan->vi->dev); return ret; } static void tegra_channel_stop_streaming(struct vb2_queue *vq) { struct tegra_vi_channel *chan = vb2_get_drv_priv(vq); chan->vi->ops->vi_stop_streaming(vq); pm_runtime_put(chan->vi->dev); } static const struct vb2_ops tegra_channel_queue_qops = { .queue_setup = tegra_channel_queue_setup, .buf_prepare = tegra_channel_buffer_prepare, .buf_queue = tegra_channel_buffer_queue, .wait_prepare = vb2_ops_wait_prepare, .wait_finish = vb2_ops_wait_finish, .start_streaming = tegra_channel_start_streaming, .stop_streaming = tegra_channel_stop_streaming, }; /* * V4L2 ioctl operations */ static int tegra_channel_querycap(struct file *file, void *fh, struct v4l2_capability *cap) { struct tegra_vi_channel *chan = video_drvdata(file); strscpy(cap->driver, "tegra-video", sizeof(cap->driver)); strscpy(cap->card, chan->video.name, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", dev_name(chan->vi->dev)); return 0; } static int tegra_channel_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); return v4l2_g_parm_cap(&chan->video, subdev, a); } static int tegra_channel_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); return v4l2_s_parm_cap(&chan->video, subdev, a); } static int tegra_channel_enum_framesizes(struct file *file, void *fh, struct v4l2_frmsizeenum *sizes) { int ret; struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; const struct tegra_video_format *fmtinfo; struct v4l2_subdev_frame_size_enum fse = { .index = sizes->index, .which = V4L2_SUBDEV_FORMAT_ACTIVE, }; fmtinfo = tegra_get_format_by_fourcc(chan->vi, sizes->pixel_format); if (!fmtinfo) return -EINVAL; fse.code = fmtinfo->code; subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(subdev, pad, enum_frame_size, NULL, &fse); if (ret) return ret; sizes->type = V4L2_FRMSIZE_TYPE_DISCRETE; sizes->discrete.width = fse.max_width; sizes->discrete.height = fse.max_height; return 0; } static int tegra_channel_enum_frameintervals(struct file *file, void *fh, struct v4l2_frmivalenum *ivals) { int ret; struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; const struct tegra_video_format *fmtinfo; struct v4l2_subdev_frame_interval_enum fie = { .index = ivals->index, .width = ivals->width, .height = ivals->height, .which = V4L2_SUBDEV_FORMAT_ACTIVE, }; fmtinfo = tegra_get_format_by_fourcc(chan->vi, ivals->pixel_format); if (!fmtinfo) return -EINVAL; fie.code = fmtinfo->code; subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(subdev, pad, enum_frame_interval, NULL, &fie); if (ret) return ret; ivals->type = V4L2_FRMIVAL_TYPE_DISCRETE; ivals->discrete.numerator = fie.interval.numerator; ivals->discrete.denominator = fie.interval.denominator; return 0; } static int tegra_channel_enum_format(struct file *file, void *fh, struct v4l2_fmtdesc *f) { struct tegra_vi_channel *chan = video_drvdata(file); unsigned int index = 0, i; unsigned long *fmts_bitmap = chan->tpg_fmts_bitmap; if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) fmts_bitmap = chan->fmts_bitmap; if (f->index >= bitmap_weight(fmts_bitmap, MAX_FORMAT_NUM)) return -EINVAL; for (i = 0; i < f->index + 1; i++, index++) index = find_next_bit(fmts_bitmap, MAX_FORMAT_NUM, index); f->pixelformat = tegra_get_format_fourcc_by_idx(chan->vi, index - 1); return 0; } static int tegra_channel_get_format(struct file *file, void *fh, struct v4l2_format *format) { struct tegra_vi_channel *chan = video_drvdata(file); format->fmt.pix = chan->format; return 0; } static void tegra_channel_fmt_align(struct tegra_vi_channel *chan, struct v4l2_pix_format *pix, unsigned int bpp) { unsigned int min_bpl; unsigned int max_bpl; unsigned int bpl; /* * The transfer alignment requirements are expressed in bytes. * Clamp the requested width and height to the limits. */ pix->width = clamp(pix->width, TEGRA_MIN_WIDTH, TEGRA_MAX_WIDTH); pix->height = clamp(pix->height, TEGRA_MIN_HEIGHT, TEGRA_MAX_HEIGHT); /* Clamp the requested bytes per line value. If the maximum bytes per * line value is zero, the module doesn't support user configurable * line sizes. Override the requested value with the minimum in that * case. */ min_bpl = pix->width * bpp; max_bpl = rounddown(TEGRA_MAX_WIDTH, SURFACE_ALIGN_BYTES); bpl = roundup(pix->bytesperline, SURFACE_ALIGN_BYTES); pix->bytesperline = clamp(bpl, min_bpl, max_bpl); pix->sizeimage = pix->bytesperline * pix->height; if (pix->pixelformat == V4L2_PIX_FMT_NV16) pix->sizeimage *= 2; } static int __tegra_channel_try_format(struct tegra_vi_channel *chan, struct v4l2_pix_format *pix) { const struct tegra_video_format *fmtinfo; struct v4l2_subdev *subdev; struct v4l2_subdev_format fmt; struct v4l2_subdev_state *sd_state; struct v4l2_subdev_frame_size_enum fse = { .which = V4L2_SUBDEV_FORMAT_TRY, }; struct v4l2_subdev_selection sdsel = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, .target = V4L2_SEL_TGT_CROP_BOUNDS, }; int ret; subdev = tegra_channel_get_remote_source_subdev(chan); if (!subdev) return -ENODEV; sd_state = v4l2_subdev_alloc_state(subdev); if (IS_ERR(sd_state)) return PTR_ERR(sd_state); /* * Retrieve the format information and if requested format isn't * supported, keep the current format. */ fmtinfo = tegra_get_format_by_fourcc(chan->vi, pix->pixelformat); if (!fmtinfo) { pix->pixelformat = chan->format.pixelformat; pix->colorspace = chan->format.colorspace; fmtinfo = tegra_get_format_by_fourcc(chan->vi, pix->pixelformat); } pix->field = V4L2_FIELD_NONE; fmt.which = V4L2_SUBDEV_FORMAT_TRY; fmt.pad = 0; v4l2_fill_mbus_format(&fmt.format, pix, fmtinfo->code); /* * Attempt to obtain the format size from subdev. * If not available, try to get crop boundary from subdev. */ fse.code = fmtinfo->code; ret = v4l2_subdev_call(subdev, pad, enum_frame_size, sd_state, &fse); if (ret) { if (!v4l2_subdev_has_op(subdev, pad, get_selection)) { sd_state->pads->try_crop.width = 0; sd_state->pads->try_crop.height = 0; } else { ret = v4l2_subdev_call(subdev, pad, get_selection, NULL, &sdsel); if (ret) return -EINVAL; sd_state->pads->try_crop.width = sdsel.r.width; sd_state->pads->try_crop.height = sdsel.r.height; } } else { sd_state->pads->try_crop.width = fse.max_width; sd_state->pads->try_crop.height = fse.max_height; } ret = v4l2_subdev_call(subdev, pad, set_fmt, sd_state, &fmt); if (ret < 0) return ret; v4l2_fill_pix_format(pix, &fmt.format); tegra_channel_fmt_align(chan, pix, fmtinfo->bpp); v4l2_subdev_free_state(sd_state); return 0; } static int tegra_channel_try_format(struct file *file, void *fh, struct v4l2_format *format) { struct tegra_vi_channel *chan = video_drvdata(file); return __tegra_channel_try_format(chan, &format->fmt.pix); } static void tegra_channel_update_gangports(struct tegra_vi_channel *chan) { if (chan->format.width <= 1920) chan->numgangports = 1; else chan->numgangports = chan->totalports; } static int tegra_channel_set_format(struct file *file, void *fh, struct v4l2_format *format) { struct tegra_vi_channel *chan = video_drvdata(file); const struct tegra_video_format *fmtinfo; struct v4l2_subdev_format fmt; struct v4l2_subdev *subdev; struct v4l2_pix_format *pix = &format->fmt.pix; int ret; if (vb2_is_busy(&chan->queue)) return -EBUSY; /* get supported format by try_fmt */ ret = __tegra_channel_try_format(chan, pix); if (ret) return ret; fmtinfo = tegra_get_format_by_fourcc(chan->vi, pix->pixelformat); fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; fmt.pad = 0; v4l2_fill_mbus_format(&fmt.format, pix, fmtinfo->code); subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(subdev, pad, set_fmt, NULL, &fmt); if (ret < 0) return ret; v4l2_fill_pix_format(pix, &fmt.format); tegra_channel_fmt_align(chan, pix, fmtinfo->bpp); chan->format = *pix; chan->fmtinfo = fmtinfo; tegra_channel_update_gangports(chan); return 0; } static int tegra_channel_set_subdev_active_fmt(struct tegra_vi_channel *chan) { int ret, index; struct v4l2_subdev *subdev; struct v4l2_subdev_format fmt = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, }; /* * Initialize channel format to the sub-device active format if there * is corresponding match in the Tegra supported video formats. */ subdev = tegra_channel_get_remote_source_subdev(chan); ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); if (ret) return ret; index = tegra_get_format_idx_by_code(chan->vi, fmt.format.code, 0); if (index < 0) return -EINVAL; chan->fmtinfo = &chan->vi->soc->video_formats[index]; v4l2_fill_pix_format(&chan->format, &fmt.format); chan->format.pixelformat = chan->fmtinfo->fourcc; chan->format.bytesperline = chan->format.width * chan->fmtinfo->bpp; chan->format.sizeimage = chan->format.bytesperline * chan->format.height; tegra_channel_fmt_align(chan, &chan->format, chan->fmtinfo->bpp); tegra_channel_update_gangports(chan); return 0; } static int tegra_channel_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) { switch (sub->type) { case V4L2_EVENT_SOURCE_CHANGE: return v4l2_event_subscribe(fh, sub, 4, NULL); } return v4l2_ctrl_subscribe_event(fh, sub); } static int tegra_channel_g_selection(struct file *file, void *priv, struct v4l2_selection *sel) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; struct v4l2_subdev_format fmt = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, }; struct v4l2_subdev_selection sdsel = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, .target = sel->target, }; int ret; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, get_selection)) return -ENOTTY; if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) return -EINVAL; /* * Try the get selection operation and fallback to get format if not * implemented. */ ret = v4l2_subdev_call(subdev, pad, get_selection, NULL, &sdsel); if (!ret) sel->r = sdsel.r; if (ret != -ENOIOCTLCMD) return ret; ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt); if (ret < 0) return ret; sel->r.left = 0; sel->r.top = 0; sel->r.width = fmt.format.width; sel->r.height = fmt.format.height; return 0; } static int tegra_channel_s_selection(struct file *file, void *fh, struct v4l2_selection *sel) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; int ret; struct v4l2_subdev_selection sdsel = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, .target = sel->target, .flags = sel->flags, .r = sel->r, }; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, set_selection)) return -ENOTTY; if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) return -EINVAL; if (vb2_is_busy(&chan->queue)) return -EBUSY; ret = v4l2_subdev_call(subdev, pad, set_selection, NULL, &sdsel); if (!ret) { sel->r = sdsel.r; /* * Subdev active format resolution may have changed during * set selection operation. So, update channel format to * the sub-device active format. */ return tegra_channel_set_subdev_active_fmt(chan); } return ret; } static int tegra_channel_g_edid(struct file *file, void *fh, struct v4l2_edid *edid) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, get_edid)) return -ENOTTY; return v4l2_subdev_call(subdev, pad, get_edid, edid); } static int tegra_channel_s_edid(struct file *file, void *fh, struct v4l2_edid *edid) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, set_edid)) return -ENOTTY; return v4l2_subdev_call(subdev, pad, set_edid, edid); } static int tegra_channel_g_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, video, g_dv_timings)) return -ENOTTY; return v4l2_device_call_until_err(chan->video.v4l2_dev, 0, video, g_dv_timings, timings); } static int tegra_channel_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; struct v4l2_bt_timings *bt = &timings->bt; struct v4l2_dv_timings curr_timings; int ret; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, video, s_dv_timings)) return -ENOTTY; ret = tegra_channel_g_dv_timings(file, fh, &curr_timings); if (ret) return ret; if (v4l2_match_dv_timings(timings, &curr_timings, 0, false)) return 0; if (vb2_is_busy(&chan->queue)) return -EBUSY; ret = v4l2_device_call_until_err(chan->video.v4l2_dev, 0, video, s_dv_timings, timings); if (ret) return ret; chan->format.width = bt->width; chan->format.height = bt->height; chan->format.bytesperline = bt->width * chan->fmtinfo->bpp; chan->format.sizeimage = chan->format.bytesperline * bt->height; tegra_channel_fmt_align(chan, &chan->format, chan->fmtinfo->bpp); tegra_channel_update_gangports(chan); return 0; } static int tegra_channel_query_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, video, query_dv_timings)) return -ENOTTY; return v4l2_device_call_until_err(chan->video.v4l2_dev, 0, video, query_dv_timings, timings); } static int tegra_channel_enum_dv_timings(struct file *file, void *fh, struct v4l2_enum_dv_timings *timings) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, enum_dv_timings)) return -ENOTTY; return v4l2_subdev_call(subdev, pad, enum_dv_timings, timings); } static int tegra_channel_dv_timings_cap(struct file *file, void *fh, struct v4l2_dv_timings_cap *cap) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; subdev = tegra_channel_get_remote_source_subdev(chan); if (!v4l2_subdev_has_op(subdev, pad, dv_timings_cap)) return -ENOTTY; return v4l2_subdev_call(subdev, pad, dv_timings_cap, cap); } static int tegra_channel_log_status(struct file *file, void *fh) { struct tegra_vi_channel *chan = video_drvdata(file); v4l2_device_call_all(chan->video.v4l2_dev, 0, core, log_status); return 0; } static int tegra_channel_enum_input(struct file *file, void *fh, struct v4l2_input *inp) { struct tegra_vi_channel *chan = video_drvdata(file); struct v4l2_subdev *subdev; if (inp->index) return -EINVAL; inp->type = V4L2_INPUT_TYPE_CAMERA; subdev = tegra_channel_get_remote_source_subdev(chan); strscpy(inp->name, subdev->name, sizeof(inp->name)); if (v4l2_subdev_has_op(subdev, pad, dv_timings_cap)) inp->capabilities = V4L2_IN_CAP_DV_TIMINGS; return 0; } static int tegra_channel_g_input(struct file *file, void *priv, unsigned int *i) { *i = 0; return 0; } static int tegra_channel_s_input(struct file *file, void *priv, unsigned int input) { if (input > 0) return -EINVAL; return 0; } static const struct v4l2_ioctl_ops tegra_channel_ioctl_ops = { .vidioc_querycap = tegra_channel_querycap, .vidioc_g_parm = tegra_channel_g_parm, .vidioc_s_parm = tegra_channel_s_parm, .vidioc_enum_framesizes = tegra_channel_enum_framesizes, .vidioc_enum_frameintervals = tegra_channel_enum_frameintervals, .vidioc_enum_fmt_vid_cap = tegra_channel_enum_format, .vidioc_g_fmt_vid_cap = tegra_channel_get_format, .vidioc_s_fmt_vid_cap = tegra_channel_set_format, .vidioc_try_fmt_vid_cap = tegra_channel_try_format, .vidioc_enum_input = tegra_channel_enum_input, .vidioc_g_input = tegra_channel_g_input, .vidioc_s_input = tegra_channel_s_input, .vidioc_reqbufs = vb2_ioctl_reqbufs, .vidioc_prepare_buf = vb2_ioctl_prepare_buf, .vidioc_querybuf = vb2_ioctl_querybuf, .vidioc_qbuf = vb2_ioctl_qbuf, .vidioc_dqbuf = vb2_ioctl_dqbuf, .vidioc_create_bufs = vb2_ioctl_create_bufs, .vidioc_expbuf = vb2_ioctl_expbuf, .vidioc_streamon = vb2_ioctl_streamon, .vidioc_streamoff = vb2_ioctl_streamoff, .vidioc_subscribe_event = tegra_channel_subscribe_event, .vidioc_unsubscribe_event = v4l2_event_unsubscribe, .vidioc_g_selection = tegra_channel_g_selection, .vidioc_s_selection = tegra_channel_s_selection, .vidioc_g_edid = tegra_channel_g_edid, .vidioc_s_edid = tegra_channel_s_edid, .vidioc_g_dv_timings = tegra_channel_g_dv_timings, .vidioc_s_dv_timings = tegra_channel_s_dv_timings, .vidioc_query_dv_timings = tegra_channel_query_dv_timings, .vidioc_enum_dv_timings = tegra_channel_enum_dv_timings, .vidioc_dv_timings_cap = tegra_channel_dv_timings_cap, .vidioc_log_status = tegra_channel_log_status, }; /* * V4L2 file operations */ static const struct v4l2_file_operations tegra_channel_fops = { .owner = THIS_MODULE, .unlocked_ioctl = video_ioctl2, .open = v4l2_fh_open, .release = vb2_fop_release, .read = vb2_fop_read, .poll = vb2_fop_poll, .mmap = vb2_fop_mmap, }; /* * V4L2 control operations */ static int vi_s_ctrl(struct v4l2_ctrl *ctrl) { struct tegra_vi_channel *chan = container_of(ctrl->handler, struct tegra_vi_channel, ctrl_handler); switch (ctrl->id) { case V4L2_CID_TEST_PATTERN: /* pattern change takes effect on next stream */ chan->pg_mode = ctrl->val + 1; break; case V4L2_CID_TEGRA_SYNCPT_TIMEOUT_RETRY: chan->syncpt_timeout_retry = ctrl->val; break; default: return -EINVAL; } return 0; } static const struct v4l2_ctrl_ops vi_ctrl_ops = { .s_ctrl = vi_s_ctrl, }; #if IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG) static const char *const vi_pattern_strings[] = { "Black/White Direct Mode", "Color Patch Mode", }; #else static const struct v4l2_ctrl_config syncpt_timeout_ctrl = { .ops = &vi_ctrl_ops, .id = V4L2_CID_TEGRA_SYNCPT_TIMEOUT_RETRY, .name = "Syncpt timeout retry", .type = V4L2_CTRL_TYPE_INTEGER, .min = 1, .max = 10000, .step = 1, .def = 5, }; #endif static int tegra_channel_setup_ctrl_handler(struct tegra_vi_channel *chan) { int ret; #if IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG) /* add test pattern control handler to v4l2 device */ v4l2_ctrl_new_std_menu_items(&chan->ctrl_handler, &vi_ctrl_ops, V4L2_CID_TEST_PATTERN, ARRAY_SIZE(vi_pattern_strings) - 1, 0, 0, vi_pattern_strings); if (chan->ctrl_handler.error) { dev_err(chan->vi->dev, "failed to add TPG ctrl handler: %d\n", chan->ctrl_handler.error); v4l2_ctrl_handler_free(&chan->ctrl_handler); return chan->ctrl_handler.error; } #else struct v4l2_subdev *subdev; /* custom control */ v4l2_ctrl_new_custom(&chan->ctrl_handler, &syncpt_timeout_ctrl, NULL); if (chan->ctrl_handler.error) { dev_err(chan->vi->dev, "failed to add %s ctrl handler: %d\n", syncpt_timeout_ctrl.name, chan->ctrl_handler.error); v4l2_ctrl_handler_free(&chan->ctrl_handler); return chan->ctrl_handler.error; } subdev = tegra_channel_get_remote_source_subdev(chan); if (!subdev) return -ENODEV; ret = v4l2_ctrl_add_handler(&chan->ctrl_handler, subdev->ctrl_handler, NULL, true); if (ret < 0) { dev_err(chan->vi->dev, "failed to add subdev %s ctrl handler: %d\n", subdev->name, ret); v4l2_ctrl_handler_free(&chan->ctrl_handler); return ret; } #endif /* setup the controls */ ret = v4l2_ctrl_handler_setup(&chan->ctrl_handler); if (ret < 0) { dev_err(chan->vi->dev, "failed to setup v4l2 ctrl handler: %d\n", ret); return ret; } return 0; } /* VI only support 2 formats in TPG mode */ static void vi_tpg_fmts_bitmap_init(struct tegra_vi_channel *chan) { int index; bitmap_zero(chan->tpg_fmts_bitmap, MAX_FORMAT_NUM); index = tegra_get_format_idx_by_code(chan->vi, MEDIA_BUS_FMT_SRGGB10_1X10, 0); bitmap_set(chan->tpg_fmts_bitmap, index, 1); index = tegra_get_format_idx_by_code(chan->vi, MEDIA_BUS_FMT_RGB888_1X32_PADHI, 0); bitmap_set(chan->tpg_fmts_bitmap, index, 1); } static int vi_fmts_bitmap_init(struct tegra_vi_channel *chan) { int index, ret, match_code = 0; struct v4l2_subdev *subdev; struct v4l2_subdev_mbus_code_enum code = { .which = V4L2_SUBDEV_FORMAT_ACTIVE, }; bitmap_zero(chan->fmts_bitmap, MAX_FORMAT_NUM); /* * Set the bitmap bits based on all the matched formats between the * available media bus formats of sub-device and the pre-defined Tegra * supported video formats. */ subdev = tegra_channel_get_remote_source_subdev(chan); while (1) { ret = v4l2_subdev_call(subdev, pad, enum_mbus_code, NULL, &code); if (ret < 0) break; index = tegra_get_format_idx_by_code(chan->vi, code.code, 0); while (index >= 0) { bitmap_set(chan->fmts_bitmap, index, 1); if (!match_code) match_code = code.code; /* look for other formats with same mbus code */ index = tegra_get_format_idx_by_code(chan->vi, code.code, index + 1); } code.index++; } /* * Set the bitmap bit corresponding to default tegra video format if * there are no matched formats. */ if (!match_code) { match_code = tegra_default_format.code; index = tegra_get_format_idx_by_code(chan->vi, match_code, 0); if (WARN_ON(index < 0)) return -EINVAL; bitmap_set(chan->fmts_bitmap, index, 1); } /* initialize channel format to the sub-device active format */ tegra_channel_set_subdev_active_fmt(chan); return 0; } static void tegra_channel_host1x_syncpts_free(struct tegra_vi_channel *chan) { int i; for (i = 0; i < chan->numgangports; i++) { host1x_syncpt_put(chan->mw_ack_sp[i]); host1x_syncpt_put(chan->frame_start_sp[i]); } } static void tegra_channel_cleanup(struct tegra_vi_channel *chan) { v4l2_ctrl_handler_free(&chan->ctrl_handler); media_entity_cleanup(&chan->video.entity); tegra_channel_host1x_syncpts_free(chan); mutex_destroy(&chan->video_lock); } void tegra_channels_cleanup(struct tegra_vi *vi) { struct tegra_vi_channel *chan, *tmp; if (!vi) return; list_for_each_entry_safe(chan, tmp, &vi->vi_chans, list) { tegra_channel_cleanup(chan); list_del(&chan->list); kfree(chan); } } static int tegra_channel_host1x_syncpt_init(struct tegra_vi_channel *chan) { struct tegra_vi *vi = chan->vi; unsigned long flags = HOST1X_SYNCPT_CLIENT_MANAGED; struct host1x_syncpt *fs_sp; struct host1x_syncpt *mw_sp; int ret, i; for (i = 0; i < chan->numgangports; i++) { fs_sp = host1x_syncpt_request(&vi->client, flags); if (!fs_sp) { dev_err(vi->dev, "failed to request frame start syncpoint\n"); ret = -ENOMEM; goto free_syncpts; } mw_sp = host1x_syncpt_request(&vi->client, flags); if (!mw_sp) { dev_err(vi->dev, "failed to request memory ack syncpoint\n"); host1x_syncpt_put(fs_sp); ret = -ENOMEM; goto free_syncpts; } chan->frame_start_sp[i] = fs_sp; chan->mw_ack_sp[i] = mw_sp; spin_lock_init(&chan->sp_incr_lock[i]); } return 0; free_syncpts: tegra_channel_host1x_syncpts_free(chan); return ret; } static int tegra_channel_init(struct tegra_vi_channel *chan) { struct tegra_vi *vi = chan->vi; struct tegra_video_device *vid = dev_get_drvdata(vi->client.host); int ret; mutex_init(&chan->video_lock); INIT_LIST_HEAD(&chan->capture); INIT_LIST_HEAD(&chan->done); spin_lock_init(&chan->start_lock); spin_lock_init(&chan->done_lock); init_waitqueue_head(&chan->start_wait); init_waitqueue_head(&chan->done_wait); /* initialize the video format */ chan->fmtinfo = &tegra_default_format; chan->format.pixelformat = chan->fmtinfo->fourcc; chan->format.colorspace = V4L2_COLORSPACE_SRGB; chan->format.field = V4L2_FIELD_NONE; chan->format.width = TEGRA_DEF_WIDTH; chan->format.height = TEGRA_DEF_HEIGHT; chan->format.bytesperline = TEGRA_DEF_WIDTH * chan->fmtinfo->bpp; chan->format.sizeimage = chan->format.bytesperline * TEGRA_DEF_HEIGHT; tegra_channel_fmt_align(chan, &chan->format, chan->fmtinfo->bpp); ret = tegra_channel_host1x_syncpt_init(chan); if (ret) return ret; /* initialize the media entity */ chan->pad.flags = MEDIA_PAD_FL_SINK; ret = media_entity_pads_init(&chan->video.entity, 1, &chan->pad); if (ret < 0) { dev_err(vi->dev, "failed to initialize media entity: %d\n", ret); goto free_syncpts; } ret = v4l2_ctrl_handler_init(&chan->ctrl_handler, MAX_CID_CONTROLS); if (chan->ctrl_handler.error) { dev_err(vi->dev, "failed to initialize v4l2 ctrl handler: %d\n", ret); goto cleanup_media; } /* initialize the video_device */ chan->video.fops = &tegra_channel_fops; chan->video.v4l2_dev = &vid->v4l2_dev; chan->video.release = video_device_release_empty; chan->video.queue = &chan->queue; snprintf(chan->video.name, sizeof(chan->video.name), "%s-%s-%u", dev_name(vi->dev), "output", chan->portnos[0]); chan->video.vfl_type = VFL_TYPE_VIDEO; chan->video.vfl_dir = VFL_DIR_RX; chan->video.ioctl_ops = &tegra_channel_ioctl_ops; chan->video.ctrl_handler = &chan->ctrl_handler; chan->video.lock = &chan->video_lock; chan->video.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; video_set_drvdata(&chan->video, chan); chan->queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; chan->queue.io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ; chan->queue.lock = &chan->video_lock; chan->queue.drv_priv = chan; chan->queue.buf_struct_size = sizeof(struct tegra_channel_buffer); chan->queue.ops = &tegra_channel_queue_qops; chan->queue.mem_ops = &vb2_dma_contig_memops; chan->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; chan->queue.min_buffers_needed = 2; chan->queue.dev = vi->dev; ret = vb2_queue_init(&chan->queue); if (ret < 0) { dev_err(vi->dev, "failed to initialize vb2 queue: %d\n", ret); goto free_v4l2_ctrl_hdl; } if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) v4l2_async_notifier_init(&chan->notifier); return 0; free_v4l2_ctrl_hdl: v4l2_ctrl_handler_free(&chan->ctrl_handler); cleanup_media: media_entity_cleanup(&chan->video.entity); free_syncpts: tegra_channel_host1x_syncpts_free(chan); return ret; } static int tegra_vi_channel_alloc(struct tegra_vi *vi, unsigned int port_num, struct device_node *node, unsigned int lanes) { struct tegra_vi_channel *chan; unsigned int i; /* * Do not use devm_kzalloc as memory is freed immediately * when device instance is unbound but application might still * be holding the device node open. Channel memory allocated * with kzalloc is freed during video device release callback. */ chan = kzalloc(sizeof(*chan), GFP_KERNEL); if (!chan) return -ENOMEM; chan->vi = vi; chan->portnos[0] = port_num; /* * For data lanes more than maximum csi lanes per brick, multiple of * x4 ports are used simultaneously for capture. */ if (lanes <= CSI_LANES_PER_BRICK) chan->totalports = 1; else chan->totalports = lanes / CSI_LANES_PER_BRICK; chan->numgangports = chan->totalports; for (i = 1; i < chan->totalports; i++) chan->portnos[i] = chan->portnos[0] + i * CSI_PORTS_PER_BRICK; chan->of_node = node; list_add_tail(&chan->list, &vi->vi_chans); return 0; } static int tegra_vi_tpg_channels_alloc(struct tegra_vi *vi) { unsigned int port_num; unsigned int nchannels = vi->soc->vi_max_channels; int ret; for (port_num = 0; port_num < nchannels; port_num++) { ret = tegra_vi_channel_alloc(vi, port_num, vi->dev->of_node, 2); if (ret < 0) return ret; } return 0; } static int tegra_vi_channels_alloc(struct tegra_vi *vi) { struct device_node *node = vi->dev->of_node; struct device_node *ep = NULL; struct device_node *ports; struct device_node *port; unsigned int port_num; struct device_node *parent; struct v4l2_fwnode_endpoint v4l2_ep = { .bus_type = 0 }; unsigned int lanes; int ret = 0; ports = of_get_child_by_name(node, "ports"); if (!ports) return -ENODEV; for_each_child_of_node(ports, port) { if (!of_node_name_eq(port, "port")) continue; ret = of_property_read_u32(port, "reg", &port_num); if (ret < 0) continue; if (port_num > vi->soc->vi_max_channels) { dev_err(vi->dev, "invalid port num %d for %pOF\n", port_num, port); ret = -EINVAL; of_node_put(port); goto cleanup; } ep = of_get_child_by_name(port, "endpoint"); if (!ep) continue; parent = of_graph_get_remote_port_parent(ep); of_node_put(ep); if (!parent) continue; ep = of_graph_get_endpoint_by_regs(parent, 0, 0); of_node_put(parent); ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &v4l2_ep); of_node_put(ep); if (ret) continue; lanes = v4l2_ep.bus.mipi_csi2.num_data_lanes; ret = tegra_vi_channel_alloc(vi, port_num, port, lanes); if (ret < 0) { of_node_put(port); goto cleanup; } } cleanup: of_node_put(ports); return ret; } static int tegra_vi_channels_init(struct tegra_vi *vi) { struct tegra_vi_channel *chan; int ret; list_for_each_entry(chan, &vi->vi_chans, list) { ret = tegra_channel_init(chan); if (ret < 0) { dev_err(vi->dev, "failed to initialize channel-%d: %d\n", chan->portnos[0], ret); goto cleanup; } } return 0; cleanup: list_for_each_entry_continue_reverse(chan, &vi->vi_chans, list) tegra_channel_cleanup(chan); return ret; } void tegra_v4l2_nodes_cleanup_tpg(struct tegra_video_device *vid) { struct tegra_vi *vi = vid->vi; struct tegra_csi *csi = vid->csi; struct tegra_csi_channel *csi_chan; struct tegra_vi_channel *chan; list_for_each_entry(chan, &vi->vi_chans, list) vb2_video_unregister_device(&chan->video); list_for_each_entry(csi_chan, &csi->csi_chans, list) v4l2_device_unregister_subdev(&csi_chan->subdev); } int tegra_v4l2_nodes_setup_tpg(struct tegra_video_device *vid) { struct tegra_vi *vi = vid->vi; struct tegra_csi *csi = vid->csi; struct tegra_vi_channel *vi_chan; struct tegra_csi_channel *csi_chan; u32 link_flags = MEDIA_LNK_FL_ENABLED; int ret; if (!vi || !csi) return -ENODEV; csi_chan = list_first_entry(&csi->csi_chans, struct tegra_csi_channel, list); list_for_each_entry(vi_chan, &vi->vi_chans, list) { struct media_entity *source = &csi_chan->subdev.entity; struct media_entity *sink = &vi_chan->video.entity; struct media_pad *source_pad = csi_chan->pads; struct media_pad *sink_pad = &vi_chan->pad; ret = v4l2_device_register_subdev(&vid->v4l2_dev, &csi_chan->subdev); if (ret) { dev_err(vi->dev, "failed to register subdev: %d\n", ret); goto cleanup; } ret = video_register_device(&vi_chan->video, VFL_TYPE_VIDEO, -1); if (ret < 0) { dev_err(vi->dev, "failed to register video device: %d\n", ret); goto cleanup; } dev_dbg(vi->dev, "creating %s:%u -> %s:%u link\n", source->name, source_pad->index, sink->name, sink_pad->index); ret = media_create_pad_link(source, source_pad->index, sink, sink_pad->index, link_flags); if (ret < 0) { dev_err(vi->dev, "failed to create %s:%u -> %s:%u link: %d\n", source->name, source_pad->index, sink->name, sink_pad->index, ret); goto cleanup; } ret = tegra_channel_setup_ctrl_handler(vi_chan); if (ret < 0) goto cleanup; v4l2_set_subdev_hostdata(&csi_chan->subdev, vi_chan); vi_tpg_fmts_bitmap_init(vi_chan); csi_chan = list_next_entry(csi_chan, list); } return 0; cleanup: tegra_v4l2_nodes_cleanup_tpg(vid); return ret; } static int __maybe_unused vi_runtime_resume(struct device *dev) { struct tegra_vi *vi = dev_get_drvdata(dev); int ret; ret = regulator_enable(vi->vdd); if (ret) { dev_err(dev, "failed to enable VDD supply: %d\n", ret); return ret; } ret = clk_set_rate(vi->clk, vi->soc->vi_max_clk_hz); if (ret) { dev_err(dev, "failed to set vi clock rate: %d\n", ret); goto disable_vdd; } ret = clk_prepare_enable(vi->clk); if (ret) { dev_err(dev, "failed to enable vi clock: %d\n", ret); goto disable_vdd; } return 0; disable_vdd: regulator_disable(vi->vdd); return ret; } static int __maybe_unused vi_runtime_suspend(struct device *dev) { struct tegra_vi *vi = dev_get_drvdata(dev); clk_disable_unprepare(vi->clk); regulator_disable(vi->vdd); return 0; } /* * Graph Management */ static struct tegra_vi_graph_entity * tegra_vi_graph_find_entity(struct tegra_vi_channel *chan, const struct fwnode_handle *fwnode) { struct tegra_vi_graph_entity *entity; struct v4l2_async_subdev *asd; list_for_each_entry(asd, &chan->notifier.asd_list, asd_list) { entity = to_tegra_vi_graph_entity(asd); if (entity->asd.match.fwnode == fwnode) return entity; } return NULL; } static int tegra_vi_graph_build(struct tegra_vi_channel *chan, struct tegra_vi_graph_entity *entity) { struct tegra_vi *vi = chan->vi; struct tegra_vi_graph_entity *ent; struct fwnode_handle *ep = NULL; struct v4l2_fwnode_link link; struct media_entity *local = entity->entity; struct media_entity *remote; struct media_pad *local_pad; struct media_pad *remote_pad; u32 link_flags = MEDIA_LNK_FL_ENABLED; int ret = 0; dev_dbg(vi->dev, "creating links for entity %s\n", local->name); while (1) { ep = fwnode_graph_get_next_endpoint(entity->asd.match.fwnode, ep); if (!ep) break; ret = v4l2_fwnode_parse_link(ep, &link); if (ret < 0) { dev_err(vi->dev, "failed to parse link for %pOF: %d\n", to_of_node(ep), ret); continue; } if (link.local_port >= local->num_pads) { dev_err(vi->dev, "invalid port number %u on %pOF\n", link.local_port, to_of_node(link.local_node)); v4l2_fwnode_put_link(&link); ret = -EINVAL; break; } local_pad = &local->pads[link.local_port]; /* Remote node is vi node. So use channel video entity and pad * as remote/sink. */ if (link.remote_node == of_fwnode_handle(vi->dev->of_node)) { remote = &chan->video.entity; remote_pad = &chan->pad; goto create_link; } /* * Skip sink ports, they will be processed from the other end * of the link. */ if (local_pad->flags & MEDIA_PAD_FL_SINK) { dev_dbg(vi->dev, "skipping sink port %pOF:%u\n", to_of_node(link.local_node), link.local_port); v4l2_fwnode_put_link(&link); continue; } /* find the remote entity from notifier list */ ent = tegra_vi_graph_find_entity(chan, link.remote_node); if (!ent) { dev_err(vi->dev, "no entity found for %pOF\n", to_of_node(link.remote_node)); v4l2_fwnode_put_link(&link); ret = -ENODEV; break; } remote = ent->entity; if (link.remote_port >= remote->num_pads) { dev_err(vi->dev, "invalid port number %u on %pOF\n", link.remote_port, to_of_node(link.remote_node)); v4l2_fwnode_put_link(&link); ret = -EINVAL; break; } remote_pad = &remote->pads[link.remote_port]; create_link: dev_dbg(vi->dev, "creating %s:%u -> %s:%u link\n", local->name, local_pad->index, remote->name, remote_pad->index); ret = media_create_pad_link(local, local_pad->index, remote, remote_pad->index, link_flags); v4l2_fwnode_put_link(&link); if (ret < 0) { dev_err(vi->dev, "failed to create %s:%u -> %s:%u link: %d\n", local->name, local_pad->index, remote->name, remote_pad->index, ret); break; } } fwnode_handle_put(ep); return ret; } static int tegra_vi_graph_notify_complete(struct v4l2_async_notifier *notifier) { struct tegra_vi_graph_entity *entity; struct v4l2_async_subdev *asd; struct v4l2_subdev *subdev; struct tegra_vi_channel *chan; struct tegra_vi *vi; int ret; chan = container_of(notifier, struct tegra_vi_channel, notifier); vi = chan->vi; dev_dbg(vi->dev, "notify complete, all subdevs registered\n"); /* * Video device node should be created at the end of all the device * related initialization/setup. * Current video_register_device() does both initialize and register * video device in same API. * * TODO: Update v4l2-dev driver to split initialize and register into * separate APIs and then update Tegra video driver to do video device * initialize followed by all video device related setup and then * register the video device. */ ret = video_register_device(&chan->video, VFL_TYPE_VIDEO, -1); if (ret < 0) { dev_err(vi->dev, "failed to register video device: %d\n", ret); goto unregister_video; } /* create links between the entities */ list_for_each_entry(asd, &chan->notifier.asd_list, asd_list) { entity = to_tegra_vi_graph_entity(asd); ret = tegra_vi_graph_build(chan, entity); if (ret < 0) goto unregister_video; } ret = tegra_channel_setup_ctrl_handler(chan); if (ret < 0) { dev_err(vi->dev, "failed to setup channel controls: %d\n", ret); goto unregister_video; } ret = vi_fmts_bitmap_init(chan); if (ret < 0) { dev_err(vi->dev, "failed to initialize formats bitmap: %d\n", ret); goto unregister_video; } subdev = tegra_channel_get_remote_csi_subdev(chan); if (!subdev) { ret = -ENODEV; dev_err(vi->dev, "failed to get remote csi subdev: %d\n", ret); goto unregister_video; } v4l2_set_subdev_hostdata(subdev, chan); subdev = tegra_channel_get_remote_source_subdev(chan); v4l2_set_subdev_hostdata(subdev, chan); return 0; unregister_video: vb2_video_unregister_device(&chan->video); return ret; } static int tegra_vi_graph_notify_bound(struct v4l2_async_notifier *notifier, struct v4l2_subdev *subdev, struct v4l2_async_subdev *asd) { struct tegra_vi_graph_entity *entity; struct tegra_vi *vi; struct tegra_vi_channel *chan; chan = container_of(notifier, struct tegra_vi_channel, notifier); vi = chan->vi; /* * Locate the entity corresponding to the bound subdev and store the * subdev pointer. */ entity = tegra_vi_graph_find_entity(chan, subdev->fwnode); if (!entity) { dev_err(vi->dev, "no entity for subdev %s\n", subdev->name); return -EINVAL; } if (entity->subdev) { dev_err(vi->dev, "duplicate subdev for node %pOF\n", to_of_node(entity->asd.match.fwnode)); return -EINVAL; } dev_dbg(vi->dev, "subdev %s bound\n", subdev->name); entity->entity = &subdev->entity; entity->subdev = subdev; return 0; } static const struct v4l2_async_notifier_operations tegra_vi_async_ops = { .bound = tegra_vi_graph_notify_bound, .complete = tegra_vi_graph_notify_complete, }; static int tegra_vi_graph_parse_one(struct tegra_vi_channel *chan, struct fwnode_handle *fwnode) { struct tegra_vi *vi = chan->vi; struct fwnode_handle *ep = NULL; struct fwnode_handle *remote = NULL; struct tegra_vi_graph_entity *tvge; struct device_node *node = NULL; int ret; dev_dbg(vi->dev, "parsing node %pOF\n", to_of_node(fwnode)); /* parse all the remote entities and put them into the list */ for_each_endpoint_of_node(to_of_node(fwnode), node) { ep = of_fwnode_handle(node); remote = fwnode_graph_get_remote_port_parent(ep); if (!remote) { dev_err(vi->dev, "remote device at %pOF not found\n", node); ret = -EINVAL; goto cleanup; } /* skip entities that are already processed */ if (remote == dev_fwnode(vi->dev) || tegra_vi_graph_find_entity(chan, remote)) { fwnode_handle_put(remote); continue; } tvge = v4l2_async_notifier_add_fwnode_subdev(&chan->notifier, remote, struct tegra_vi_graph_entity); if (IS_ERR(tvge)) { ret = PTR_ERR(tvge); dev_err(vi->dev, "failed to add subdev to notifier: %d\n", ret); fwnode_handle_put(remote); goto cleanup; } ret = tegra_vi_graph_parse_one(chan, remote); if (ret < 0) { fwnode_handle_put(remote); goto cleanup; } fwnode_handle_put(remote); } return 0; cleanup: dev_err(vi->dev, "failed parsing the graph: %d\n", ret); v4l2_async_notifier_cleanup(&chan->notifier); of_node_put(node); return ret; } static int tegra_vi_graph_init(struct tegra_vi *vi) { struct tegra_video_device *vid = dev_get_drvdata(vi->client.host); struct tegra_vi_channel *chan; struct fwnode_handle *fwnode = dev_fwnode(vi->dev); int ret; struct fwnode_handle *remote = NULL; /* * Walk the links to parse the full graph. Each channel will have * one endpoint of the composite node. Start by parsing the * composite node and parse the remote entities in turn. * Each channel will register v4l2 async notifier to make the graph * independent between the channels so we can the current channel * in case of something wrong during graph parsing and continue with * next channels. */ list_for_each_entry(chan, &vi->vi_chans, list) { remote = fwnode_graph_get_remote_node(fwnode, chan->portnos[0], 0); if (!remote) continue; ret = tegra_vi_graph_parse_one(chan, remote); fwnode_handle_put(remote); if (ret < 0 || list_empty(&chan->notifier.asd_list)) continue; chan->notifier.ops = &tegra_vi_async_ops; ret = v4l2_async_notifier_register(&vid->v4l2_dev, &chan->notifier); if (ret < 0) { dev_err(vi->dev, "failed to register channel %d notifier: %d\n", chan->portnos[0], ret); v4l2_async_notifier_cleanup(&chan->notifier); } } return 0; } static void tegra_vi_graph_cleanup(struct tegra_vi *vi) { struct tegra_vi_channel *chan; list_for_each_entry(chan, &vi->vi_chans, list) { vb2_video_unregister_device(&chan->video); v4l2_async_notifier_unregister(&chan->notifier); v4l2_async_notifier_cleanup(&chan->notifier); } } static int tegra_vi_init(struct host1x_client *client) { struct tegra_video_device *vid = dev_get_drvdata(client->host); struct tegra_vi *vi = host1x_client_to_vi(client); struct tegra_vi_channel *chan, *tmp; int ret; vid->media_dev.hw_revision = vi->soc->hw_revision; snprintf(vid->media_dev.bus_info, sizeof(vid->media_dev.bus_info), "platform:%s", dev_name(vi->dev)); INIT_LIST_HEAD(&vi->vi_chans); if (IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) ret = tegra_vi_tpg_channels_alloc(vi); else ret = tegra_vi_channels_alloc(vi); if (ret < 0) { dev_err(vi->dev, "failed to allocate vi channels: %d\n", ret); goto free_chans; } ret = tegra_vi_channels_init(vi); if (ret < 0) goto free_chans; vid->vi = vi; if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) { ret = tegra_vi_graph_init(vi); if (ret < 0) goto cleanup_chans; } return 0; cleanup_chans: list_for_each_entry(chan, &vi->vi_chans, list) tegra_channel_cleanup(chan); free_chans: list_for_each_entry_safe(chan, tmp, &vi->vi_chans, list) { list_del(&chan->list); kfree(chan); } return ret; } static int tegra_vi_exit(struct host1x_client *client) { struct tegra_vi *vi = host1x_client_to_vi(client); /* * Do not cleanup the channels here as application might still be * holding video device nodes. Channels cleanup will happen during * v4l2_device release callback which gets called after all video * device nodes are released. */ if (!IS_ENABLED(CONFIG_VIDEO_TEGRA_TPG)) tegra_vi_graph_cleanup(vi); return 0; } static const struct host1x_client_ops vi_client_ops = { .init = tegra_vi_init, .exit = tegra_vi_exit, }; static int tegra_vi_probe(struct platform_device *pdev) { struct tegra_vi *vi; int ret; vi = devm_kzalloc(&pdev->dev, sizeof(*vi), GFP_KERNEL); if (!vi) return -ENOMEM; vi->iomem = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(vi->iomem)) return PTR_ERR(vi->iomem); vi->soc = of_device_get_match_data(&pdev->dev); vi->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(vi->clk)) { ret = PTR_ERR(vi->clk); dev_err(&pdev->dev, "failed to get vi clock: %d\n", ret); return ret; } vi->vdd = devm_regulator_get(&pdev->dev, "avdd-dsi-csi"); if (IS_ERR(vi->vdd)) { ret = PTR_ERR(vi->vdd); dev_err(&pdev->dev, "failed to get VDD supply: %d\n", ret); return ret; } if (!pdev->dev.pm_domain) { ret = -ENOENT; dev_warn(&pdev->dev, "PM domain is not attached: %d\n", ret); return ret; } ret = devm_of_platform_populate(&pdev->dev); if (ret < 0) { dev_err(&pdev->dev, "failed to populate vi child device: %d\n", ret); return ret; } vi->dev = &pdev->dev; vi->ops = vi->soc->ops; platform_set_drvdata(pdev, vi); pm_runtime_enable(&pdev->dev); /* initialize host1x interface */ INIT_LIST_HEAD(&vi->client.list); vi->client.ops = &vi_client_ops; vi->client.dev = &pdev->dev; ret = host1x_client_register(&vi->client); if (ret < 0) { dev_err(&pdev->dev, "failed to register host1x client: %d\n", ret); goto rpm_disable; } return 0; rpm_disable: pm_runtime_disable(&pdev->dev); return ret; } static int tegra_vi_remove(struct platform_device *pdev) { struct tegra_vi *vi = platform_get_drvdata(pdev); int err; err = host1x_client_unregister(&vi->client); if (err < 0) { dev_err(&pdev->dev, "failed to unregister host1x client: %d\n", err); return err; } pm_runtime_disable(&pdev->dev); return 0; } static const struct of_device_id tegra_vi_of_id_table[] = { #if defined(CONFIG_ARCH_TEGRA_210_SOC) { .compatible = "nvidia,tegra210-vi", .data = &tegra210_vi_soc }, #endif { } }; MODULE_DEVICE_TABLE(of, tegra_vi_of_id_table); static const struct dev_pm_ops tegra_vi_pm_ops = { SET_RUNTIME_PM_OPS(vi_runtime_suspend, vi_runtime_resume, NULL) }; struct platform_driver tegra_vi_driver = { .driver = { .name = "tegra-vi", .of_match_table = tegra_vi_of_id_table, .pm = &tegra_vi_pm_ops, }, .probe = tegra_vi_probe, .remove = tegra_vi_remove, };
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1