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 *
host1x_client_to_vi(struct host1x_client * client)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 *
to_tegra_channel_buffer(struct vb2_v4l2_buffer * vb)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 *
to_tegra_vi_graph_entity(struct v4l2_async_connection * asd)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 
tegra_get_format_idx_by_code(struct tegra_vi * vi,unsigned int code,unsigned int offset)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 
tegra_get_format_fourcc_by_idx(struct tegra_vi * vi,unsigned int index)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 *
tegra_get_format_by_fourcc(struct tegra_vi * vi,u32 fourcc)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 
tegra_channel_queue_setup(struct vb2_queue * vq,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],struct device * alloc_devs[])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 
tegra_channel_buffer_prepare(struct vb2_buffer * vb)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 
tegra_channel_buffer_queue(struct vb2_buffer * vb)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 *
tegra_channel_get_remote_csi_subdev(struct tegra_vi_channel * chan)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 *
tegra_channel_get_remote_source_subdev(struct tegra_vi_channel * chan)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 
tegra_channel_enable_stream(struct tegra_vi_channel * chan)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 
tegra_channel_disable_stream(struct tegra_vi_channel * chan)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 
tegra_channel_set_stream(struct tegra_vi_channel * chan,bool on)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 
tegra_channel_release_buffers(struct tegra_vi_channel * chan,enum vb2_buffer_state state)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 
tegra_channel_start_streaming(struct vb2_queue * vq,u32 count)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 
tegra_channel_stop_streaming(struct vb2_queue * vq)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  */
tegra_channel_querycap(struct file * file,void * fh,struct v4l2_capability * cap)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 
tegra_channel_g_parm(struct file * file,void * fh,struct v4l2_streamparm * a)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 
tegra_channel_s_parm(struct file * file,void * fh,struct v4l2_streamparm * a)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 
tegra_channel_enum_framesizes(struct file * file,void * fh,struct v4l2_frmsizeenum * sizes)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 
tegra_channel_enum_frameintervals(struct file * file,void * fh,struct v4l2_frmivalenum * ivals)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 
tegra_channel_enum_format(struct file * file,void * fh,struct v4l2_fmtdesc * f)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 
tegra_channel_get_format(struct file * file,void * fh,struct v4l2_format * format)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 
__tegra_channel_try_format(struct tegra_vi_channel * chan,struct v4l2_pix_format * pix)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 
tegra_channel_try_format(struct file * file,void * fh,struct v4l2_format * format)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 
tegra_channel_update_gangports(struct tegra_vi_channel * chan)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 
tegra_channel_set_format(struct file * file,void * fh,struct v4l2_format * format)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 
tegra_channel_set_subdev_active_fmt(struct tegra_vi_channel * chan)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
tegra_channel_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)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 
tegra_channel_g_selection(struct file * file,void * priv,struct v4l2_selection * sel)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 
tegra_channel_s_selection(struct file * file,void * fh,struct v4l2_selection * sel)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 
tegra_channel_g_edid(struct file * file,void * fh,struct v4l2_edid * edid)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 
tegra_channel_s_edid(struct file * file,void * fh,struct v4l2_edid * edid)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 
tegra_channel_g_dv_timings(struct file * file,void * fh,struct v4l2_dv_timings * timings)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 
tegra_channel_s_dv_timings(struct file * file,void * fh,struct v4l2_dv_timings * timings)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 
tegra_channel_query_dv_timings(struct file * file,void * fh,struct v4l2_dv_timings * timings)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 
tegra_channel_enum_dv_timings(struct file * file,void * fh,struct v4l2_enum_dv_timings * timings)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 
tegra_channel_dv_timings_cap(struct file * file,void * fh,struct v4l2_dv_timings_cap * cap)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 
tegra_channel_log_status(struct file * file,void * fh)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 
tegra_channel_enum_input(struct file * file,void * fh,struct v4l2_input * inp)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 
tegra_channel_g_input(struct file * file,void * priv,unsigned int * i)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 
tegra_channel_s_input(struct file * file,void * priv,unsigned int input)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  */
vi_s_ctrl(struct v4l2_ctrl * ctrl)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 
tegra_channel_setup_ctrl_handler(struct tegra_vi_channel * chan)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 */
vi_tpg_fmts_bitmap_init(struct tegra_vi_channel * chan)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 
vi_fmts_bitmap_init(struct tegra_vi_channel * chan)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 
tegra_channel_cleanup(struct tegra_vi_channel * chan)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 
tegra_channels_cleanup(struct tegra_vi * vi)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 
tegra_channel_init(struct tegra_vi_channel * chan)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 
tegra_vi_channel_alloc(struct tegra_vi * vi,unsigned int port_num,struct device_node * node,unsigned int lanes)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 
tegra_vi_tpg_channels_alloc(struct tegra_vi * vi)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 
tegra_vi_channels_alloc(struct tegra_vi * vi)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 
tegra_vi_channels_init(struct tegra_vi * vi)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 
tegra_v4l2_nodes_cleanup_tpg(struct tegra_video_device * vid)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 
tegra_v4l2_nodes_setup_tpg(struct tegra_video_device * vid)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 
vi_runtime_resume(struct device * dev)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 
vi_runtime_suspend(struct device * dev)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 *
tegra_vi_graph_find_entity(struct list_head * list,const struct fwnode_handle * fwnode)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 
tegra_vi_graph_build(struct tegra_vi_channel * chan,struct tegra_vi_graph_entity * entity)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 
tegra_vi_graph_notify_complete(struct v4l2_async_notifier * notifier)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 
tegra_vi_graph_notify_bound(struct v4l2_async_notifier * notifier,struct v4l2_subdev * subdev,struct v4l2_async_connection * asd)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 
tegra_vi_graph_parse_one(struct tegra_vi_channel * chan,struct fwnode_handle * fwnode)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 
tegra_vi_graph_init(struct tegra_vi * vi)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 
tegra_vi_graph_cleanup(struct tegra_vi * vi)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 
tegra_vi_init(struct host1x_client * client)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 
tegra_vi_exit(struct host1x_client * client)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 
tegra_vi_probe(struct platform_device * pdev)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 
tegra_vi_remove(struct platform_device * pdev)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 };
1984