vivid-kthread-cap.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * vivid-kthread-cap.h - video/vbi capture thread support functions.
  4 *
  5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  6 */
  7
  8#include <linux/module.h>
  9#include <linux/errno.h>
 10#include <linux/kernel.h>
 11#include <linux/init.h>
 12#include <linux/sched.h>
 13#include <linux/slab.h>
 14#include <linux/font.h>
 15#include <linux/mutex.h>
 16#include <linux/videodev2.h>
 17#include <linux/kthread.h>
 18#include <linux/freezer.h>
 19#include <linux/random.h>
 20#include <linux/v4l2-dv-timings.h>
 21#include <linux/jiffies.h>
 22#include <asm/div64.h>
 23#include <media/videobuf2-vmalloc.h>
 24#include <media/v4l2-dv-timings.h>
 25#include <media/v4l2-ioctl.h>
 26#include <media/v4l2-fh.h>
 27#include <media/v4l2-event.h>
 28#include <media/v4l2-rect.h>
 29
 30#include "vivid-core.h"
 31#include "vivid-vid-common.h"
 32#include "vivid-vid-cap.h"
 33#include "vivid-vid-out.h"
 34#include "vivid-radio-common.h"
 35#include "vivid-radio-rx.h"
 36#include "vivid-radio-tx.h"
 37#include "vivid-sdr-cap.h"
 38#include "vivid-vbi-cap.h"
 39#include "vivid-vbi-out.h"
 40#include "vivid-osd.h"
 41#include "vivid-ctrls.h"
 42#include "vivid-kthread-cap.h"
 43#include "vivid-meta-cap.h"
 44
 45static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
 46{
 47	if (vivid_is_sdtv_cap(dev))
 48		return dev->std_cap[dev->input];
 49	return 0;
 50}
 51
 52static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
 53			u16 *cap, const u16 *osd)
 54{
 55	u16 out;
 56
 57	out = *cap;
 58	*cap = *osd;
 59
 60	if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
 61	    *osd != dev->chromakey_out)
 62		return;
 63	if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
 64	    out == dev->chromakey_out)
 65		return;
 66	if (dev->fmt_cap->alpha_mask) {
 67		if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
 68		    dev->global_alpha_out)
 69			return;
 70		if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
 71		    *cap & dev->fmt_cap->alpha_mask)
 72			return;
 73		if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
 74		    !(*cap & dev->fmt_cap->alpha_mask))
 75			return;
 76	}
 77	*cap = out;
 78}
 79
 80static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
 81		u8 *vcapbuf, const u8 *vosdbuf,
 82		unsigned width, unsigned pixsize)
 83{
 84	unsigned x;
 85
 86	for (x = 0; x < width; x++, vcapbuf += pixsize, vosdbuf += pixsize) {
 87		copy_pix(dev, y_offset, x_offset + x,
 88			 (u16 *)vcapbuf, (const u16 *)vosdbuf);
 89	}
 90}
 91
 92static void scale_line(const u8 *src, u8 *dst, unsigned srcw, unsigned dstw, unsigned twopixsize)
 93{
 94	/* Coarse scaling with Bresenham */
 95	unsigned int_part;
 96	unsigned fract_part;
 97	unsigned src_x = 0;
 98	unsigned error = 0;
 99	unsigned x;
100
101	/*
102	 * We always combine two pixels to prevent color bleed in the packed
103	 * yuv case.
104	 */
105	srcw /= 2;
106	dstw /= 2;
107	int_part = srcw / dstw;
108	fract_part = srcw % dstw;
109	for (x = 0; x < dstw; x++, dst += twopixsize) {
110		memcpy(dst, src + src_x * twopixsize, twopixsize);
111		src_x += int_part;
112		error += fract_part;
113		if (error >= dstw) {
114			error -= dstw;
115			src_x++;
116		}
117	}
118}
119
120/*
121 * Precalculate the rectangles needed to perform video looping:
122 *
123 * The nominal pipeline is that the video output buffer is cropped by
124 * crop_out, scaled to compose_out, overlaid with the output overlay,
125 * cropped on the capture side by crop_cap and scaled again to the video
126 * capture buffer using compose_cap.
127 *
128 * To keep things efficient we calculate the intersection of compose_out
129 * and crop_cap (since that's the only part of the video that will
130 * actually end up in the capture buffer), determine which part of the
131 * video output buffer that is and which part of the video capture buffer
132 * so we can scale the video straight from the output buffer to the capture
133 * buffer without any intermediate steps.
134 *
135 * If we need to deal with an output overlay, then there is no choice and
136 * that intermediate step still has to be taken. For the output overlay
137 * support we calculate the intersection of the framebuffer and the overlay
138 * window (which may be partially or wholly outside of the framebuffer
139 * itself) and the intersection of that with loop_vid_copy (i.e. the part of
140 * the actual looped video that will be overlaid). The result is calculated
141 * both in framebuffer coordinates (loop_fb_copy) and compose_out coordinates
142 * (loop_vid_overlay). Finally calculate the part of the capture buffer that
143 * will receive that overlaid video.
144 */
145static void vivid_precalc_copy_rects(struct vivid_dev *dev, struct vivid_dev *out_dev)
146{
147	/* Framebuffer rectangle */
148	struct v4l2_rect r_fb = {
149		0, 0, dev->display_width, dev->display_height
150	};
151	/* Overlay window rectangle in framebuffer coordinates */
152	struct v4l2_rect r_overlay = {
153		out_dev->overlay_out_left, out_dev->overlay_out_top,
154		out_dev->compose_out.width, out_dev->compose_out.height
155	};
156
157	v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &out_dev->compose_out);
158
159	dev->loop_vid_out = dev->loop_vid_copy;
160	v4l2_rect_scale(&dev->loop_vid_out, &out_dev->compose_out, &out_dev->crop_out);
161	dev->loop_vid_out.left += out_dev->crop_out.left;
162	dev->loop_vid_out.top += out_dev->crop_out.top;
163
164	dev->loop_vid_cap = dev->loop_vid_copy;
165	v4l2_rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
166
167	dprintk(dev, 1,
168		"loop_vid_copy: (%d,%d)/%ux%u loop_vid_out: (%d,%d)/%ux%u loop_vid_cap: (%d,%d)/%ux%u\n",
169		dev->loop_vid_copy.left, dev->loop_vid_copy.top,
170		dev->loop_vid_copy.width, dev->loop_vid_copy.height,
171		dev->loop_vid_out.left, dev->loop_vid_out.top,
172		dev->loop_vid_out.width, dev->loop_vid_out.height,
173		dev->loop_vid_cap.left, dev->loop_vid_cap.top,
174		dev->loop_vid_cap.width, dev->loop_vid_cap.height);
175
176	v4l2_rect_intersect(&r_overlay, &r_fb, &r_overlay);
177
178	/* shift r_overlay to the same origin as compose_out */
179	r_overlay.left += out_dev->compose_out.left - out_dev->overlay_out_left;
180	r_overlay.top += out_dev->compose_out.top - out_dev->overlay_out_top;
181
182	v4l2_rect_intersect(&dev->loop_vid_overlay, &r_overlay, &dev->loop_vid_copy);
183	dev->loop_fb_copy = dev->loop_vid_overlay;
184
185	/* shift dev->loop_fb_copy back again to the fb origin */
186	dev->loop_fb_copy.left -= out_dev->compose_out.left - out_dev->overlay_out_left;
187	dev->loop_fb_copy.top -= out_dev->compose_out.top - out_dev->overlay_out_top;
188
189	dev->loop_vid_overlay_cap = dev->loop_vid_overlay;
190	v4l2_rect_scale(&dev->loop_vid_overlay_cap, &dev->crop_cap, &dev->compose_cap);
191
192	dprintk(dev, 1,
193		"loop_fb_copy: (%d,%d)/%ux%u loop_vid_overlay: (%d,%d)/%ux%u loop_vid_overlay_cap: (%d,%d)/%ux%u\n",
194		dev->loop_fb_copy.left, dev->loop_fb_copy.top,
195		dev->loop_fb_copy.width, dev->loop_fb_copy.height,
196		dev->loop_vid_overlay.left, dev->loop_vid_overlay.top,
197		dev->loop_vid_overlay.width, dev->loop_vid_overlay.height,
198		dev->loop_vid_overlay_cap.left, dev->loop_vid_overlay_cap.top,
199		dev->loop_vid_overlay_cap.width, dev->loop_vid_overlay_cap.height);
200}
201
202static void *plane_vaddr(struct tpg_data *tpg, struct vivid_buffer *buf,
203			 unsigned p, unsigned bpl[TPG_MAX_PLANES], unsigned h)
204{
205	unsigned i;
206	void *vbuf;
207
208	if (p == 0 || tpg_g_buffers(tpg) > 1)
209		return vb2_plane_vaddr(&buf->vb.vb2_buf, p);
210	vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
211	for (i = 0; i < p; i++)
212		vbuf += bpl[i] * h / tpg->vdownsampling[i];
213	return vbuf;
214}
215
216static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev,
217						struct vivid_dev *out_dev, unsigned p,
218						u8 *vcapbuf, struct vivid_buffer *vid_cap_buf)
219{
220	bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
221	struct tpg_data *tpg = &dev->tpg;
222	struct vivid_buffer *vid_out_buf = NULL;
223	unsigned vdiv = out_dev->fmt_out->vdownsampling[p];
224	unsigned twopixsize = tpg_g_twopixelsize(tpg, p);
225	unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
226	unsigned img_height = dev->compose_cap.height;
227	unsigned stride_cap = tpg->bytesperline[p];
228	unsigned stride_out = out_dev->bytesperline_out[p];
229	unsigned stride_osd = dev->display_byte_stride;
230	unsigned hmax = (img_height * tpg->perc_fill) / 100;
231	u8 *voutbuf;
232	u8 *vosdbuf = NULL;
233	unsigned y;
234	bool blend = out_dev->fbuf_out_flags;
235	/* Coarse scaling with Bresenham */
236	unsigned vid_out_int_part;
237	unsigned vid_out_fract_part;
238	unsigned vid_out_y = 0;
239	unsigned vid_out_error = 0;
240	unsigned vid_overlay_int_part = 0;
241	unsigned vid_overlay_fract_part = 0;
242	unsigned vid_overlay_y = 0;
243	unsigned vid_overlay_error = 0;
244	unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
245	unsigned vid_cap_right;
246	bool quick;
247
248	vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
249	vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
250
251	if (!list_empty(&out_dev->vid_out_active))
252		vid_out_buf = list_entry(out_dev->vid_out_active.next,
253					 struct vivid_buffer, list);
254	if (vid_out_buf == NULL)
255		return -ENODATA;
256
257	vid_cap_buf->vb.field = vid_out_buf->vb.field;
258
259	voutbuf = plane_vaddr(tpg, vid_out_buf, p,
260			      out_dev->bytesperline_out, out_dev->fmt_out_rect.height);
261	if (p < out_dev->fmt_out->buffers)
262		voutbuf += vid_out_buf->vb.vb2_buf.planes[p].data_offset;
263	voutbuf += tpg_hdiv(tpg, p, dev->loop_vid_out.left) +
264		(dev->loop_vid_out.top / vdiv) * stride_out;
265	vcapbuf += tpg_hdiv(tpg, p, dev->compose_cap.left) +
266		(dev->compose_cap.top / vdiv) * stride_cap;
267
268	if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
269		/*
270		 * If there is nothing to copy, then just fill the capture window
271		 * with black.
272		 */
273		for (y = 0; y < hmax / vdiv; y++, vcapbuf += stride_cap)
274			memcpy(vcapbuf, tpg->black_line[p], img_width);
275		return 0;
276	}
277
278	if (out_dev->overlay_out_enabled &&
279	    dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
280		vosdbuf = dev->video_vbase;
281		vosdbuf += (dev->loop_fb_copy.left * twopixsize) / 2 +
282			   dev->loop_fb_copy.top * stride_osd;
283		vid_overlay_int_part = dev->loop_vid_overlay.height /
284				       dev->loop_vid_overlay_cap.height;
285		vid_overlay_fract_part = dev->loop_vid_overlay.height %
286					 dev->loop_vid_overlay_cap.height;
287	}
288
289	vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
290	/* quick is true if no video scaling is needed */
291	quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
292
293	dev->cur_scaled_line = dev->loop_vid_out.height;
294	for (y = 0; y < hmax; y += vdiv, vcapbuf += stride_cap) {
295		/* osdline is true if this line requires overlay blending */
296		bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
297			  y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
298
299		/*
300		 * If this line of the capture buffer doesn't get any video, then
301		 * just fill with black.
302		 */
303		if (y < dev->loop_vid_cap.top ||
304		    y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
305			memcpy(vcapbuf, tpg->black_line[p], img_width);
306			continue;
307		}
308
309		/* fill the left border with black */
310		if (dev->loop_vid_cap.left)
311			memcpy(vcapbuf, tpg->black_line[p], vid_cap_left);
312
313		/* fill the right border with black */
314		if (vid_cap_right < img_width)
315			memcpy(vcapbuf + vid_cap_right, tpg->black_line[p],
316				img_width - vid_cap_right);
317
318		if (quick && !osdline) {
319			memcpy(vcapbuf + vid_cap_left,
320			       voutbuf + vid_out_y * stride_out,
321			       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
322			goto update_vid_out_y;
323		}
324		if (dev->cur_scaled_line == vid_out_y) {
325			memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
326			       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
327			goto update_vid_out_y;
328		}
329		if (!osdline) {
330			scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
331				tpg_hdiv(tpg, p, dev->loop_vid_out.width),
332				tpg_hdiv(tpg, p, dev->loop_vid_cap.width),
333				tpg_g_twopixelsize(tpg, p));
334		} else {
335			/*
336			 * Offset in bytes within loop_vid_copy to the start of the
337			 * loop_vid_overlay rectangle.
338			 */
339			unsigned offset =
340				((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
341				 twopixsize) / 2;
342			u8 *osd = vosdbuf + vid_overlay_y * stride_osd;
343
344			scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
345				dev->loop_vid_out.width, dev->loop_vid_copy.width,
346				tpg_g_twopixelsize(tpg, p));
347			if (blend)
348				blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
349					   dev->loop_vid_overlay.left,
350					   dev->blended_line + offset, osd,
351					   dev->loop_vid_overlay.width, twopixsize / 2);
352			else
353				memcpy(dev->blended_line + offset,
354				       osd, (dev->loop_vid_overlay.width * twopixsize) / 2);
355			scale_line(dev->blended_line, dev->scaled_line,
356					dev->loop_vid_copy.width, dev->loop_vid_cap.width,
357					tpg_g_twopixelsize(tpg, p));
358		}
359		dev->cur_scaled_line = vid_out_y;
360		memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
361		       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
362
363update_vid_out_y:
364		if (osdline) {
365			vid_overlay_y += vid_overlay_int_part;
366			vid_overlay_error += vid_overlay_fract_part;
367			if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
368				vid_overlay_error -= dev->loop_vid_overlay_cap.height;
369				vid_overlay_y++;
370			}
371		}
372		vid_out_y += vid_out_int_part;
373		vid_out_error += vid_out_fract_part;
374		if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
375			vid_out_error -= dev->loop_vid_cap.height / vdiv;
376			vid_out_y++;
377		}
378	}
379
380	if (!blank)
381		return 0;
382	for (; y < img_height; y += vdiv, vcapbuf += stride_cap)
383		memcpy(vcapbuf, tpg->contrast_line[p], img_width);
384	return 0;
385}
386
387static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
388{
389	struct vivid_dev *out_dev = NULL;
390	struct tpg_data *tpg = &dev->tpg;
391	unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
392	unsigned line_height = 16 / factor;
393	bool is_tv = vivid_is_sdtv_cap(dev);
394	bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
395	unsigned p;
396	int line = 1;
397	u8 *basep[TPG_MAX_PLANES][2];
398	unsigned ms;
399	char str[100];
400	s32 gain;
401
402	buf->vb.sequence = dev->vid_cap_seq_count;
403	v4l2_ctrl_s_ctrl(dev->ro_int32, buf->vb.sequence & 0xff);
404	if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
405		/*
406		 * 60 Hz standards start with the bottom field, 50 Hz standards
407		 * with the top field. So if the 0-based seq_count is even,
408		 * then the field is TOP for 50 Hz and BOTTOM for 60 Hz
409		 * standards.
410		 */
411		buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
412			V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
413		/*
414		 * The sequence counter counts frames, not fields. So divide
415		 * by two.
416		 */
417		buf->vb.sequence /= 2;
418	} else {
419		buf->vb.field = dev->field_cap;
420	}
421	tpg_s_field(tpg, buf->vb.field,
422		    dev->field_cap == V4L2_FIELD_ALTERNATE);
423	tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
424
425	if (vivid_vid_can_loop(dev) &&
426	    ((vivid_is_svid_cap(dev) &&
427	    !VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) ||
428	    (vivid_is_hdmi_cap(dev) &&
429	    !VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input])))) {
430		out_dev = vivid_input_is_connected_to(dev);
431		/*
432		 * If the vivid instance of the output device is different
433		 * from the vivid instance of this input device, then we
434		 * must take care to properly serialize the output device to
435		 * prevent that the buffer we are copying from is being freed.
436		 *
437		 * If the output device is part of the same instance, then the
438		 * lock is already taken and there is no need to take the mutex.
439		 *
440		 * The problem with taking the mutex is that you can get
441		 * deadlocked if instance A locks instance B and vice versa.
442		 * It is not really worth trying to be very smart about this,
443		 * so just try to take the lock, and if you can't, then just
444		 * set out_dev to NULL and you will end up with a single frame
445		 * of Noise (the default test pattern in this case).
446		 */
447		if (out_dev && dev != out_dev && !mutex_trylock(&out_dev->mutex))
448			out_dev = NULL;
449	}
450
451	if (out_dev)
452		vivid_precalc_copy_rects(dev, out_dev);
453
454	for (p = 0; p < tpg_g_planes(tpg); p++) {
455		void *vbuf = plane_vaddr(tpg, buf, p,
456					 tpg->bytesperline, tpg->buf_height);
457
458		/*
459		 * The first plane of a multiplanar format has a non-zero
460		 * data_offset. This helps testing whether the application
461		 * correctly supports non-zero data offsets.
462		 */
463		if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
464			memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
465			       dev->fmt_cap->data_offset[p]);
466			vbuf += dev->fmt_cap->data_offset[p];
467		}
468		tpg_calc_text_basep(tpg, basep, p, vbuf);
469		if (!out_dev || vivid_copy_buffer(dev, out_dev, p, vbuf, buf))
470			tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
471					p, vbuf);
472	}
473	if (out_dev && dev != out_dev)
474		mutex_unlock(&out_dev->mutex);
475
476	dev->must_blank[buf->vb.vb2_buf.index] = false;
477
478	/* Updates stream time, only update at the start of a new frame. */
479	if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
480			(dev->vid_cap_seq_count & 1) == 0)
481		dev->ms_vid_cap =
482			jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
483
484	ms = dev->ms_vid_cap;
485	if (dev->osd_mode <= 1) {
486		snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d %u%s",
487				(ms / (60 * 60 * 1000)) % 24,
488				(ms / (60 * 1000)) % 60,
489				(ms / 1000) % 60,
490				ms % 1000,
491				buf->vb.sequence,
492				(dev->field_cap == V4L2_FIELD_ALTERNATE) ?
493					(buf->vb.field == V4L2_FIELD_TOP ?
494					 " top" : " bottom") : "");
495		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
496	}
497	if (dev->osd_mode == 0) {
498		snprintf(str, sizeof(str), " %dx%d, input %d ",
499				dev->src_rect.width, dev->src_rect.height, dev->input);
500		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
501
502		gain = v4l2_ctrl_g_ctrl(dev->gain);
503		mutex_lock(dev->ctrl_hdl_user_vid.lock);
504		snprintf(str, sizeof(str),
505			" brightness %3d, contrast %3d, saturation %3d, hue %d ",
506			dev->brightness->cur.val,
507			dev->contrast->cur.val,
508			dev->saturation->cur.val,
509			dev->hue->cur.val);
510		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
511		snprintf(str, sizeof(str),
512			" autogain %d, gain %3d, alpha 0x%02x ",
513			dev->autogain->cur.val, gain, dev->alpha->cur.val);
514		mutex_unlock(dev->ctrl_hdl_user_vid.lock);
515		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
516		mutex_lock(dev->ctrl_hdl_user_aud.lock);
517		snprintf(str, sizeof(str),
518			" volume %3d, mute %d ",
519			dev->volume->cur.val, dev->mute->cur.val);
520		mutex_unlock(dev->ctrl_hdl_user_aud.lock);
521		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
522		mutex_lock(dev->ctrl_hdl_user_gen.lock);
523		snprintf(str, sizeof(str), " int32 %d, ro_int32 %d, int64 %lld, bitmask %08x ",
524			 dev->int32->cur.val,
525			 dev->ro_int32->cur.val,
526			 *dev->int64->p_cur.p_s64,
527			 dev->bitmask->cur.val);
528		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
529		snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
530			dev->boolean->cur.val,
531			dev->menu->qmenu[dev->menu->cur.val],
532			dev->string->p_cur.p_char);
533		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
534		snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
535			dev->int_menu->qmenu_int[dev->int_menu->cur.val],
536			dev->int_menu->cur.val);
537		mutex_unlock(dev->ctrl_hdl_user_gen.lock);
538		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
539		if (dev->button_pressed) {
540			dev->button_pressed--;
541			snprintf(str, sizeof(str), " button pressed!");
542			tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
543		}
544		if (dev->osd[0]) {
545			if (vivid_is_hdmi_cap(dev)) {
546				snprintf(str, sizeof(str),
547					 " OSD \"%s\"", dev->osd);
548				tpg_gen_text(tpg, basep, line++ * line_height,
549					     16, str);
550			}
551			if (dev->osd_jiffies &&
552			    time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
553				dev->osd[0] = 0;
554				dev->osd_jiffies = 0;
555			}
556		}
557	}
558}
559
560static void vivid_cap_update_frame_period(struct vivid_dev *dev)
561{
562	u64 f_period;
563
564	f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
565	if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
566		dev->timeperframe_vid_cap.denominator = 1;
567	do_div(f_period, dev->timeperframe_vid_cap.denominator);
568	if (dev->field_cap == V4L2_FIELD_ALTERNATE)
569		f_period >>= 1;
570	/*
571	 * If "End of Frame", then offset the exposure time by 0.9
572	 * of the frame period.
573	 */
574	dev->cap_frame_eof_offset = f_period * 9;
575	do_div(dev->cap_frame_eof_offset, 10);
576	dev->cap_frame_period = f_period;
577}
578
579static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
580							 int dropped_bufs)
581{
582	struct vivid_buffer *vid_cap_buf = NULL;
583	struct vivid_buffer *vbi_cap_buf = NULL;
584	struct vivid_buffer *meta_cap_buf = NULL;
585	u64 f_time = 0;
586
587	dprintk(dev, 1, "Video Capture Thread Tick\n");
588
589	while (dropped_bufs-- > 1)
590		tpg_update_mv_count(&dev->tpg,
591				dev->field_cap == V4L2_FIELD_NONE ||
592				dev->field_cap == V4L2_FIELD_ALTERNATE);
593
594	/* Drop a certain percentage of buffers. */
595	if (dev->perc_dropped_buffers &&
596	    get_random_u32_below(100) < dev->perc_dropped_buffers)
597		goto update_mv;
598
599	spin_lock(&dev->slock);
600	if (!list_empty(&dev->vid_cap_active)) {
601		vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
602		list_del(&vid_cap_buf->list);
603	}
604	if (!list_empty(&dev->vbi_cap_active)) {
605		if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
606		    (dev->vbi_cap_seq_count & 1)) {
607			vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
608						 struct vivid_buffer, list);
609			list_del(&vbi_cap_buf->list);
610		}
611	}
612	if (!list_empty(&dev->meta_cap_active)) {
613		meta_cap_buf = list_entry(dev->meta_cap_active.next,
614					  struct vivid_buffer, list);
615		list_del(&meta_cap_buf->list);
616	}
617
618	spin_unlock(&dev->slock);
619
620	if (!vid_cap_buf && !vbi_cap_buf && !meta_cap_buf)
621		goto update_mv;
622
623	f_time = ktime_get_ns() + dev->time_wrap_offset;
624
625	if (vid_cap_buf) {
626		v4l2_ctrl_request_setup(vid_cap_buf->vb.vb2_buf.req_obj.req,
627					&dev->ctrl_hdl_vid_cap);
628		/* Fill buffer */
629		vivid_fillbuff(dev, vid_cap_buf);
630		dprintk(dev, 1, "filled buffer %d\n",
631			vid_cap_buf->vb.vb2_buf.index);
632
633		v4l2_ctrl_request_complete(vid_cap_buf->vb.vb2_buf.req_obj.req,
634					   &dev->ctrl_hdl_vid_cap);
635		vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
636				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
637		dprintk(dev, 2, "vid_cap buffer %d done\n",
638				vid_cap_buf->vb.vb2_buf.index);
639
640		vid_cap_buf->vb.vb2_buf.timestamp = f_time;
641		if (!dev->tstamp_src_is_soe)
642			vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
643	}
644
645	if (vbi_cap_buf) {
646		u64 vbi_period;
647
648		v4l2_ctrl_request_setup(vbi_cap_buf->vb.vb2_buf.req_obj.req,
649					&dev->ctrl_hdl_vbi_cap);
650		if (vbi_cap_buf->vb.vb2_buf.type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
651			vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
652		else
653			vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
654		v4l2_ctrl_request_complete(vbi_cap_buf->vb.vb2_buf.req_obj.req,
655					   &dev->ctrl_hdl_vbi_cap);
656		vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
657				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
658		dprintk(dev, 2, "vbi_cap %d done\n",
659				vbi_cap_buf->vb.vb2_buf.index);
660
661		/* If capturing a VBI, offset by 0.05 */
662		vbi_period = dev->cap_frame_period * 5;
663		do_div(vbi_period, 100);
664		vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
665	}
666
667	if (meta_cap_buf) {
668		v4l2_ctrl_request_setup(meta_cap_buf->vb.vb2_buf.req_obj.req,
669					&dev->ctrl_hdl_meta_cap);
670		vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
671		v4l2_ctrl_request_complete(meta_cap_buf->vb.vb2_buf.req_obj.req,
672					   &dev->ctrl_hdl_meta_cap);
673		vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
674				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
675		dprintk(dev, 2, "meta_cap %d done\n",
676			meta_cap_buf->vb.vb2_buf.index);
677		meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
678	}
679
680	dev->dqbuf_error = false;
681
682update_mv:
683	/* Update the test pattern movement counters */
684	tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
685				       dev->field_cap == V4L2_FIELD_ALTERNATE);
686}
687
688static int vivid_thread_vid_cap(void *data)
689{
690	struct vivid_dev *dev = data;
691	u64 numerators_since_start;
692	u64 buffers_since_start;
693	u64 next_jiffies_since_start;
694	unsigned long jiffies_since_start;
695	unsigned long cur_jiffies;
696	unsigned wait_jiffies;
697	unsigned numerator;
698	unsigned denominator;
699	int dropped_bufs;
700
701	dprintk(dev, 1, "Video Capture Thread Start\n");
702
703	set_freezable();
704
705	/* Resets frame counters */
706	dev->cap_seq_offset = 0;
707	dev->cap_seq_count = 0;
708	dev->cap_seq_resync = false;
709	dev->jiffies_vid_cap = jiffies;
710	dev->cap_stream_start = ktime_get_ns();
711	if (dev->time_wrap)
712		dev->time_wrap_offset = dev->time_wrap - dev->cap_stream_start;
713	else
714		dev->time_wrap_offset = 0;
715	vivid_cap_update_frame_period(dev);
716
717	for (;;) {
718		try_to_freeze();
719		if (kthread_should_stop())
720			break;
721
722		if (!mutex_trylock(&dev->mutex)) {
723			schedule();
724			continue;
725		}
726
727		cur_jiffies = jiffies;
728		if (dev->cap_seq_resync) {
729			dev->jiffies_vid_cap = cur_jiffies;
730			dev->cap_seq_offset = dev->cap_seq_count + 1;
731			dev->cap_seq_count = 0;
732			dev->cap_stream_start += dev->cap_frame_period *
733						 dev->cap_seq_offset;
734			vivid_cap_update_frame_period(dev);
735			dev->cap_seq_resync = false;
736		}
737		numerator = dev->timeperframe_vid_cap.numerator;
738		denominator = dev->timeperframe_vid_cap.denominator;
739
740		if (dev->field_cap == V4L2_FIELD_ALTERNATE)
741			denominator *= 2;
742
743		/* Calculate the number of jiffies since we started streaming */
744		jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
745		/* Get the number of buffers streamed since the start */
746		buffers_since_start = (u64)jiffies_since_start * denominator +
747				      (HZ * numerator) / 2;
748		do_div(buffers_since_start, HZ * numerator);
749
750		/*
751		 * After more than 0xf0000000 (rounded down to a multiple of
752		 * 'jiffies-per-day' to ease jiffies_to_msecs calculation)
753		 * jiffies have passed since we started streaming reset the
754		 * counters and keep track of the sequence offset.
755		 */
756		if (jiffies_since_start > JIFFIES_RESYNC) {
757			dev->jiffies_vid_cap = cur_jiffies;
758			dev->cap_seq_offset = buffers_since_start;
759			buffers_since_start = 0;
760		}
761		dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
762		dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
763		dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
764		dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
765		dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
766
767		vivid_thread_vid_cap_tick(dev, dropped_bufs);
768
769		/*
770		 * Calculate the number of 'numerators' streamed since we started,
771		 * including the current buffer.
772		 */
773		numerators_since_start = ++buffers_since_start * numerator;
774
775		/* And the number of jiffies since we started */
776		jiffies_since_start = jiffies - dev->jiffies_vid_cap;
777
778		mutex_unlock(&dev->mutex);
779
780		/*
781		 * Calculate when that next buffer is supposed to start
782		 * in jiffies since we started streaming.
783		 */
784		next_jiffies_since_start = numerators_since_start * HZ +
785					   denominator / 2;
786		do_div(next_jiffies_since_start, denominator);
787		/* If it is in the past, then just schedule asap */
788		if (next_jiffies_since_start < jiffies_since_start)
789			next_jiffies_since_start = jiffies_since_start;
790
791		wait_jiffies = next_jiffies_since_start - jiffies_since_start;
792		if (!time_is_after_jiffies(cur_jiffies + wait_jiffies))
793			continue;
794
795		wait_queue_head_t wait;
796
797		init_waitqueue_head(&wait);
798		wait_event_interruptible_timeout(wait, kthread_should_stop(),
799					cur_jiffies + wait_jiffies - jiffies);
800	}
801	dprintk(dev, 1, "Video Capture Thread End\n");
802	return 0;
803}
804
805static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
806{
807	v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
808	v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
809	v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
810}
811
812int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
813{
814	dprintk(dev, 1, "%s\n", __func__);
815
816	if (dev->kthread_vid_cap) {
817		u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
818
819		if (pstreaming == &dev->vid_cap_streaming)
820			dev->vid_cap_seq_start = seq_count;
821		else if (pstreaming == &dev->vbi_cap_streaming)
822			dev->vbi_cap_seq_start = seq_count;
823		else
824			dev->meta_cap_seq_start = seq_count;
825		*pstreaming = true;
826		return 0;
827	}
828
829	/* Resets frame counters */
830	tpg_init_mv_count(&dev->tpg);
831
832	dev->vid_cap_seq_start = dev->seq_wrap * 128;
833	dev->vbi_cap_seq_start = dev->seq_wrap * 128;
834	dev->meta_cap_seq_start = dev->seq_wrap * 128;
835
836	dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
837			"%s-vid-cap", dev->v4l2_dev.name);
838
839	if (IS_ERR(dev->kthread_vid_cap)) {
840		int err = PTR_ERR(dev->kthread_vid_cap);
841
842		dev->kthread_vid_cap = NULL;
843		v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
844		return err;
845	}
846	*pstreaming = true;
847	vivid_grab_controls(dev, true);
848
849	dprintk(dev, 1, "returning from %s\n", __func__);
850	return 0;
851}
852
853void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
854{
855	dprintk(dev, 1, "%s\n", __func__);
856
857	if (dev->kthread_vid_cap == NULL)
858		return;
859
860	*pstreaming = false;
861	if (pstreaming == &dev->vid_cap_streaming) {
862		/* Release all active buffers */
863		while (!list_empty(&dev->vid_cap_active)) {
864			struct vivid_buffer *buf;
865
866			buf = list_entry(dev->vid_cap_active.next,
867					 struct vivid_buffer, list);
868			list_del(&buf->list);
869			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
870						   &dev->ctrl_hdl_vid_cap);
871			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
872			dprintk(dev, 2, "vid_cap buffer %d done\n",
873				buf->vb.vb2_buf.index);
874		}
875	}
876
877	if (pstreaming == &dev->vbi_cap_streaming) {
878		while (!list_empty(&dev->vbi_cap_active)) {
879			struct vivid_buffer *buf;
880
881			buf = list_entry(dev->vbi_cap_active.next,
882					 struct vivid_buffer, list);
883			list_del(&buf->list);
884			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
885						   &dev->ctrl_hdl_vbi_cap);
886			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
887			dprintk(dev, 2, "vbi_cap buffer %d done\n",
888				buf->vb.vb2_buf.index);
889		}
890	}
891
892	if (pstreaming == &dev->meta_cap_streaming) {
893		while (!list_empty(&dev->meta_cap_active)) {
894			struct vivid_buffer *buf;
895
896			buf = list_entry(dev->meta_cap_active.next,
897					 struct vivid_buffer, list);
898			list_del(&buf->list);
899			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
900						   &dev->ctrl_hdl_meta_cap);
901			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
902			dprintk(dev, 2, "meta_cap buffer %d done\n",
903				buf->vb.vb2_buf.index);
904		}
905	}
906
907	if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
908	    dev->meta_cap_streaming)
909		return;
910
911	/* shutdown control thread */
912	vivid_grab_controls(dev, false);
913	kthread_stop(dev->kthread_vid_cap);
914	dev->kthread_vid_cap = NULL;
915}