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 
vivid_get_std_cap(const struct vivid_dev * dev)45 static 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 
copy_pix(struct vivid_dev * dev,int win_y,int win_x,u16 * cap,const u16 * osd)52 static 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 
blend_line(struct vivid_dev * dev,unsigned y_offset,unsigned x_offset,u8 * vcapbuf,const u8 * vosdbuf,unsigned width,unsigned pixsize)80 static 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 
scale_line(const u8 * src,u8 * dst,unsigned srcw,unsigned dstw,unsigned twopixsize)92 static 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  */
vivid_precalc_copy_rects(struct vivid_dev * dev)145 static void vivid_precalc_copy_rects(struct vivid_dev *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 		dev->overlay_out_left, dev->overlay_out_top,
154 		dev->compose_out.width, dev->compose_out.height
155 	};
156 
157 	v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &dev->compose_out);
158 
159 	dev->loop_vid_out = dev->loop_vid_copy;
160 	v4l2_rect_scale(&dev->loop_vid_out, &dev->compose_out, &dev->crop_out);
161 	dev->loop_vid_out.left += dev->crop_out.left;
162 	dev->loop_vid_out.top += 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: %dx%d@%dx%d loop_vid_out: %dx%d@%dx%d loop_vid_cap: %dx%d@%dx%d\n",
169 		dev->loop_vid_copy.width, dev->loop_vid_copy.height,
170 		dev->loop_vid_copy.left, dev->loop_vid_copy.top,
171 		dev->loop_vid_out.width, dev->loop_vid_out.height,
172 		dev->loop_vid_out.left, dev->loop_vid_out.top,
173 		dev->loop_vid_cap.width, dev->loop_vid_cap.height,
174 		dev->loop_vid_cap.left, dev->loop_vid_cap.top);
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 += dev->compose_out.left - dev->overlay_out_left;
180 	r_overlay.top += dev->compose_out.top - 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 -= dev->compose_out.left - dev->overlay_out_left;
187 	dev->loop_fb_copy.top -= dev->compose_out.top - 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: %dx%d@%dx%d loop_vid_overlay: %dx%d@%dx%d loop_vid_overlay_cap: %dx%d@%dx%d\n",
194 		dev->loop_fb_copy.width, dev->loop_fb_copy.height,
195 		dev->loop_fb_copy.left, dev->loop_fb_copy.top,
196 		dev->loop_vid_overlay.width, dev->loop_vid_overlay.height,
197 		dev->loop_vid_overlay.left, dev->loop_vid_overlay.top,
198 		dev->loop_vid_overlay_cap.width, dev->loop_vid_overlay_cap.height,
199 		dev->loop_vid_overlay_cap.left, dev->loop_vid_overlay_cap.top);
200 }
201 
plane_vaddr(struct tpg_data * tpg,struct vivid_buffer * buf,unsigned p,unsigned bpl[TPG_MAX_PLANES],unsigned h)202 static 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 
vivid_copy_buffer(struct vivid_dev * dev,unsigned p,u8 * vcapbuf,struct vivid_buffer * vid_cap_buf)216 static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev, unsigned p,
217 		u8 *vcapbuf, struct vivid_buffer *vid_cap_buf)
218 {
219 	bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
220 	struct tpg_data *tpg = &dev->tpg;
221 	struct vivid_buffer *vid_out_buf = NULL;
222 	unsigned vdiv = dev->fmt_out->vdownsampling[p];
223 	unsigned twopixsize = tpg_g_twopixelsize(tpg, p);
224 	unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
225 	unsigned img_height = dev->compose_cap.height;
226 	unsigned stride_cap = tpg->bytesperline[p];
227 	unsigned stride_out = dev->bytesperline_out[p];
228 	unsigned stride_osd = dev->display_byte_stride;
229 	unsigned hmax = (img_height * tpg->perc_fill) / 100;
230 	u8 *voutbuf;
231 	u8 *vosdbuf = NULL;
232 	unsigned y;
233 	bool blend = dev->fbuf_out_flags;
234 	/* Coarse scaling with Bresenham */
235 	unsigned vid_out_int_part;
236 	unsigned vid_out_fract_part;
237 	unsigned vid_out_y = 0;
238 	unsigned vid_out_error = 0;
239 	unsigned vid_overlay_int_part = 0;
240 	unsigned vid_overlay_fract_part = 0;
241 	unsigned vid_overlay_y = 0;
242 	unsigned vid_overlay_error = 0;
243 	unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
244 	unsigned vid_cap_right;
245 	bool quick;
246 
247 	vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
248 	vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
249 
250 	if (!list_empty(&dev->vid_out_active))
251 		vid_out_buf = list_entry(dev->vid_out_active.next,
252 					 struct vivid_buffer, list);
253 	if (vid_out_buf == NULL)
254 		return -ENODATA;
255 
256 	vid_cap_buf->vb.field = vid_out_buf->vb.field;
257 
258 	voutbuf = plane_vaddr(tpg, vid_out_buf, p,
259 			      dev->bytesperline_out, dev->fmt_out_rect.height);
260 	if (p < dev->fmt_out->buffers)
261 		voutbuf += vid_out_buf->vb.vb2_buf.planes[p].data_offset;
262 	voutbuf += tpg_hdiv(tpg, p, dev->loop_vid_out.left) +
263 		(dev->loop_vid_out.top / vdiv) * stride_out;
264 	vcapbuf += tpg_hdiv(tpg, p, dev->compose_cap.left) +
265 		(dev->compose_cap.top / vdiv) * stride_cap;
266 
267 	if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
268 		/*
269 		 * If there is nothing to copy, then just fill the capture window
270 		 * with black.
271 		 */
272 		for (y = 0; y < hmax / vdiv; y++, vcapbuf += stride_cap)
273 			memcpy(vcapbuf, tpg->black_line[p], img_width);
274 		return 0;
275 	}
276 
277 	if (dev->overlay_out_enabled &&
278 	    dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
279 		vosdbuf = dev->video_vbase;
280 		vosdbuf += (dev->loop_fb_copy.left * twopixsize) / 2 +
281 			   dev->loop_fb_copy.top * stride_osd;
282 		vid_overlay_int_part = dev->loop_vid_overlay.height /
283 				       dev->loop_vid_overlay_cap.height;
284 		vid_overlay_fract_part = dev->loop_vid_overlay.height %
285 					 dev->loop_vid_overlay_cap.height;
286 	}
287 
288 	vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
289 	/* quick is true if no video scaling is needed */
290 	quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
291 
292 	dev->cur_scaled_line = dev->loop_vid_out.height;
293 	for (y = 0; y < hmax; y += vdiv, vcapbuf += stride_cap) {
294 		/* osdline is true if this line requires overlay blending */
295 		bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
296 			  y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
297 
298 		/*
299 		 * If this line of the capture buffer doesn't get any video, then
300 		 * just fill with black.
301 		 */
302 		if (y < dev->loop_vid_cap.top ||
303 		    y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
304 			memcpy(vcapbuf, tpg->black_line[p], img_width);
305 			continue;
306 		}
307 
308 		/* fill the left border with black */
309 		if (dev->loop_vid_cap.left)
310 			memcpy(vcapbuf, tpg->black_line[p], vid_cap_left);
311 
312 		/* fill the right border with black */
313 		if (vid_cap_right < img_width)
314 			memcpy(vcapbuf + vid_cap_right, tpg->black_line[p],
315 				img_width - vid_cap_right);
316 
317 		if (quick && !osdline) {
318 			memcpy(vcapbuf + vid_cap_left,
319 			       voutbuf + vid_out_y * stride_out,
320 			       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
321 			goto update_vid_out_y;
322 		}
323 		if (dev->cur_scaled_line == vid_out_y) {
324 			memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
325 			       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
326 			goto update_vid_out_y;
327 		}
328 		if (!osdline) {
329 			scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
330 				tpg_hdiv(tpg, p, dev->loop_vid_out.width),
331 				tpg_hdiv(tpg, p, dev->loop_vid_cap.width),
332 				tpg_g_twopixelsize(tpg, p));
333 		} else {
334 			/*
335 			 * Offset in bytes within loop_vid_copy to the start of the
336 			 * loop_vid_overlay rectangle.
337 			 */
338 			unsigned offset =
339 				((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
340 				 twopixsize) / 2;
341 			u8 *osd = vosdbuf + vid_overlay_y * stride_osd;
342 
343 			scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
344 				dev->loop_vid_out.width, dev->loop_vid_copy.width,
345 				tpg_g_twopixelsize(tpg, p));
346 			if (blend)
347 				blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
348 					   dev->loop_vid_overlay.left,
349 					   dev->blended_line + offset, osd,
350 					   dev->loop_vid_overlay.width, twopixsize / 2);
351 			else
352 				memcpy(dev->blended_line + offset,
353 				       osd, (dev->loop_vid_overlay.width * twopixsize) / 2);
354 			scale_line(dev->blended_line, dev->scaled_line,
355 					dev->loop_vid_copy.width, dev->loop_vid_cap.width,
356 					tpg_g_twopixelsize(tpg, p));
357 		}
358 		dev->cur_scaled_line = vid_out_y;
359 		memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
360 		       tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
361 
362 update_vid_out_y:
363 		if (osdline) {
364 			vid_overlay_y += vid_overlay_int_part;
365 			vid_overlay_error += vid_overlay_fract_part;
366 			if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
367 				vid_overlay_error -= dev->loop_vid_overlay_cap.height;
368 				vid_overlay_y++;
369 			}
370 		}
371 		vid_out_y += vid_out_int_part;
372 		vid_out_error += vid_out_fract_part;
373 		if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
374 			vid_out_error -= dev->loop_vid_cap.height / vdiv;
375 			vid_out_y++;
376 		}
377 	}
378 
379 	if (!blank)
380 		return 0;
381 	for (; y < img_height; y += vdiv, vcapbuf += stride_cap)
382 		memcpy(vcapbuf, tpg->contrast_line[p], img_width);
383 	return 0;
384 }
385 
vivid_fillbuff(struct vivid_dev * dev,struct vivid_buffer * buf)386 static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
387 {
388 	struct tpg_data *tpg = &dev->tpg;
389 	unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
390 	unsigned line_height = 16 / factor;
391 	bool is_tv = vivid_is_sdtv_cap(dev);
392 	bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
393 	unsigned p;
394 	int line = 1;
395 	u8 *basep[TPG_MAX_PLANES][2];
396 	unsigned ms;
397 	char str[100];
398 	s32 gain;
399 	bool is_loop = false;
400 
401 	if (dev->loop_video && dev->can_loop_video &&
402 		((vivid_is_svid_cap(dev) &&
403 		!VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) ||
404 		(vivid_is_hdmi_cap(dev) &&
405 		!VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input]))))
406 		is_loop = true;
407 
408 	buf->vb.sequence = dev->vid_cap_seq_count;
409 	v4l2_ctrl_s_ctrl(dev->ro_int32, buf->vb.sequence & 0xff);
410 	if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
411 		/*
412 		 * 60 Hz standards start with the bottom field, 50 Hz standards
413 		 * with the top field. So if the 0-based seq_count is even,
414 		 * then the field is TOP for 50 Hz and BOTTOM for 60 Hz
415 		 * standards.
416 		 */
417 		buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
418 			V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
419 		/*
420 		 * The sequence counter counts frames, not fields. So divide
421 		 * by two.
422 		 */
423 		buf->vb.sequence /= 2;
424 	} else {
425 		buf->vb.field = dev->field_cap;
426 	}
427 	tpg_s_field(tpg, buf->vb.field,
428 		    dev->field_cap == V4L2_FIELD_ALTERNATE);
429 	tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
430 
431 	vivid_precalc_copy_rects(dev);
432 
433 	for (p = 0; p < tpg_g_planes(tpg); p++) {
434 		void *vbuf = plane_vaddr(tpg, buf, p,
435 					 tpg->bytesperline, tpg->buf_height);
436 
437 		/*
438 		 * The first plane of a multiplanar format has a non-zero
439 		 * data_offset. This helps testing whether the application
440 		 * correctly supports non-zero data offsets.
441 		 */
442 		if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
443 			memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
444 			       dev->fmt_cap->data_offset[p]);
445 			vbuf += dev->fmt_cap->data_offset[p];
446 		}
447 		tpg_calc_text_basep(tpg, basep, p, vbuf);
448 		if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
449 			tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
450 					p, vbuf);
451 	}
452 	dev->must_blank[buf->vb.vb2_buf.index] = false;
453 
454 	/* Updates stream time, only update at the start of a new frame. */
455 	if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
456 			(dev->vid_cap_seq_count & 1) == 0)
457 		dev->ms_vid_cap =
458 			jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
459 
460 	ms = dev->ms_vid_cap;
461 	if (dev->osd_mode <= 1) {
462 		snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d %u%s",
463 				(ms / (60 * 60 * 1000)) % 24,
464 				(ms / (60 * 1000)) % 60,
465 				(ms / 1000) % 60,
466 				ms % 1000,
467 				buf->vb.sequence,
468 				(dev->field_cap == V4L2_FIELD_ALTERNATE) ?
469 					(buf->vb.field == V4L2_FIELD_TOP ?
470 					 " top" : " bottom") : "");
471 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
472 	}
473 	if (dev->osd_mode == 0) {
474 		snprintf(str, sizeof(str), " %dx%d, input %d ",
475 				dev->src_rect.width, dev->src_rect.height, dev->input);
476 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
477 
478 		gain = v4l2_ctrl_g_ctrl(dev->gain);
479 		mutex_lock(dev->ctrl_hdl_user_vid.lock);
480 		snprintf(str, sizeof(str),
481 			" brightness %3d, contrast %3d, saturation %3d, hue %d ",
482 			dev->brightness->cur.val,
483 			dev->contrast->cur.val,
484 			dev->saturation->cur.val,
485 			dev->hue->cur.val);
486 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
487 		snprintf(str, sizeof(str),
488 			" autogain %d, gain %3d, alpha 0x%02x ",
489 			dev->autogain->cur.val, gain, dev->alpha->cur.val);
490 		mutex_unlock(dev->ctrl_hdl_user_vid.lock);
491 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
492 		mutex_lock(dev->ctrl_hdl_user_aud.lock);
493 		snprintf(str, sizeof(str),
494 			" volume %3d, mute %d ",
495 			dev->volume->cur.val, dev->mute->cur.val);
496 		mutex_unlock(dev->ctrl_hdl_user_aud.lock);
497 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
498 		mutex_lock(dev->ctrl_hdl_user_gen.lock);
499 		snprintf(str, sizeof(str), " int32 %d, ro_int32 %d, int64 %lld, bitmask %08x ",
500 			 dev->int32->cur.val,
501 			 dev->ro_int32->cur.val,
502 			 *dev->int64->p_cur.p_s64,
503 			 dev->bitmask->cur.val);
504 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
505 		snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
506 			dev->boolean->cur.val,
507 			dev->menu->qmenu[dev->menu->cur.val],
508 			dev->string->p_cur.p_char);
509 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
510 		snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
511 			dev->int_menu->qmenu_int[dev->int_menu->cur.val],
512 			dev->int_menu->cur.val);
513 		mutex_unlock(dev->ctrl_hdl_user_gen.lock);
514 		tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
515 		if (dev->button_pressed) {
516 			dev->button_pressed--;
517 			snprintf(str, sizeof(str), " button pressed!");
518 			tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
519 		}
520 		if (dev->osd[0]) {
521 			if (vivid_is_hdmi_cap(dev)) {
522 				snprintf(str, sizeof(str),
523 					 " OSD \"%s\"", dev->osd);
524 				tpg_gen_text(tpg, basep, line++ * line_height,
525 					     16, str);
526 			}
527 			if (dev->osd_jiffies &&
528 			    time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
529 				dev->osd[0] = 0;
530 				dev->osd_jiffies = 0;
531 			}
532 		}
533 	}
534 }
535 
vivid_cap_update_frame_period(struct vivid_dev * dev)536 static void vivid_cap_update_frame_period(struct vivid_dev *dev)
537 {
538 	u64 f_period;
539 
540 	f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
541 	if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
542 		dev->timeperframe_vid_cap.denominator = 1;
543 	do_div(f_period, dev->timeperframe_vid_cap.denominator);
544 	if (dev->field_cap == V4L2_FIELD_ALTERNATE)
545 		f_period >>= 1;
546 	/*
547 	 * If "End of Frame", then offset the exposure time by 0.9
548 	 * of the frame period.
549 	 */
550 	dev->cap_frame_eof_offset = f_period * 9;
551 	do_div(dev->cap_frame_eof_offset, 10);
552 	dev->cap_frame_period = f_period;
553 }
554 
vivid_thread_vid_cap_tick(struct vivid_dev * dev,int dropped_bufs)555 static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
556 							 int dropped_bufs)
557 {
558 	struct vivid_buffer *vid_cap_buf = NULL;
559 	struct vivid_buffer *vbi_cap_buf = NULL;
560 	struct vivid_buffer *meta_cap_buf = NULL;
561 	u64 f_time = 0;
562 
563 	dprintk(dev, 1, "Video Capture Thread Tick\n");
564 
565 	while (dropped_bufs-- > 1)
566 		tpg_update_mv_count(&dev->tpg,
567 				dev->field_cap == V4L2_FIELD_NONE ||
568 				dev->field_cap == V4L2_FIELD_ALTERNATE);
569 
570 	/* Drop a certain percentage of buffers. */
571 	if (dev->perc_dropped_buffers &&
572 	    get_random_u32_below(100) < dev->perc_dropped_buffers)
573 		goto update_mv;
574 
575 	spin_lock(&dev->slock);
576 	if (!list_empty(&dev->vid_cap_active)) {
577 		vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
578 		list_del(&vid_cap_buf->list);
579 	}
580 	if (!list_empty(&dev->vbi_cap_active)) {
581 		if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
582 		    (dev->vbi_cap_seq_count & 1)) {
583 			vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
584 						 struct vivid_buffer, list);
585 			list_del(&vbi_cap_buf->list);
586 		}
587 	}
588 	if (!list_empty(&dev->meta_cap_active)) {
589 		meta_cap_buf = list_entry(dev->meta_cap_active.next,
590 					  struct vivid_buffer, list);
591 		list_del(&meta_cap_buf->list);
592 	}
593 
594 	spin_unlock(&dev->slock);
595 
596 	if (!vid_cap_buf && !vbi_cap_buf && !meta_cap_buf)
597 		goto update_mv;
598 
599 	f_time = ktime_get_ns() + dev->time_wrap_offset;
600 
601 	if (vid_cap_buf) {
602 		v4l2_ctrl_request_setup(vid_cap_buf->vb.vb2_buf.req_obj.req,
603 					&dev->ctrl_hdl_vid_cap);
604 		/* Fill buffer */
605 		vivid_fillbuff(dev, vid_cap_buf);
606 		dprintk(dev, 1, "filled buffer %d\n",
607 			vid_cap_buf->vb.vb2_buf.index);
608 
609 		v4l2_ctrl_request_complete(vid_cap_buf->vb.vb2_buf.req_obj.req,
610 					   &dev->ctrl_hdl_vid_cap);
611 		vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
612 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
613 		dprintk(dev, 2, "vid_cap buffer %d done\n",
614 				vid_cap_buf->vb.vb2_buf.index);
615 
616 		vid_cap_buf->vb.vb2_buf.timestamp = f_time;
617 		if (!dev->tstamp_src_is_soe)
618 			vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
619 	}
620 
621 	if (vbi_cap_buf) {
622 		u64 vbi_period;
623 
624 		v4l2_ctrl_request_setup(vbi_cap_buf->vb.vb2_buf.req_obj.req,
625 					&dev->ctrl_hdl_vbi_cap);
626 		if (vbi_cap_buf->vb.vb2_buf.type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
627 			vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
628 		else
629 			vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
630 		v4l2_ctrl_request_complete(vbi_cap_buf->vb.vb2_buf.req_obj.req,
631 					   &dev->ctrl_hdl_vbi_cap);
632 		vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
633 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
634 		dprintk(dev, 2, "vbi_cap %d done\n",
635 				vbi_cap_buf->vb.vb2_buf.index);
636 
637 		/* If capturing a VBI, offset by 0.05 */
638 		vbi_period = dev->cap_frame_period * 5;
639 		do_div(vbi_period, 100);
640 		vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
641 	}
642 
643 	if (meta_cap_buf) {
644 		v4l2_ctrl_request_setup(meta_cap_buf->vb.vb2_buf.req_obj.req,
645 					&dev->ctrl_hdl_meta_cap);
646 		vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
647 		v4l2_ctrl_request_complete(meta_cap_buf->vb.vb2_buf.req_obj.req,
648 					   &dev->ctrl_hdl_meta_cap);
649 		vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
650 				VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
651 		dprintk(dev, 2, "meta_cap %d done\n",
652 			meta_cap_buf->vb.vb2_buf.index);
653 		meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
654 	}
655 
656 	dev->dqbuf_error = false;
657 
658 update_mv:
659 	/* Update the test pattern movement counters */
660 	tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
661 				       dev->field_cap == V4L2_FIELD_ALTERNATE);
662 }
663 
vivid_thread_vid_cap(void * data)664 static int vivid_thread_vid_cap(void *data)
665 {
666 	struct vivid_dev *dev = data;
667 	u64 numerators_since_start;
668 	u64 buffers_since_start;
669 	u64 next_jiffies_since_start;
670 	unsigned long jiffies_since_start;
671 	unsigned long cur_jiffies;
672 	unsigned wait_jiffies;
673 	unsigned numerator;
674 	unsigned denominator;
675 	int dropped_bufs;
676 
677 	dprintk(dev, 1, "Video Capture Thread Start\n");
678 
679 	set_freezable();
680 
681 	/* Resets frame counters */
682 	dev->cap_seq_offset = 0;
683 	dev->cap_seq_count = 0;
684 	dev->cap_seq_resync = false;
685 	dev->jiffies_vid_cap = jiffies;
686 	dev->cap_stream_start = ktime_get_ns();
687 	if (dev->time_wrap)
688 		dev->time_wrap_offset = dev->time_wrap - dev->cap_stream_start;
689 	else
690 		dev->time_wrap_offset = 0;
691 	vivid_cap_update_frame_period(dev);
692 
693 	for (;;) {
694 		try_to_freeze();
695 		if (kthread_should_stop())
696 			break;
697 
698 		if (!mutex_trylock(&dev->mutex)) {
699 			schedule();
700 			continue;
701 		}
702 
703 		cur_jiffies = jiffies;
704 		if (dev->cap_seq_resync) {
705 			dev->jiffies_vid_cap = cur_jiffies;
706 			dev->cap_seq_offset = dev->cap_seq_count + 1;
707 			dev->cap_seq_count = 0;
708 			dev->cap_stream_start += dev->cap_frame_period *
709 						 dev->cap_seq_offset;
710 			vivid_cap_update_frame_period(dev);
711 			dev->cap_seq_resync = false;
712 		}
713 		numerator = dev->timeperframe_vid_cap.numerator;
714 		denominator = dev->timeperframe_vid_cap.denominator;
715 
716 		if (dev->field_cap == V4L2_FIELD_ALTERNATE)
717 			denominator *= 2;
718 
719 		/* Calculate the number of jiffies since we started streaming */
720 		jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
721 		/* Get the number of buffers streamed since the start */
722 		buffers_since_start = (u64)jiffies_since_start * denominator +
723 				      (HZ * numerator) / 2;
724 		do_div(buffers_since_start, HZ * numerator);
725 
726 		/*
727 		 * After more than 0xf0000000 (rounded down to a multiple of
728 		 * 'jiffies-per-day' to ease jiffies_to_msecs calculation)
729 		 * jiffies have passed since we started streaming reset the
730 		 * counters and keep track of the sequence offset.
731 		 */
732 		if (jiffies_since_start > JIFFIES_RESYNC) {
733 			dev->jiffies_vid_cap = cur_jiffies;
734 			dev->cap_seq_offset = buffers_since_start;
735 			buffers_since_start = 0;
736 		}
737 		dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
738 		dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
739 		dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
740 		dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
741 		dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
742 
743 		vivid_thread_vid_cap_tick(dev, dropped_bufs);
744 
745 		/*
746 		 * Calculate the number of 'numerators' streamed since we started,
747 		 * including the current buffer.
748 		 */
749 		numerators_since_start = ++buffers_since_start * numerator;
750 
751 		/* And the number of jiffies since we started */
752 		jiffies_since_start = jiffies - dev->jiffies_vid_cap;
753 
754 		mutex_unlock(&dev->mutex);
755 
756 		/*
757 		 * Calculate when that next buffer is supposed to start
758 		 * in jiffies since we started streaming.
759 		 */
760 		next_jiffies_since_start = numerators_since_start * HZ +
761 					   denominator / 2;
762 		do_div(next_jiffies_since_start, denominator);
763 		/* If it is in the past, then just schedule asap */
764 		if (next_jiffies_since_start < jiffies_since_start)
765 			next_jiffies_since_start = jiffies_since_start;
766 
767 		wait_jiffies = next_jiffies_since_start - jiffies_since_start;
768 		while (time_is_after_jiffies(cur_jiffies + wait_jiffies) &&
769 		       !kthread_should_stop())
770 			schedule();
771 	}
772 	dprintk(dev, 1, "Video Capture Thread End\n");
773 	return 0;
774 }
775 
vivid_grab_controls(struct vivid_dev * dev,bool grab)776 static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
777 {
778 	v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
779 	v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
780 	v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
781 }
782 
vivid_start_generating_vid_cap(struct vivid_dev * dev,bool * pstreaming)783 int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
784 {
785 	dprintk(dev, 1, "%s\n", __func__);
786 
787 	if (dev->kthread_vid_cap) {
788 		u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
789 
790 		if (pstreaming == &dev->vid_cap_streaming)
791 			dev->vid_cap_seq_start = seq_count;
792 		else if (pstreaming == &dev->vbi_cap_streaming)
793 			dev->vbi_cap_seq_start = seq_count;
794 		else
795 			dev->meta_cap_seq_start = seq_count;
796 		*pstreaming = true;
797 		return 0;
798 	}
799 
800 	/* Resets frame counters */
801 	tpg_init_mv_count(&dev->tpg);
802 
803 	dev->vid_cap_seq_start = dev->seq_wrap * 128;
804 	dev->vbi_cap_seq_start = dev->seq_wrap * 128;
805 	dev->meta_cap_seq_start = dev->seq_wrap * 128;
806 
807 	dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
808 			"%s-vid-cap", dev->v4l2_dev.name);
809 
810 	if (IS_ERR(dev->kthread_vid_cap)) {
811 		int err = PTR_ERR(dev->kthread_vid_cap);
812 
813 		dev->kthread_vid_cap = NULL;
814 		v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
815 		return err;
816 	}
817 	*pstreaming = true;
818 	vivid_grab_controls(dev, true);
819 
820 	dprintk(dev, 1, "returning from %s\n", __func__);
821 	return 0;
822 }
823 
vivid_stop_generating_vid_cap(struct vivid_dev * dev,bool * pstreaming)824 void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
825 {
826 	dprintk(dev, 1, "%s\n", __func__);
827 
828 	if (dev->kthread_vid_cap == NULL)
829 		return;
830 
831 	*pstreaming = false;
832 	if (pstreaming == &dev->vid_cap_streaming) {
833 		/* Release all active buffers */
834 		while (!list_empty(&dev->vid_cap_active)) {
835 			struct vivid_buffer *buf;
836 
837 			buf = list_entry(dev->vid_cap_active.next,
838 					 struct vivid_buffer, list);
839 			list_del(&buf->list);
840 			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
841 						   &dev->ctrl_hdl_vid_cap);
842 			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
843 			dprintk(dev, 2, "vid_cap buffer %d done\n",
844 				buf->vb.vb2_buf.index);
845 		}
846 	}
847 
848 	if (pstreaming == &dev->vbi_cap_streaming) {
849 		while (!list_empty(&dev->vbi_cap_active)) {
850 			struct vivid_buffer *buf;
851 
852 			buf = list_entry(dev->vbi_cap_active.next,
853 					 struct vivid_buffer, list);
854 			list_del(&buf->list);
855 			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
856 						   &dev->ctrl_hdl_vbi_cap);
857 			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
858 			dprintk(dev, 2, "vbi_cap buffer %d done\n",
859 				buf->vb.vb2_buf.index);
860 		}
861 	}
862 
863 	if (pstreaming == &dev->meta_cap_streaming) {
864 		while (!list_empty(&dev->meta_cap_active)) {
865 			struct vivid_buffer *buf;
866 
867 			buf = list_entry(dev->meta_cap_active.next,
868 					 struct vivid_buffer, list);
869 			list_del(&buf->list);
870 			v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
871 						   &dev->ctrl_hdl_meta_cap);
872 			vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
873 			dprintk(dev, 2, "meta_cap buffer %d done\n",
874 				buf->vb.vb2_buf.index);
875 		}
876 	}
877 
878 	if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
879 	    dev->meta_cap_streaming)
880 		return;
881 
882 	/* shutdown control thread */
883 	vivid_grab_controls(dev, false);
884 	kthread_stop(dev->kthread_vid_cap);
885 	dev->kthread_vid_cap = NULL;
886 }
887