1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * v4l2-tpg-core.c - Test Pattern Generator
4  *
5  * Note: gen_twopix and tpg_gen_text are based on code from vivi.c. See the
6  * vivi.c source for the copyright information of those functions.
7  *
8  * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
9  */
10 
11 #include <linux/module.h>
12 #include <media/tpg/v4l2-tpg.h>
13 
14 /* Must remain in sync with enum tpg_pattern */
15 const char * const tpg_pattern_strings[] = {
16 	"75% Colorbar",
17 	"100% Colorbar",
18 	"CSC Colorbar",
19 	"Horizontal 100% Colorbar",
20 	"100% Color Squares",
21 	"100% Black",
22 	"100% White",
23 	"100% Red",
24 	"100% Green",
25 	"100% Blue",
26 	"16x16 Checkers",
27 	"2x2 Checkers",
28 	"1x1 Checkers",
29 	"2x2 Red/Green Checkers",
30 	"1x1 Red/Green Checkers",
31 	"Alternating Hor Lines",
32 	"Alternating Vert Lines",
33 	"One Pixel Wide Cross",
34 	"Two Pixels Wide Cross",
35 	"Ten Pixels Wide Cross",
36 	"Gray Ramp",
37 	"Noise",
38 	NULL
39 };
40 EXPORT_SYMBOL_GPL(tpg_pattern_strings);
41 
42 /* Must remain in sync with enum tpg_aspect */
43 const char * const tpg_aspect_strings[] = {
44 	"Source Width x Height",
45 	"4x3",
46 	"14x9",
47 	"16x9",
48 	"16x9 Anamorphic",
49 	NULL
50 };
51 EXPORT_SYMBOL_GPL(tpg_aspect_strings);
52 
53 /*
54  * Sine table: sin[0] = 127 * sin(-180 degrees)
55  *             sin[128] = 127 * sin(0 degrees)
56  *             sin[256] = 127 * sin(180 degrees)
57  */
58 static const s8 sin[257] = {
59 	   0,   -4,   -7,  -11,  -13,  -18,  -20,  -22,  -26,  -29,  -33,  -35,  -37,  -41,  -43,  -48,
60 	 -50,  -52,  -56,  -58,  -62,  -63,  -65,  -69,  -71,  -75,  -76,  -78,  -82,  -83,  -87,  -88,
61 	 -90,  -93,  -94,  -97,  -99, -101, -103, -104, -107, -108, -110, -111, -112, -114, -115, -117,
62 	-118, -119, -120, -121, -122, -123, -123, -124, -125, -125, -126, -126, -127, -127, -127, -127,
63 	-127, -127, -127, -127, -126, -126, -125, -125, -124, -124, -123, -122, -121, -120, -119, -118,
64 	-117, -116, -114, -113, -111, -110, -109, -107, -105, -103, -101, -100,  -97,  -96,  -93,  -91,
65 	 -90,  -87,  -85,  -82,  -80,  -76,  -75,  -73,  -69,  -67,  -63,  -62,  -60,  -56,  -54,  -50,
66 	 -48,  -46,  -41,  -39,  -35,  -33,  -31,  -26,  -24,  -20,  -18,  -15,  -11,   -9,   -4,   -2,
67 	   0,    2,    4,    9,   11,   15,   18,   20,   24,   26,   31,   33,   35,   39,   41,   46,
68 	  48,   50,   54,   56,   60,   62,   64,   67,   69,   73,   75,   76,   80,   82,   85,   87,
69 	  90,   91,   93,   96,   97,  100,  101,  103,  105,  107,  109,  110,  111,  113,  114,  116,
70 	 117,  118,  119,  120,  121,  122,  123,  124,  124,  125,  125,  126,  126,  127,  127,  127,
71 	 127,  127,  127,  127,  127,  126,  126,  125,  125,  124,  123,  123,  122,  121,  120,  119,
72 	 118,  117,  115,  114,  112,  111,  110,  108,  107,  104,  103,  101,   99,   97,   94,   93,
73 	  90,   88,   87,   83,   82,   78,   76,   75,   71,   69,   65,   64,   62,   58,   56,   52,
74 	  50,   48,   43,   41,   37,   35,   33,   29,   26,   22,   20,   18,   13,   11,    7,    4,
75 	   0,
76 };
77 
78 #define cos(idx) sin[((idx) + 64) % sizeof(sin)]
79 
80 /* Global font descriptor */
81 static const u8 *font8x16;
82 
83 void tpg_set_font(const u8 *f)
84 {
85 	font8x16 = f;
86 }
87 EXPORT_SYMBOL_GPL(tpg_set_font);
88 
89 void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h)
90 {
91 	memset(tpg, 0, sizeof(*tpg));
92 	tpg->scaled_width = tpg->src_width = w;
93 	tpg->src_height = tpg->buf_height = h;
94 	tpg->crop.width = tpg->compose.width = w;
95 	tpg->crop.height = tpg->compose.height = h;
96 	tpg->recalc_colors = true;
97 	tpg->recalc_square_border = true;
98 	tpg->brightness = 128;
99 	tpg->contrast = 128;
100 	tpg->saturation = 128;
101 	tpg->hue = 0;
102 	tpg->mv_hor_mode = TPG_MOVE_NONE;
103 	tpg->mv_vert_mode = TPG_MOVE_NONE;
104 	tpg->field = V4L2_FIELD_NONE;
105 	tpg_s_fourcc(tpg, V4L2_PIX_FMT_RGB24);
106 	tpg->colorspace = V4L2_COLORSPACE_SRGB;
107 	tpg->perc_fill = 100;
108 	tpg->hsv_enc = V4L2_HSV_ENC_180;
109 }
110 EXPORT_SYMBOL_GPL(tpg_init);
111 
112 int tpg_alloc(struct tpg_data *tpg, unsigned max_w)
113 {
114 	unsigned pat;
115 	unsigned plane;
116 
117 	tpg->max_line_width = max_w;
118 	for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++) {
119 		for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
120 			unsigned pixelsz = plane ? 2 : 4;
121 
122 			tpg->lines[pat][plane] =
123 				vzalloc(array3_size(max_w, 2, pixelsz));
124 			if (!tpg->lines[pat][plane])
125 				return -ENOMEM;
126 			if (plane == 0)
127 				continue;
128 			tpg->downsampled_lines[pat][plane] =
129 				vzalloc(array3_size(max_w, 2, pixelsz));
130 			if (!tpg->downsampled_lines[pat][plane])
131 				return -ENOMEM;
132 		}
133 	}
134 	for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
135 		unsigned pixelsz = plane ? 2 : 4;
136 
137 		tpg->contrast_line[plane] =
138 			vzalloc(array_size(pixelsz, max_w));
139 		if (!tpg->contrast_line[plane])
140 			return -ENOMEM;
141 		tpg->black_line[plane] =
142 			vzalloc(array_size(pixelsz, max_w));
143 		if (!tpg->black_line[plane])
144 			return -ENOMEM;
145 		tpg->random_line[plane] =
146 			vzalloc(array3_size(max_w, 2, pixelsz));
147 		if (!tpg->random_line[plane])
148 			return -ENOMEM;
149 	}
150 	return 0;
151 }
152 EXPORT_SYMBOL_GPL(tpg_alloc);
153 
154 void tpg_free(struct tpg_data *tpg)
155 {
156 	unsigned pat;
157 	unsigned plane;
158 
159 	for (pat = 0; pat < TPG_MAX_PAT_LINES; pat++)
160 		for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
161 			vfree(tpg->lines[pat][plane]);
162 			tpg->lines[pat][plane] = NULL;
163 			if (plane == 0)
164 				continue;
165 			vfree(tpg->downsampled_lines[pat][plane]);
166 			tpg->downsampled_lines[pat][plane] = NULL;
167 		}
168 	for (plane = 0; plane < TPG_MAX_PLANES; plane++) {
169 		vfree(tpg->contrast_line[plane]);
170 		vfree(tpg->black_line[plane]);
171 		vfree(tpg->random_line[plane]);
172 		tpg->contrast_line[plane] = NULL;
173 		tpg->black_line[plane] = NULL;
174 		tpg->random_line[plane] = NULL;
175 	}
176 }
177 EXPORT_SYMBOL_GPL(tpg_free);
178 
179 bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc)
180 {
181 	tpg->fourcc = fourcc;
182 	tpg->planes = 1;
183 	tpg->buffers = 1;
184 	tpg->recalc_colors = true;
185 	tpg->interleaved = false;
186 	tpg->vdownsampling[0] = 1;
187 	tpg->hdownsampling[0] = 1;
188 	tpg->hmask[0] = ~0;
189 	tpg->hmask[1] = ~0;
190 	tpg->hmask[2] = ~0;
191 
192 	switch (fourcc) {
193 	case V4L2_PIX_FMT_SBGGR8:
194 	case V4L2_PIX_FMT_SGBRG8:
195 	case V4L2_PIX_FMT_SGRBG8:
196 	case V4L2_PIX_FMT_SRGGB8:
197 	case V4L2_PIX_FMT_SBGGR10:
198 	case V4L2_PIX_FMT_SGBRG10:
199 	case V4L2_PIX_FMT_SGRBG10:
200 	case V4L2_PIX_FMT_SRGGB10:
201 	case V4L2_PIX_FMT_SBGGR12:
202 	case V4L2_PIX_FMT_SGBRG12:
203 	case V4L2_PIX_FMT_SGRBG12:
204 	case V4L2_PIX_FMT_SRGGB12:
205 	case V4L2_PIX_FMT_SBGGR16:
206 	case V4L2_PIX_FMT_SGBRG16:
207 	case V4L2_PIX_FMT_SGRBG16:
208 	case V4L2_PIX_FMT_SRGGB16:
209 		tpg->interleaved = true;
210 		tpg->vdownsampling[1] = 1;
211 		tpg->hdownsampling[1] = 1;
212 		tpg->planes = 2;
213 		fallthrough;
214 	case V4L2_PIX_FMT_RGB332:
215 	case V4L2_PIX_FMT_RGB565:
216 	case V4L2_PIX_FMT_RGB565X:
217 	case V4L2_PIX_FMT_RGB444:
218 	case V4L2_PIX_FMT_XRGB444:
219 	case V4L2_PIX_FMT_ARGB444:
220 	case V4L2_PIX_FMT_RGBX444:
221 	case V4L2_PIX_FMT_RGBA444:
222 	case V4L2_PIX_FMT_XBGR444:
223 	case V4L2_PIX_FMT_ABGR444:
224 	case V4L2_PIX_FMT_BGRX444:
225 	case V4L2_PIX_FMT_BGRA444:
226 	case V4L2_PIX_FMT_RGB555:
227 	case V4L2_PIX_FMT_XRGB555:
228 	case V4L2_PIX_FMT_ARGB555:
229 	case V4L2_PIX_FMT_RGBX555:
230 	case V4L2_PIX_FMT_RGBA555:
231 	case V4L2_PIX_FMT_XBGR555:
232 	case V4L2_PIX_FMT_ABGR555:
233 	case V4L2_PIX_FMT_BGRX555:
234 	case V4L2_PIX_FMT_BGRA555:
235 	case V4L2_PIX_FMT_RGB555X:
236 	case V4L2_PIX_FMT_XRGB555X:
237 	case V4L2_PIX_FMT_ARGB555X:
238 	case V4L2_PIX_FMT_BGR666:
239 	case V4L2_PIX_FMT_RGB24:
240 	case V4L2_PIX_FMT_BGR24:
241 	case V4L2_PIX_FMT_RGB32:
242 	case V4L2_PIX_FMT_BGR32:
243 	case V4L2_PIX_FMT_XRGB32:
244 	case V4L2_PIX_FMT_XBGR32:
245 	case V4L2_PIX_FMT_ARGB32:
246 	case V4L2_PIX_FMT_ABGR32:
247 	case V4L2_PIX_FMT_RGBX32:
248 	case V4L2_PIX_FMT_BGRX32:
249 	case V4L2_PIX_FMT_RGBA32:
250 	case V4L2_PIX_FMT_BGRA32:
251 		tpg->color_enc = TGP_COLOR_ENC_RGB;
252 		break;
253 	case V4L2_PIX_FMT_GREY:
254 	case V4L2_PIX_FMT_Y10:
255 	case V4L2_PIX_FMT_Y12:
256 	case V4L2_PIX_FMT_Y16:
257 	case V4L2_PIX_FMT_Y16_BE:
258 	case V4L2_PIX_FMT_Z16:
259 		tpg->color_enc = TGP_COLOR_ENC_LUMA;
260 		break;
261 	case V4L2_PIX_FMT_YUV444:
262 	case V4L2_PIX_FMT_YUV555:
263 	case V4L2_PIX_FMT_YUV565:
264 	case V4L2_PIX_FMT_YUV32:
265 	case V4L2_PIX_FMT_AYUV32:
266 	case V4L2_PIX_FMT_XYUV32:
267 	case V4L2_PIX_FMT_VUYA32:
268 	case V4L2_PIX_FMT_VUYX32:
269 	case V4L2_PIX_FMT_YUVA32:
270 	case V4L2_PIX_FMT_YUVX32:
271 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
272 		break;
273 	case V4L2_PIX_FMT_YUV420M:
274 	case V4L2_PIX_FMT_YVU420M:
275 		tpg->buffers = 3;
276 		fallthrough;
277 	case V4L2_PIX_FMT_YUV420:
278 	case V4L2_PIX_FMT_YVU420:
279 		tpg->vdownsampling[1] = 2;
280 		tpg->vdownsampling[2] = 2;
281 		tpg->hdownsampling[1] = 2;
282 		tpg->hdownsampling[2] = 2;
283 		tpg->planes = 3;
284 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
285 		break;
286 	case V4L2_PIX_FMT_YUV422M:
287 	case V4L2_PIX_FMT_YVU422M:
288 		tpg->buffers = 3;
289 		fallthrough;
290 	case V4L2_PIX_FMT_YUV422P:
291 		tpg->vdownsampling[1] = 1;
292 		tpg->vdownsampling[2] = 1;
293 		tpg->hdownsampling[1] = 2;
294 		tpg->hdownsampling[2] = 2;
295 		tpg->planes = 3;
296 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
297 		break;
298 	case V4L2_PIX_FMT_NV16M:
299 	case V4L2_PIX_FMT_NV61M:
300 		tpg->buffers = 2;
301 		fallthrough;
302 	case V4L2_PIX_FMT_NV16:
303 	case V4L2_PIX_FMT_NV61:
304 		tpg->vdownsampling[1] = 1;
305 		tpg->hdownsampling[1] = 1;
306 		tpg->hmask[1] = ~1;
307 		tpg->planes = 2;
308 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
309 		break;
310 	case V4L2_PIX_FMT_NV12M:
311 	case V4L2_PIX_FMT_NV21M:
312 		tpg->buffers = 2;
313 		fallthrough;
314 	case V4L2_PIX_FMT_NV12:
315 	case V4L2_PIX_FMT_NV21:
316 		tpg->vdownsampling[1] = 2;
317 		tpg->hdownsampling[1] = 1;
318 		tpg->hmask[1] = ~1;
319 		tpg->planes = 2;
320 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
321 		break;
322 	case V4L2_PIX_FMT_YUV444M:
323 	case V4L2_PIX_FMT_YVU444M:
324 		tpg->buffers = 3;
325 		tpg->planes = 3;
326 		tpg->vdownsampling[1] = 1;
327 		tpg->vdownsampling[2] = 1;
328 		tpg->hdownsampling[1] = 1;
329 		tpg->hdownsampling[2] = 1;
330 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
331 		break;
332 	case V4L2_PIX_FMT_NV24:
333 	case V4L2_PIX_FMT_NV42:
334 		tpg->vdownsampling[1] = 1;
335 		tpg->hdownsampling[1] = 1;
336 		tpg->planes = 2;
337 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
338 		break;
339 	case V4L2_PIX_FMT_YUYV:
340 	case V4L2_PIX_FMT_UYVY:
341 	case V4L2_PIX_FMT_YVYU:
342 	case V4L2_PIX_FMT_VYUY:
343 		tpg->hmask[0] = ~1;
344 		tpg->color_enc = TGP_COLOR_ENC_YCBCR;
345 		break;
346 	case V4L2_PIX_FMT_HSV24:
347 	case V4L2_PIX_FMT_HSV32:
348 		tpg->color_enc = TGP_COLOR_ENC_HSV;
349 		break;
350 	default:
351 		return false;
352 	}
353 
354 	switch (fourcc) {
355 	case V4L2_PIX_FMT_GREY:
356 	case V4L2_PIX_FMT_RGB332:
357 		tpg->twopixelsize[0] = 2;
358 		break;
359 	case V4L2_PIX_FMT_RGB565:
360 	case V4L2_PIX_FMT_RGB565X:
361 	case V4L2_PIX_FMT_RGB444:
362 	case V4L2_PIX_FMT_XRGB444:
363 	case V4L2_PIX_FMT_ARGB444:
364 	case V4L2_PIX_FMT_RGBX444:
365 	case V4L2_PIX_FMT_RGBA444:
366 	case V4L2_PIX_FMT_XBGR444:
367 	case V4L2_PIX_FMT_ABGR444:
368 	case V4L2_PIX_FMT_BGRX444:
369 	case V4L2_PIX_FMT_BGRA444:
370 	case V4L2_PIX_FMT_RGB555:
371 	case V4L2_PIX_FMT_XRGB555:
372 	case V4L2_PIX_FMT_ARGB555:
373 	case V4L2_PIX_FMT_RGBX555:
374 	case V4L2_PIX_FMT_RGBA555:
375 	case V4L2_PIX_FMT_XBGR555:
376 	case V4L2_PIX_FMT_ABGR555:
377 	case V4L2_PIX_FMT_BGRX555:
378 	case V4L2_PIX_FMT_BGRA555:
379 	case V4L2_PIX_FMT_RGB555X:
380 	case V4L2_PIX_FMT_XRGB555X:
381 	case V4L2_PIX_FMT_ARGB555X:
382 	case V4L2_PIX_FMT_YUYV:
383 	case V4L2_PIX_FMT_UYVY:
384 	case V4L2_PIX_FMT_YVYU:
385 	case V4L2_PIX_FMT_VYUY:
386 	case V4L2_PIX_FMT_YUV444:
387 	case V4L2_PIX_FMT_YUV555:
388 	case V4L2_PIX_FMT_YUV565:
389 	case V4L2_PIX_FMT_Y10:
390 	case V4L2_PIX_FMT_Y12:
391 	case V4L2_PIX_FMT_Y16:
392 	case V4L2_PIX_FMT_Y16_BE:
393 	case V4L2_PIX_FMT_Z16:
394 		tpg->twopixelsize[0] = 2 * 2;
395 		break;
396 	case V4L2_PIX_FMT_RGB24:
397 	case V4L2_PIX_FMT_BGR24:
398 	case V4L2_PIX_FMT_HSV24:
399 		tpg->twopixelsize[0] = 2 * 3;
400 		break;
401 	case V4L2_PIX_FMT_BGR666:
402 	case V4L2_PIX_FMT_RGB32:
403 	case V4L2_PIX_FMT_BGR32:
404 	case V4L2_PIX_FMT_XRGB32:
405 	case V4L2_PIX_FMT_XBGR32:
406 	case V4L2_PIX_FMT_ARGB32:
407 	case V4L2_PIX_FMT_ABGR32:
408 	case V4L2_PIX_FMT_RGBX32:
409 	case V4L2_PIX_FMT_BGRX32:
410 	case V4L2_PIX_FMT_RGBA32:
411 	case V4L2_PIX_FMT_BGRA32:
412 	case V4L2_PIX_FMT_YUV32:
413 	case V4L2_PIX_FMT_AYUV32:
414 	case V4L2_PIX_FMT_XYUV32:
415 	case V4L2_PIX_FMT_VUYA32:
416 	case V4L2_PIX_FMT_VUYX32:
417 	case V4L2_PIX_FMT_YUVA32:
418 	case V4L2_PIX_FMT_YUVX32:
419 	case V4L2_PIX_FMT_HSV32:
420 		tpg->twopixelsize[0] = 2 * 4;
421 		break;
422 	case V4L2_PIX_FMT_NV12:
423 	case V4L2_PIX_FMT_NV21:
424 	case V4L2_PIX_FMT_NV12M:
425 	case V4L2_PIX_FMT_NV21M:
426 	case V4L2_PIX_FMT_NV16:
427 	case V4L2_PIX_FMT_NV61:
428 	case V4L2_PIX_FMT_NV16M:
429 	case V4L2_PIX_FMT_NV61M:
430 	case V4L2_PIX_FMT_SBGGR8:
431 	case V4L2_PIX_FMT_SGBRG8:
432 	case V4L2_PIX_FMT_SGRBG8:
433 	case V4L2_PIX_FMT_SRGGB8:
434 		tpg->twopixelsize[0] = 2;
435 		tpg->twopixelsize[1] = 2;
436 		break;
437 	case V4L2_PIX_FMT_SRGGB10:
438 	case V4L2_PIX_FMT_SGRBG10:
439 	case V4L2_PIX_FMT_SGBRG10:
440 	case V4L2_PIX_FMT_SBGGR10:
441 	case V4L2_PIX_FMT_SRGGB12:
442 	case V4L2_PIX_FMT_SGRBG12:
443 	case V4L2_PIX_FMT_SGBRG12:
444 	case V4L2_PIX_FMT_SBGGR12:
445 	case V4L2_PIX_FMT_SRGGB16:
446 	case V4L2_PIX_FMT_SGRBG16:
447 	case V4L2_PIX_FMT_SGBRG16:
448 	case V4L2_PIX_FMT_SBGGR16:
449 		tpg->twopixelsize[0] = 4;
450 		tpg->twopixelsize[1] = 4;
451 		break;
452 	case V4L2_PIX_FMT_YUV444M:
453 	case V4L2_PIX_FMT_YVU444M:
454 	case V4L2_PIX_FMT_YUV422M:
455 	case V4L2_PIX_FMT_YVU422M:
456 	case V4L2_PIX_FMT_YUV422P:
457 	case V4L2_PIX_FMT_YUV420:
458 	case V4L2_PIX_FMT_YVU420:
459 	case V4L2_PIX_FMT_YUV420M:
460 	case V4L2_PIX_FMT_YVU420M:
461 		tpg->twopixelsize[0] = 2;
462 		tpg->twopixelsize[1] = 2;
463 		tpg->twopixelsize[2] = 2;
464 		break;
465 	case V4L2_PIX_FMT_NV24:
466 	case V4L2_PIX_FMT_NV42:
467 		tpg->twopixelsize[0] = 2;
468 		tpg->twopixelsize[1] = 4;
469 		break;
470 	}
471 	return true;
472 }
473 EXPORT_SYMBOL_GPL(tpg_s_fourcc);
474 
475 void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
476 		const struct v4l2_rect *compose)
477 {
478 	tpg->crop = *crop;
479 	tpg->compose = *compose;
480 	tpg->scaled_width = (tpg->src_width * tpg->compose.width +
481 				 tpg->crop.width - 1) / tpg->crop.width;
482 	tpg->scaled_width &= ~1;
483 	if (tpg->scaled_width > tpg->max_line_width)
484 		tpg->scaled_width = tpg->max_line_width;
485 	if (tpg->scaled_width < 2)
486 		tpg->scaled_width = 2;
487 	tpg->recalc_lines = true;
488 }
489 EXPORT_SYMBOL_GPL(tpg_s_crop_compose);
490 
491 void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
492 		       u32 field)
493 {
494 	unsigned p;
495 
496 	tpg->src_width = width;
497 	tpg->src_height = height;
498 	tpg->field = field;
499 	tpg->buf_height = height;
500 	if (V4L2_FIELD_HAS_T_OR_B(field))
501 		tpg->buf_height /= 2;
502 	tpg->scaled_width = width;
503 	tpg->crop.top = tpg->crop.left = 0;
504 	tpg->crop.width = width;
505 	tpg->crop.height = height;
506 	tpg->compose.top = tpg->compose.left = 0;
507 	tpg->compose.width = width;
508 	tpg->compose.height = tpg->buf_height;
509 	for (p = 0; p < tpg->planes; p++)
510 		tpg->bytesperline[p] = (width * tpg->twopixelsize[p]) /
511 				       (2 * tpg->hdownsampling[p]);
512 	tpg->recalc_square_border = true;
513 }
514 EXPORT_SYMBOL_GPL(tpg_reset_source);
515 
516 static enum tpg_color tpg_get_textbg_color(struct tpg_data *tpg)
517 {
518 	switch (tpg->pattern) {
519 	case TPG_PAT_BLACK:
520 		return TPG_COLOR_100_WHITE;
521 	case TPG_PAT_CSC_COLORBAR:
522 		return TPG_COLOR_CSC_BLACK;
523 	default:
524 		return TPG_COLOR_100_BLACK;
525 	}
526 }
527 
528 static enum tpg_color tpg_get_textfg_color(struct tpg_data *tpg)
529 {
530 	switch (tpg->pattern) {
531 	case TPG_PAT_75_COLORBAR:
532 	case TPG_PAT_CSC_COLORBAR:
533 		return TPG_COLOR_CSC_WHITE;
534 	case TPG_PAT_BLACK:
535 		return TPG_COLOR_100_BLACK;
536 	default:
537 		return TPG_COLOR_100_WHITE;
538 	}
539 }
540 
541 static inline int rec709_to_linear(int v)
542 {
543 	v = clamp(v, 0, 0xff0);
544 	return tpg_rec709_to_linear[v];
545 }
546 
547 static inline int linear_to_rec709(int v)
548 {
549 	v = clamp(v, 0, 0xff0);
550 	return tpg_linear_to_rec709[v];
551 }
552 
553 static void color_to_hsv(struct tpg_data *tpg, int r, int g, int b,
554 			   int *h, int *s, int *v)
555 {
556 	int max_rgb, min_rgb, diff_rgb;
557 	int aux;
558 	int third;
559 	int third_size;
560 
561 	r >>= 4;
562 	g >>= 4;
563 	b >>= 4;
564 
565 	/* Value */
566 	max_rgb = max3(r, g, b);
567 	*v = max_rgb;
568 	if (!max_rgb) {
569 		*h = 0;
570 		*s = 0;
571 		return;
572 	}
573 
574 	/* Saturation */
575 	min_rgb = min3(r, g, b);
576 	diff_rgb = max_rgb - min_rgb;
577 	aux = 255 * diff_rgb;
578 	aux += max_rgb / 2;
579 	aux /= max_rgb;
580 	*s = aux;
581 	if (!aux) {
582 		*h = 0;
583 		return;
584 	}
585 
586 	third_size = (tpg->real_hsv_enc == V4L2_HSV_ENC_180) ? 60 : 85;
587 
588 	/* Hue */
589 	if (max_rgb == r) {
590 		aux =  g - b;
591 		third = 0;
592 	} else if (max_rgb == g) {
593 		aux =  b - r;
594 		third = third_size;
595 	} else {
596 		aux =  r - g;
597 		third = third_size * 2;
598 	}
599 
600 	aux *= third_size / 2;
601 	aux += diff_rgb / 2;
602 	aux /= diff_rgb;
603 	aux += third;
604 
605 	/* Clamp Hue */
606 	if (tpg->real_hsv_enc == V4L2_HSV_ENC_180) {
607 		if (aux < 0)
608 			aux += 180;
609 		else if (aux > 180)
610 			aux -= 180;
611 	} else {
612 		aux = aux & 0xff;
613 	}
614 
615 	*h = aux;
616 }
617 
618 static void rgb2ycbcr(const int m[3][3], int r, int g, int b,
619 			int y_offset, int *y, int *cb, int *cr)
620 {
621 	*y  = ((m[0][0] * r + m[0][1] * g + m[0][2] * b) >> 16) + (y_offset << 4);
622 	*cb = ((m[1][0] * r + m[1][1] * g + m[1][2] * b) >> 16) + (128 << 4);
623 	*cr = ((m[2][0] * r + m[2][1] * g + m[2][2] * b) >> 16) + (128 << 4);
624 }
625 
626 static void color_to_ycbcr(struct tpg_data *tpg, int r, int g, int b,
627 			   int *y, int *cb, int *cr)
628 {
629 #define COEFF(v, r) ((int)(0.5 + (v) * (r) * 256.0))
630 
631 	static const int bt601[3][3] = {
632 		{ COEFF(0.299, 219),   COEFF(0.587, 219),   COEFF(0.114, 219)   },
633 		{ COEFF(-0.1687, 224), COEFF(-0.3313, 224), COEFF(0.5, 224)     },
634 		{ COEFF(0.5, 224),     COEFF(-0.4187, 224), COEFF(-0.0813, 224) },
635 	};
636 	static const int bt601_full[3][3] = {
637 		{ COEFF(0.299, 255),   COEFF(0.587, 255),   COEFF(0.114, 255)   },
638 		{ COEFF(-0.1687, 255), COEFF(-0.3313, 255), COEFF(0.5, 255)     },
639 		{ COEFF(0.5, 255),     COEFF(-0.4187, 255), COEFF(-0.0813, 255) },
640 	};
641 	static const int rec709[3][3] = {
642 		{ COEFF(0.2126, 219),  COEFF(0.7152, 219),  COEFF(0.0722, 219)  },
643 		{ COEFF(-0.1146, 224), COEFF(-0.3854, 224), COEFF(0.5, 224)     },
644 		{ COEFF(0.5, 224),     COEFF(-0.4542, 224), COEFF(-0.0458, 224) },
645 	};
646 	static const int rec709_full[3][3] = {
647 		{ COEFF(0.2126, 255),  COEFF(0.7152, 255),  COEFF(0.0722, 255)  },
648 		{ COEFF(-0.1146, 255), COEFF(-0.3854, 255), COEFF(0.5, 255)     },
649 		{ COEFF(0.5, 255),     COEFF(-0.4542, 255), COEFF(-0.0458, 255) },
650 	};
651 	static const int smpte240m[3][3] = {
652 		{ COEFF(0.212, 219),  COEFF(0.701, 219),  COEFF(0.087, 219)  },
653 		{ COEFF(-0.116, 224), COEFF(-0.384, 224), COEFF(0.5, 224)    },
654 		{ COEFF(0.5, 224),    COEFF(-0.445, 224), COEFF(-0.055, 224) },
655 	};
656 	static const int smpte240m_full[3][3] = {
657 		{ COEFF(0.212, 255),  COEFF(0.701, 255),  COEFF(0.087, 255)  },
658 		{ COEFF(-0.116, 255), COEFF(-0.384, 255), COEFF(0.5, 255)    },
659 		{ COEFF(0.5, 255),    COEFF(-0.445, 255), COEFF(-0.055, 255) },
660 	};
661 	static const int bt2020[3][3] = {
662 		{ COEFF(0.2627, 219),  COEFF(0.6780, 219),  COEFF(0.0593, 219)  },
663 		{ COEFF(-0.1396, 224), COEFF(-0.3604, 224), COEFF(0.5, 224)     },
664 		{ COEFF(0.5, 224),     COEFF(-0.4598, 224), COEFF(-0.0402, 224) },
665 	};
666 	static const int bt2020_full[3][3] = {
667 		{ COEFF(0.2627, 255),  COEFF(0.6780, 255),  COEFF(0.0593, 255)  },
668 		{ COEFF(-0.1396, 255), COEFF(-0.3604, 255), COEFF(0.5, 255)     },
669 		{ COEFF(0.5, 255),     COEFF(-0.4598, 255), COEFF(-0.0402, 255) },
670 	};
671 	static const int bt2020c[4] = {
672 		COEFF(1.0 / 1.9404, 224), COEFF(1.0 / 1.5816, 224),
673 		COEFF(1.0 / 1.7184, 224), COEFF(1.0 / 0.9936, 224),
674 	};
675 	static const int bt2020c_full[4] = {
676 		COEFF(1.0 / 1.9404, 255), COEFF(1.0 / 1.5816, 255),
677 		COEFF(1.0 / 1.7184, 255), COEFF(1.0 / 0.9936, 255),
678 	};
679 
680 	bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
681 	unsigned y_offset = full ? 0 : 16;
682 	int lin_y, yc;
683 
684 	switch (tpg->real_ycbcr_enc) {
685 	case V4L2_YCBCR_ENC_601:
686 		rgb2ycbcr(full ? bt601_full : bt601, r, g, b, y_offset, y, cb, cr);
687 		break;
688 	case V4L2_YCBCR_ENC_XV601:
689 		/* Ignore quantization range, there is only one possible
690 		 * Y'CbCr encoding. */
691 		rgb2ycbcr(bt601, r, g, b, 16, y, cb, cr);
692 		break;
693 	case V4L2_YCBCR_ENC_XV709:
694 		/* Ignore quantization range, there is only one possible
695 		 * Y'CbCr encoding. */
696 		rgb2ycbcr(rec709, r, g, b, 16, y, cb, cr);
697 		break;
698 	case V4L2_YCBCR_ENC_BT2020:
699 		rgb2ycbcr(full ? bt2020_full : bt2020, r, g, b, y_offset, y, cb, cr);
700 		break;
701 	case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
702 		lin_y = (COEFF(0.2627, 255) * rec709_to_linear(r) +
703 			 COEFF(0.6780, 255) * rec709_to_linear(g) +
704 			 COEFF(0.0593, 255) * rec709_to_linear(b)) >> 16;
705 		yc = linear_to_rec709(lin_y);
706 		*y = full ? yc : (yc * 219) / 255 + (16 << 4);
707 		if (b <= yc)
708 			*cb = (((b - yc) * (full ? bt2020c_full[0] : bt2020c[0])) >> 16) + (128 << 4);
709 		else
710 			*cb = (((b - yc) * (full ? bt2020c_full[1] : bt2020c[1])) >> 16) + (128 << 4);
711 		if (r <= yc)
712 			*cr = (((r - yc) * (full ? bt2020c_full[2] : bt2020c[2])) >> 16) + (128 << 4);
713 		else
714 			*cr = (((r - yc) * (full ? bt2020c_full[3] : bt2020c[3])) >> 16) + (128 << 4);
715 		break;
716 	case V4L2_YCBCR_ENC_SMPTE240M:
717 		rgb2ycbcr(full ? smpte240m_full : smpte240m, r, g, b, y_offset, y, cb, cr);
718 		break;
719 	case V4L2_YCBCR_ENC_709:
720 	default:
721 		rgb2ycbcr(full ? rec709_full : rec709, r, g, b, y_offset, y, cb, cr);
722 		break;
723 	}
724 }
725 
726 static void ycbcr2rgb(const int m[3][3], int y, int cb, int cr,
727 			int y_offset, int *r, int *g, int *b)
728 {
729 	y -= y_offset << 4;
730 	cb -= 128 << 4;
731 	cr -= 128 << 4;
732 	*r = m[0][0] * y + m[0][1] * cb + m[0][2] * cr;
733 	*g = m[1][0] * y + m[1][1] * cb + m[1][2] * cr;
734 	*b = m[2][0] * y + m[2][1] * cb + m[2][2] * cr;
735 	*r = clamp(*r >> 12, 0, 0xff0);
736 	*g = clamp(*g >> 12, 0, 0xff0);
737 	*b = clamp(*b >> 12, 0, 0xff0);
738 }
739 
740 static void ycbcr_to_color(struct tpg_data *tpg, int y, int cb, int cr,
741 			   int *r, int *g, int *b)
742 {
743 #undef COEFF
744 #define COEFF(v, r) ((int)(0.5 + (v) * ((255.0 * 255.0 * 16.0) / (r))))
745 	static const int bt601[3][3] = {
746 		{ COEFF(1, 219), COEFF(0, 224),       COEFF(1.4020, 224)  },
747 		{ COEFF(1, 219), COEFF(-0.3441, 224), COEFF(-0.7141, 224) },
748 		{ COEFF(1, 219), COEFF(1.7720, 224),  COEFF(0, 224)       },
749 	};
750 	static const int bt601_full[3][3] = {
751 		{ COEFF(1, 255), COEFF(0, 255),       COEFF(1.4020, 255)  },
752 		{ COEFF(1, 255), COEFF(-0.3441, 255), COEFF(-0.7141, 255) },
753 		{ COEFF(1, 255), COEFF(1.7720, 255),  COEFF(0, 255)       },
754 	};
755 	static const int rec709[3][3] = {
756 		{ COEFF(1, 219), COEFF(0, 224),       COEFF(1.5748, 224)  },
757 		{ COEFF(1, 219), COEFF(-0.1873, 224), COEFF(-0.4681, 224) },
758 		{ COEFF(1, 219), COEFF(1.8556, 224),  COEFF(0, 224)       },
759 	};
760 	static const int rec709_full[3][3] = {
761 		{ COEFF(1, 255), COEFF(0, 255),       COEFF(1.5748, 255)  },
762 		{ COEFF(1, 255), COEFF(-0.1873, 255), COEFF(-0.4681, 255) },
763 		{ COEFF(1, 255), COEFF(1.8556, 255),  COEFF(0, 255)       },
764 	};
765 	static const int smpte240m[3][3] = {
766 		{ COEFF(1, 219), COEFF(0, 224),       COEFF(1.5756, 224)  },
767 		{ COEFF(1, 219), COEFF(-0.2253, 224), COEFF(-0.4767, 224) },
768 		{ COEFF(1, 219), COEFF(1.8270, 224),  COEFF(0, 224)       },
769 	};
770 	static const int smpte240m_full[3][3] = {
771 		{ COEFF(1, 255), COEFF(0, 255),       COEFF(1.5756, 255)  },
772 		{ COEFF(1, 255), COEFF(-0.2253, 255), COEFF(-0.4767, 255) },
773 		{ COEFF(1, 255), COEFF(1.8270, 255),  COEFF(0, 255)       },
774 	};
775 	static const int bt2020[3][3] = {
776 		{ COEFF(1, 219), COEFF(0, 224),       COEFF(1.4746, 224)  },
777 		{ COEFF(1, 219), COEFF(-0.1646, 224), COEFF(-0.5714, 224) },
778 		{ COEFF(1, 219), COEFF(1.8814, 224),  COEFF(0, 224)       },
779 	};
780 	static const int bt2020_full[3][3] = {
781 		{ COEFF(1, 255), COEFF(0, 255),       COEFF(1.4746, 255)  },
782 		{ COEFF(1, 255), COEFF(-0.1646, 255), COEFF(-0.5714, 255) },
783 		{ COEFF(1, 255), COEFF(1.8814, 255),  COEFF(0, 255)       },
784 	};
785 	static const int bt2020c[4] = {
786 		COEFF(1.9404, 224), COEFF(1.5816, 224),
787 		COEFF(1.7184, 224), COEFF(0.9936, 224),
788 	};
789 	static const int bt2020c_full[4] = {
790 		COEFF(1.9404, 255), COEFF(1.5816, 255),
791 		COEFF(1.7184, 255), COEFF(0.9936, 255),
792 	};
793 
794 	bool full = tpg->real_quantization == V4L2_QUANTIZATION_FULL_RANGE;
795 	unsigned y_offset = full ? 0 : 16;
796 	int y_fac = full ? COEFF(1.0, 255) : COEFF(1.0, 219);
797 	int lin_r, lin_g, lin_b, lin_y;
798 
799 	switch (tpg->real_ycbcr_enc) {
800 	case V4L2_YCBCR_ENC_601:
801 		ycbcr2rgb(full ? bt601_full : bt601, y, cb, cr, y_offset, r, g, b);
802 		break;
803 	case V4L2_YCBCR_ENC_XV601:
804 		/* Ignore quantization range, there is only one possible
805 		 * Y'CbCr encoding. */
806 		ycbcr2rgb(bt601, y, cb, cr, 16, r, g, b);
807 		break;
808 	case V4L2_YCBCR_ENC_XV709:
809 		/* Ignore quantization range, there is only one possible
810 		 * Y'CbCr encoding. */
811 		ycbcr2rgb(rec709, y, cb, cr, 16, r, g, b);
812 		break;
813 	case V4L2_YCBCR_ENC_BT2020:
814 		ycbcr2rgb(full ? bt2020_full : bt2020, y, cb, cr, y_offset, r, g, b);
815 		break;
816 	case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
817 		y -= full ? 0 : 16 << 4;
818 		cb -= 128 << 4;
819 		cr -= 128 << 4;
820 
821 		if (cb <= 0)
822 			*b = y_fac * y + (full ? bt2020c_full[0] : bt2020c[0]) * cb;
823 		else
824 			*b = y_fac * y + (full ? bt2020c_full[1] : bt2020c[1]) * cb;
825 		*b = *b >> 12;
826 		if (cr <= 0)
827 			*r = y_fac * y + (full ? bt2020c_full[2] : bt2020c[2]) * cr;
828 		else
829 			*r = y_fac * y + (full ? bt2020c_full[3] : bt2020c[3]) * cr;
830 		*r = *r >> 12;
831 		lin_r = rec709_to_linear(*r);
832 		lin_b = rec709_to_linear(*b);
833 		lin_y = rec709_to_linear((y * 255) / (full ? 255 : 219));
834 
835 		lin_g = COEFF(1.0 / 0.6780, 255) * lin_y -
836 			COEFF(0.2627 / 0.6780, 255) * lin_r -
837 			COEFF(0.0593 / 0.6780, 255) * lin_b;
838 		*g = linear_to_rec709(lin_g >> 12);
839 		break;
840 	case V4L2_YCBCR_ENC_SMPTE240M:
841 		ycbcr2rgb(full ? smpte240m_full : smpte240m, y, cb, cr, y_offset, r, g, b);
842 		break;
843 	case V4L2_YCBCR_ENC_709:
844 	default:
845 		ycbcr2rgb(full ? rec709_full : rec709, y, cb, cr, y_offset, r, g, b);
846 		break;
847 	}
848 }
849 
850 /* precalculate color bar values to speed up rendering */
851 static void precalculate_color(struct tpg_data *tpg, int k)
852 {
853 	int col = k;
854 	int r = tpg_colors[col].r;
855 	int g = tpg_colors[col].g;
856 	int b = tpg_colors[col].b;
857 	int y, cb, cr;
858 	bool ycbcr_valid = false;
859 
860 	if (k == TPG_COLOR_TEXTBG) {
861 		col = tpg_get_textbg_color(tpg);
862 
863 		r = tpg_colors[col].r;
864 		g = tpg_colors[col].g;
865 		b = tpg_colors[col].b;
866 	} else if (k == TPG_COLOR_TEXTFG) {
867 		col = tpg_get_textfg_color(tpg);
868 
869 		r = tpg_colors[col].r;
870 		g = tpg_colors[col].g;
871 		b = tpg_colors[col].b;
872 	} else if (tpg->pattern == TPG_PAT_NOISE) {
873 		r = g = b = prandom_u32_max(256);
874 	} else if (k == TPG_COLOR_RANDOM) {
875 		r = g = b = tpg->qual_offset + prandom_u32_max(196);
876 	} else if (k >= TPG_COLOR_RAMP) {
877 		r = g = b = k - TPG_COLOR_RAMP;
878 	}
879 
880 	if (tpg->pattern == TPG_PAT_CSC_COLORBAR && col <= TPG_COLOR_CSC_BLACK) {
881 		r = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].r;
882 		g = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].g;
883 		b = tpg_csc_colors[tpg->colorspace][tpg->real_xfer_func][col].b;
884 	} else {
885 		r <<= 4;
886 		g <<= 4;
887 		b <<= 4;
888 	}
889 
890 	if (tpg->qual == TPG_QUAL_GRAY ||
891 	    tpg->color_enc ==  TGP_COLOR_ENC_LUMA) {
892 		/* Rec. 709 Luma function */
893 		/* (0.2126, 0.7152, 0.0722) * (255 * 256) */
894 		r = g = b = (13879 * r + 46688 * g + 4713 * b) >> 16;
895 	}
896 
897 	/*
898 	 * The assumption is that the RGB output is always full range,
899 	 * so only if the rgb_range overrides the 'real' rgb range do
900 	 * we need to convert the RGB values.
901 	 *
902 	 * Remember that r, g and b are still in the 0 - 0xff0 range.
903 	 */
904 	if (tpg->real_rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
905 	    tpg->rgb_range == V4L2_DV_RGB_RANGE_FULL &&
906 	    tpg->color_enc == TGP_COLOR_ENC_RGB) {
907 		/*
908 		 * Convert from full range (which is what r, g and b are)
909 		 * to limited range (which is the 'real' RGB range), which
910 		 * is then interpreted as full range.
911 		 */
912 		r = (r * 219) / 255 + (16 << 4);
913 		g = (g * 219) / 255 + (16 << 4);
914 		b = (b * 219) / 255 + (16 << 4);
915 	} else if (tpg->real_rgb_range != V4L2_DV_RGB_RANGE_LIMITED &&
916 		   tpg->rgb_range == V4L2_DV_RGB_RANGE_LIMITED &&
917 		   tpg->color_enc == TGP_COLOR_ENC_RGB) {
918 
919 		/*
920 		 * Clamp r, g and b to the limited range and convert to full
921 		 * range since that's what we deliver.
922 		 */
923 		r = clamp(r, 16 << 4, 235 << 4);
924 		g = clamp(g, 16 << 4, 235 << 4);
925 		b = clamp(b, 16 << 4, 235 << 4);
926 		r = (r - (16 << 4)) * 255 / 219;
927 		g = (g - (16 << 4)) * 255 / 219;
928 		b = (b - (16 << 4)) * 255 / 219;
929 	}
930 
931 	if ((tpg->brightness != 128 || tpg->contrast != 128 ||
932 	     tpg->saturation != 128 || tpg->hue) &&
933 	    tpg->color_enc != TGP_COLOR_ENC_LUMA) {
934 		/* Implement these operations */
935 		int tmp_cb, tmp_cr;
936 
937 		/* First convert to YCbCr */
938 
939 		color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
940 
941 		y = (16 << 4) + ((y - (16 << 4)) * tpg->contrast) / 128;
942 		y += (tpg->brightness << 4) - (128 << 4);
943 
944 		cb -= 128 << 4;
945 		cr -= 128 << 4;
946 		tmp_cb = (cb * cos(128 + tpg->hue)) / 127 + (cr * sin[128 + tpg->hue]) / 127;
947 		tmp_cr = (cr * cos(128 + tpg->hue)) / 127 - (cb * sin[128 + tpg->hue]) / 127;
948 
949 		cb = (128 << 4) + (tmp_cb * tpg->contrast * tpg->saturation) / (128 * 128);
950 		cr = (128 << 4) + (tmp_cr * tpg->contrast * tpg->saturation) / (128 * 128);
951 		if (tpg->color_enc == TGP_COLOR_ENC_YCBCR)
952 			ycbcr_valid = true;
953 		else
954 			ycbcr_to_color(tpg, y, cb, cr, &r, &g, &b);
955 	} else if ((tpg->brightness != 128 || tpg->contrast != 128) &&
956 		   tpg->color_enc == TGP_COLOR_ENC_LUMA) {
957 		r = (16 << 4) + ((r - (16 << 4)) * tpg->contrast) / 128;
958 		r += (tpg->brightness << 4) - (128 << 4);
959 	}
960 
961 	switch (tpg->color_enc) {
962 	case TGP_COLOR_ENC_HSV:
963 	{
964 		int h, s, v;
965 
966 		color_to_hsv(tpg, r, g, b, &h, &s, &v);
967 		tpg->colors[k][0] = h;
968 		tpg->colors[k][1] = s;
969 		tpg->colors[k][2] = v;
970 		break;
971 	}
972 	case TGP_COLOR_ENC_YCBCR:
973 	{
974 		/* Convert to YCbCr */
975 		if (!ycbcr_valid)
976 			color_to_ycbcr(tpg, r, g, b, &y, &cb, &cr);
977 
978 		y >>= 4;
979 		cb >>= 4;
980 		cr >>= 4;
981 		/*
982 		 * XV601/709 use the header/footer margins to encode R', G'
983 		 * and B' values outside the range [0-1]. So do not clamp
984 		 * XV601/709 values.
985 		 */
986 		if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE &&
987 		    tpg->real_ycbcr_enc != V4L2_YCBCR_ENC_XV601 &&
988 		    tpg->real_ycbcr_enc != V4L2_YCBCR_ENC_XV709) {
989 			y = clamp(y, 16, 235);
990 			cb = clamp(cb, 16, 240);
991 			cr = clamp(cr, 16, 240);
992 		} else {
993 			y = clamp(y, 1, 254);
994 			cb = clamp(cb, 1, 254);
995 			cr = clamp(cr, 1, 254);
996 		}
997 		switch (tpg->fourcc) {
998 		case V4L2_PIX_FMT_YUV444:
999 			y >>= 4;
1000 			cb >>= 4;
1001 			cr >>= 4;
1002 			break;
1003 		case V4L2_PIX_FMT_YUV555:
1004 			y >>= 3;
1005 			cb >>= 3;
1006 			cr >>= 3;
1007 			break;
1008 		case V4L2_PIX_FMT_YUV565:
1009 			y >>= 3;
1010 			cb >>= 2;
1011 			cr >>= 3;
1012 			break;
1013 		}
1014 		tpg->colors[k][0] = y;
1015 		tpg->colors[k][1] = cb;
1016 		tpg->colors[k][2] = cr;
1017 		break;
1018 	}
1019 	case TGP_COLOR_ENC_LUMA:
1020 	{
1021 		tpg->colors[k][0] = r >> 4;
1022 		break;
1023 	}
1024 	case TGP_COLOR_ENC_RGB:
1025 	{
1026 		if (tpg->real_quantization == V4L2_QUANTIZATION_LIM_RANGE) {
1027 			r = (r * 219) / 255 + (16 << 4);
1028 			g = (g * 219) / 255 + (16 << 4);
1029 			b = (b * 219) / 255 + (16 << 4);
1030 		}
1031 		switch (tpg->fourcc) {
1032 		case V4L2_PIX_FMT_RGB332:
1033 			r >>= 9;
1034 			g >>= 9;
1035 			b >>= 10;
1036 			break;
1037 		case V4L2_PIX_FMT_RGB565:
1038 		case V4L2_PIX_FMT_RGB565X:
1039 			r >>= 7;
1040 			g >>= 6;
1041 			b >>= 7;
1042 			break;
1043 		case V4L2_PIX_FMT_RGB444:
1044 		case V4L2_PIX_FMT_XRGB444:
1045 		case V4L2_PIX_FMT_ARGB444:
1046 		case V4L2_PIX_FMT_RGBX444:
1047 		case V4L2_PIX_FMT_RGBA444:
1048 		case V4L2_PIX_FMT_XBGR444:
1049 		case V4L2_PIX_FMT_ABGR444:
1050 		case V4L2_PIX_FMT_BGRX444:
1051 		case V4L2_PIX_FMT_BGRA444:
1052 			r >>= 8;
1053 			g >>= 8;
1054 			b >>= 8;
1055 			break;
1056 		case V4L2_PIX_FMT_RGB555:
1057 		case V4L2_PIX_FMT_XRGB555:
1058 		case V4L2_PIX_FMT_ARGB555:
1059 		case V4L2_PIX_FMT_RGBX555:
1060 		case V4L2_PIX_FMT_RGBA555:
1061 		case V4L2_PIX_FMT_XBGR555:
1062 		case V4L2_PIX_FMT_ABGR555:
1063 		case V4L2_PIX_FMT_BGRX555:
1064 		case V4L2_PIX_FMT_BGRA555:
1065 		case V4L2_PIX_FMT_RGB555X:
1066 		case V4L2_PIX_FMT_XRGB555X:
1067 		case V4L2_PIX_FMT_ARGB555X:
1068 			r >>= 7;
1069 			g >>= 7;
1070 			b >>= 7;
1071 			break;
1072 		case V4L2_PIX_FMT_BGR666:
1073 			r >>= 6;
1074 			g >>= 6;
1075 			b >>= 6;
1076 			break;
1077 		default:
1078 			r >>= 4;
1079 			g >>= 4;
1080 			b >>= 4;
1081 			break;
1082 		}
1083 
1084 		tpg->colors[k][0] = r;
1085 		tpg->colors[k][1] = g;
1086 		tpg->colors[k][2] = b;
1087 		break;
1088 	}
1089 	}
1090 }
1091 
1092 static void tpg_precalculate_colors(struct tpg_data *tpg)
1093 {
1094 	int k;
1095 
1096 	for (k = 0; k < TPG_COLOR_MAX; k++)
1097 		precalculate_color(tpg, k);
1098 }
1099 
1100 /* 'odd' is true for pixels 1, 3, 5, etc. and false for pixels 0, 2, 4, etc. */
1101 static void gen_twopix(struct tpg_data *tpg,
1102 		u8 buf[TPG_MAX_PLANES][8], int color, bool odd)
1103 {
1104 	unsigned offset = odd * tpg->twopixelsize[0] / 2;
1105 	u8 alpha = tpg->alpha_component;
1106 	u8 r_y_h, g_u_s, b_v;
1107 
1108 	if (tpg->alpha_red_only && color != TPG_COLOR_CSC_RED &&
1109 				   color != TPG_COLOR_100_RED &&
1110 				   color != TPG_COLOR_75_RED)
1111 		alpha = 0;
1112 	if (color == TPG_COLOR_RANDOM)
1113 		precalculate_color(tpg, color);
1114 	r_y_h = tpg->colors[color][0]; /* R or precalculated Y, H */
1115 	g_u_s = tpg->colors[color][1]; /* G or precalculated U, V */
1116 	b_v = tpg->colors[color][2]; /* B or precalculated V */
1117 
1118 	switch (tpg->fourcc) {
1119 	case V4L2_PIX_FMT_GREY:
1120 		buf[0][offset] = r_y_h;
1121 		break;
1122 	case V4L2_PIX_FMT_Y10:
1123 		buf[0][offset] = (r_y_h << 2) & 0xff;
1124 		buf[0][offset+1] = r_y_h >> 6;
1125 		break;
1126 	case V4L2_PIX_FMT_Y12:
1127 		buf[0][offset] = (r_y_h << 4) & 0xff;
1128 		buf[0][offset+1] = r_y_h >> 4;
1129 		break;
1130 	case V4L2_PIX_FMT_Y16:
1131 	case V4L2_PIX_FMT_Z16:
1132 		/*
1133 		 * Ideally both bytes should be set to r_y_h, but then you won't
1134 		 * be able to detect endian problems. So keep it 0 except for
1135 		 * the corner case where r_y_h is 0xff so white really will be
1136 		 * white (0xffff).
1137 		 */
1138 		buf[0][offset] = r_y_h == 0xff ? r_y_h : 0;
1139 		buf[0][offset+1] = r_y_h;
1140 		break;
1141 	case V4L2_PIX_FMT_Y16_BE:
1142 		/* See comment for V4L2_PIX_FMT_Y16 above */
1143 		buf[0][offset] = r_y_h;
1144 		buf[0][offset+1] = r_y_h == 0xff ? r_y_h : 0;
1145 		break;
1146 	case V4L2_PIX_FMT_YUV422M:
1147 	case V4L2_PIX_FMT_YUV422P:
1148 	case V4L2_PIX_FMT_YUV420:
1149 	case V4L2_PIX_FMT_YUV420M:
1150 		buf[0][offset] = r_y_h;
1151 		if (odd) {
1152 			buf[1][0] = (buf[1][0] + g_u_s) / 2;
1153 			buf[2][0] = (buf[2][0] + b_v) / 2;
1154 			buf[1][1] = buf[1][0];
1155 			buf[2][1] = buf[2][0];
1156 			break;
1157 		}
1158 		buf[1][0] = g_u_s;
1159 		buf[2][0] = b_v;
1160 		break;
1161 	case V4L2_PIX_FMT_YVU422M:
1162 	case V4L2_PIX_FMT_YVU420:
1163 	case V4L2_PIX_FMT_YVU420M:
1164 		buf[0][offset] = r_y_h;
1165 		if (odd) {
1166 			buf[1][0] = (buf[1][0] + b_v) / 2;
1167 			buf[2][0] = (buf[2][0] + g_u_s) / 2;
1168 			buf[1][1] = buf[1][0];
1169 			buf[2][1] = buf[2][0];
1170 			break;
1171 		}
1172 		buf[1][0] = b_v;
1173 		buf[2][0] = g_u_s;
1174 		break;
1175 
1176 	case V4L2_PIX_FMT_NV12:
1177 	case V4L2_PIX_FMT_NV12M:
1178 	case V4L2_PIX_FMT_NV16:
1179 	case V4L2_PIX_FMT_NV16M:
1180 		buf[0][offset] = r_y_h;
1181 		if (odd) {
1182 			buf[1][0] = (buf[1][0] + g_u_s) / 2;
1183 			buf[1][1] = (buf[1][1] + b_v) / 2;
1184 			break;
1185 		}
1186 		buf[1][0] = g_u_s;
1187 		buf[1][1] = b_v;
1188 		break;
1189 	case V4L2_PIX_FMT_NV21:
1190 	case V4L2_PIX_FMT_NV21M:
1191 	case V4L2_PIX_FMT_NV61:
1192 	case V4L2_PIX_FMT_NV61M:
1193 		buf[0][offset] = r_y_h;
1194 		if (odd) {
1195 			buf[1][0] = (buf[1][0] + b_v) / 2;
1196 			buf[1][1] = (buf[1][1] + g_u_s) / 2;
1197 			break;
1198 		}
1199 		buf[1][0] = b_v;
1200 		buf[1][1] = g_u_s;
1201 		break;
1202 
1203 	case V4L2_PIX_FMT_YUV444M:
1204 		buf[0][offset] = r_y_h;
1205 		buf[1][offset] = g_u_s;
1206 		buf[2][offset] = b_v;
1207 		break;
1208 
1209 	case V4L2_PIX_FMT_YVU444M:
1210 		buf[0][offset] = r_y_h;
1211 		buf[1][offset] = b_v;
1212 		buf[2][offset] = g_u_s;
1213 		break;
1214 
1215 	case V4L2_PIX_FMT_NV24:
1216 		buf[0][offset] = r_y_h;
1217 		buf[1][2 * offset] = g_u_s;
1218 		buf[1][(2 * offset + 1) % 8] = b_v;
1219 		break;
1220 
1221 	case V4L2_PIX_FMT_NV42:
1222 		buf[0][offset] = r_y_h;
1223 		buf[1][2 * offset] = b_v;
1224 		buf[1][(2 * offset + 1) % 8] = g_u_s;
1225 		break;
1226 
1227 	case V4L2_PIX_FMT_YUYV:
1228 		buf[0][offset] = r_y_h;
1229 		if (odd) {
1230 			buf[0][1] = (buf[0][1] + g_u_s) / 2;
1231 			buf[0][3] = (buf[0][3] + b_v) / 2;
1232 			break;
1233 		}
1234 		buf[0][1] = g_u_s;
1235 		buf[0][3] = b_v;
1236 		break;
1237 	case V4L2_PIX_FMT_UYVY:
1238 		buf[0][offset + 1] = r_y_h;
1239 		if (odd) {
1240 			buf[0][0] = (buf[0][0] + g_u_s) / 2;
1241 			buf[0][2] = (buf[0][2] + b_v) / 2;
1242 			break;
1243 		}
1244 		buf[0][0] = g_u_s;
1245 		buf[0][2] = b_v;
1246 		break;
1247 	case V4L2_PIX_FMT_YVYU:
1248 		buf[0][offset] = r_y_h;
1249 		if (odd) {
1250 			buf[0][1] = (buf[0][1] + b_v) / 2;
1251 			buf[0][3] = (buf[0][3] + g_u_s) / 2;
1252 			break;
1253 		}
1254 		buf[0][1] = b_v;
1255 		buf[0][3] = g_u_s;
1256 		break;
1257 	case V4L2_PIX_FMT_VYUY:
1258 		buf[0][offset + 1] = r_y_h;
1259 		if (odd) {
1260 			buf[0][0] = (buf[0][0] + b_v) / 2;
1261 			buf[0][2] = (buf[0][2] + g_u_s) / 2;
1262 			break;
1263 		}
1264 		buf[0][0] = b_v;
1265 		buf[0][2] = g_u_s;
1266 		break;
1267 	case V4L2_PIX_FMT_RGB332:
1268 		buf[0][offset] = (r_y_h << 5) | (g_u_s << 2) | b_v;
1269 		break;
1270 	case V4L2_PIX_FMT_YUV565:
1271 	case V4L2_PIX_FMT_RGB565:
1272 		buf[0][offset] = (g_u_s << 5) | b_v;
1273 		buf[0][offset + 1] = (r_y_h << 3) | (g_u_s >> 3);
1274 		break;
1275 	case V4L2_PIX_FMT_RGB565X:
1276 		buf[0][offset] = (r_y_h << 3) | (g_u_s >> 3);
1277 		buf[0][offset + 1] = (g_u_s << 5) | b_v;
1278 		break;
1279 	case V4L2_PIX_FMT_RGB444:
1280 	case V4L2_PIX_FMT_XRGB444:
1281 		alpha = 0;
1282 		fallthrough;
1283 	case V4L2_PIX_FMT_YUV444:
1284 	case V4L2_PIX_FMT_ARGB444:
1285 		buf[0][offset] = (g_u_s << 4) | b_v;
1286 		buf[0][offset + 1] = (alpha & 0xf0) | r_y_h;
1287 		break;
1288 	case V4L2_PIX_FMT_RGBX444:
1289 		alpha = 0;
1290 		fallthrough;
1291 	case V4L2_PIX_FMT_RGBA444:
1292 		buf[0][offset] = (b_v << 4) | (alpha >> 4);
1293 		buf[0][offset + 1] = (r_y_h << 4) | g_u_s;
1294 		break;
1295 	case V4L2_PIX_FMT_XBGR444:
1296 		alpha = 0;
1297 		fallthrough;
1298 	case V4L2_PIX_FMT_ABGR444:
1299 		buf[0][offset] = (g_u_s << 4) | r_y_h;
1300 		buf[0][offset + 1] = (alpha & 0xf0) | b_v;
1301 		break;
1302 	case V4L2_PIX_FMT_BGRX444:
1303 		alpha = 0;
1304 		fallthrough;
1305 	case V4L2_PIX_FMT_BGRA444:
1306 		buf[0][offset] = (r_y_h << 4) | (alpha >> 4);
1307 		buf[0][offset + 1] = (b_v << 4) | g_u_s;
1308 		break;
1309 	case V4L2_PIX_FMT_RGB555:
1310 	case V4L2_PIX_FMT_XRGB555:
1311 		alpha = 0;
1312 		fallthrough;
1313 	case V4L2_PIX_FMT_YUV555:
1314 	case V4L2_PIX_FMT_ARGB555:
1315 		buf[0][offset] = (g_u_s << 5) | b_v;
1316 		buf[0][offset + 1] = (alpha & 0x80) | (r_y_h << 2)
1317 						    | (g_u_s >> 3);
1318 		break;
1319 	case V4L2_PIX_FMT_RGBX555:
1320 		alpha = 0;
1321 		fallthrough;
1322 	case V4L2_PIX_FMT_RGBA555:
1323 		buf[0][offset] = (g_u_s << 6) | (b_v << 1) |
1324 				 ((alpha & 0x80) >> 7);
1325 		buf[0][offset + 1] = (r_y_h << 3) | (g_u_s >> 2);
1326 		break;
1327 	case V4L2_PIX_FMT_XBGR555:
1328 		alpha = 0;
1329 		fallthrough;
1330 	case V4L2_PIX_FMT_ABGR555:
1331 		buf[0][offset] = (g_u_s << 5) | r_y_h;
1332 		buf[0][offset + 1] = (alpha & 0x80) | (b_v << 2)
1333 						    | (g_u_s >> 3);
1334 		break;
1335 	case V4L2_PIX_FMT_BGRX555:
1336 		alpha = 0;
1337 		fallthrough;
1338 	case V4L2_PIX_FMT_BGRA555:
1339 		buf[0][offset] = (g_u_s << 6) | (r_y_h << 1) |
1340 				 ((alpha & 0x80) >> 7);
1341 		buf[0][offset + 1] = (b_v << 3) | (g_u_s >> 2);
1342 		break;
1343 	case V4L2_PIX_FMT_RGB555X:
1344 	case V4L2_PIX_FMT_XRGB555X:
1345 		alpha = 0;
1346 		fallthrough;
1347 	case V4L2_PIX_FMT_ARGB555X:
1348 		buf[0][offset] = (alpha & 0x80) | (r_y_h << 2) | (g_u_s >> 3);
1349 		buf[0][offset + 1] = (g_u_s << 5) | b_v;
1350 		break;
1351 	case V4L2_PIX_FMT_RGB24:
1352 	case V4L2_PIX_FMT_HSV24:
1353 		buf[0][offset] = r_y_h;
1354 		buf[0][offset + 1] = g_u_s;
1355 		buf[0][offset + 2] = b_v;
1356 		break;
1357 	case V4L2_PIX_FMT_BGR24:
1358 		buf[0][offset] = b_v;
1359 		buf[0][offset + 1] = g_u_s;
1360 		buf[0][offset + 2] = r_y_h;
1361 		break;
1362 	case V4L2_PIX_FMT_BGR666:
1363 		buf[0][offset] = (b_v << 2) | (g_u_s >> 4);
1364 		buf[0][offset + 1] = (g_u_s << 4) | (r_y_h >> 2);
1365 		buf[0][offset + 2] = r_y_h << 6;
1366 		buf[0][offset + 3] = 0;
1367 		break;
1368 	case V4L2_PIX_FMT_RGB32:
1369 	case V4L2_PIX_FMT_XRGB32:
1370 	case V4L2_PIX_FMT_HSV32:
1371 	case V4L2_PIX_FMT_XYUV32:
1372 		alpha = 0;
1373 		fallthrough;
1374 	case V4L2_PIX_FMT_YUV32:
1375 	case V4L2_PIX_FMT_ARGB32:
1376 	case V4L2_PIX_FMT_AYUV32:
1377 		buf[0][offset] = alpha;
1378 		buf[0][offset + 1] = r_y_h;
1379 		buf[0][offset + 2] = g_u_s;
1380 		buf[0][offset + 3] = b_v;
1381 		break;
1382 	case V4L2_PIX_FMT_RGBX32:
1383 	case V4L2_PIX_FMT_YUVX32:
1384 		alpha = 0;
1385 		fallthrough;
1386 	case V4L2_PIX_FMT_RGBA32:
1387 	case V4L2_PIX_FMT_YUVA32:
1388 		buf[0][offset] = r_y_h;
1389 		buf[0][offset + 1] = g_u_s;
1390 		buf[0][offset + 2] = b_v;
1391 		buf[0][offset + 3] = alpha;
1392 		break;
1393 	case V4L2_PIX_FMT_BGR32:
1394 	case V4L2_PIX_FMT_XBGR32:
1395 	case V4L2_PIX_FMT_VUYX32:
1396 		alpha = 0;
1397 		fallthrough;
1398 	case V4L2_PIX_FMT_ABGR32:
1399 	case V4L2_PIX_FMT_VUYA32:
1400 		buf[0][offset] = b_v;
1401 		buf[0][offset + 1] = g_u_s;
1402 		buf[0][offset + 2] = r_y_h;
1403 		buf[0][offset + 3] = alpha;
1404 		break;
1405 	case V4L2_PIX_FMT_BGRX32:
1406 		alpha = 0;
1407 		fallthrough;
1408 	case V4L2_PIX_FMT_BGRA32:
1409 		buf[0][offset] = alpha;
1410 		buf[0][offset + 1] = b_v;
1411 		buf[0][offset + 2] = g_u_s;
1412 		buf[0][offset + 3] = r_y_h;
1413 		break;
1414 	case V4L2_PIX_FMT_SBGGR8:
1415 		buf[0][offset] = odd ? g_u_s : b_v;
1416 		buf[1][offset] = odd ? r_y_h : g_u_s;
1417 		break;
1418 	case V4L2_PIX_FMT_SGBRG8:
1419 		buf[0][offset] = odd ? b_v : g_u_s;
1420 		buf[1][offset] = odd ? g_u_s : r_y_h;
1421 		break;
1422 	case V4L2_PIX_FMT_SGRBG8:
1423 		buf[0][offset] = odd ? r_y_h : g_u_s;
1424 		buf[1][offset] = odd ? g_u_s : b_v;
1425 		break;
1426 	case V4L2_PIX_FMT_SRGGB8:
1427 		buf[0][offset] = odd ? g_u_s : r_y_h;
1428 		buf[1][offset] = odd ? b_v : g_u_s;
1429 		break;
1430 	case V4L2_PIX_FMT_SBGGR10:
1431 		buf[0][offset] = odd ? g_u_s << 2 : b_v << 2;
1432 		buf[0][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1433 		buf[1][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1434 		buf[1][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1435 		buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1436 		buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1437 		break;
1438 	case V4L2_PIX_FMT_SGBRG10:
1439 		buf[0][offset] = odd ? b_v << 2 : g_u_s << 2;
1440 		buf[0][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1441 		buf[1][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1442 		buf[1][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1443 		buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1444 		buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1445 		break;
1446 	case V4L2_PIX_FMT_SGRBG10:
1447 		buf[0][offset] = odd ? r_y_h << 2 : g_u_s << 2;
1448 		buf[0][offset + 1] = odd ? r_y_h >> 6 : g_u_s >> 6;
1449 		buf[1][offset] = odd ? g_u_s << 2 : b_v << 2;
1450 		buf[1][offset + 1] = odd ? g_u_s >> 6 : b_v >> 6;
1451 		buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1452 		buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1453 		break;
1454 	case V4L2_PIX_FMT_SRGGB10:
1455 		buf[0][offset] = odd ? g_u_s << 2 : r_y_h << 2;
1456 		buf[0][offset + 1] = odd ? g_u_s >> 6 : r_y_h >> 6;
1457 		buf[1][offset] = odd ? b_v << 2 : g_u_s << 2;
1458 		buf[1][offset + 1] = odd ? b_v >> 6 : g_u_s >> 6;
1459 		buf[0][offset] |= (buf[0][offset] >> 2) & 3;
1460 		buf[1][offset] |= (buf[1][offset] >> 2) & 3;
1461 		break;
1462 	case V4L2_PIX_FMT_SBGGR12:
1463 		buf[0][offset] = odd ? g_u_s << 4 : b_v << 4;
1464 		buf[0][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1465 		buf[1][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1466 		buf[1][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1467 		buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1468 		buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1469 		break;
1470 	case V4L2_PIX_FMT_SGBRG12:
1471 		buf[0][offset] = odd ? b_v << 4 : g_u_s << 4;
1472 		buf[0][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1473 		buf[1][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1474 		buf[1][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1475 		buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1476 		buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1477 		break;
1478 	case V4L2_PIX_FMT_SGRBG12:
1479 		buf[0][offset] = odd ? r_y_h << 4 : g_u_s << 4;
1480 		buf[0][offset + 1] = odd ? r_y_h >> 4 : g_u_s >> 4;
1481 		buf[1][offset] = odd ? g_u_s << 4 : b_v << 4;
1482 		buf[1][offset + 1] = odd ? g_u_s >> 4 : b_v >> 4;
1483 		buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1484 		buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1485 		break;
1486 	case V4L2_PIX_FMT_SRGGB12:
1487 		buf[0][offset] = odd ? g_u_s << 4 : r_y_h << 4;
1488 		buf[0][offset + 1] = odd ? g_u_s >> 4 : r_y_h >> 4;
1489 		buf[1][offset] = odd ? b_v << 4 : g_u_s << 4;
1490 		buf[1][offset + 1] = odd ? b_v >> 4 : g_u_s >> 4;
1491 		buf[0][offset] |= (buf[0][offset] >> 4) & 0xf;
1492 		buf[1][offset] |= (buf[1][offset] >> 4) & 0xf;
1493 		break;
1494 	case V4L2_PIX_FMT_SBGGR16:
1495 		buf[0][offset] = buf[0][offset + 1] = odd ? g_u_s : b_v;
1496 		buf[1][offset] = buf[1][offset + 1] = odd ? r_y_h : g_u_s;
1497 		break;
1498 	case V4L2_PIX_FMT_SGBRG16:
1499 		buf[0][offset] = buf[0][offset + 1] = odd ? b_v : g_u_s;
1500 		buf[1][offset] = buf[1][offset + 1] = odd ? g_u_s : r_y_h;
1501 		break;
1502 	case V4L2_PIX_FMT_SGRBG16:
1503 		buf[0][offset] = buf[0][offset + 1] = odd ? r_y_h : g_u_s;
1504 		buf[1][offset] = buf[1][offset + 1] = odd ? g_u_s : b_v;
1505 		break;
1506 	case V4L2_PIX_FMT_SRGGB16:
1507 		buf[0][offset] = buf[0][offset + 1] = odd ? g_u_s : r_y_h;
1508 		buf[1][offset] = buf[1][offset + 1] = odd ? b_v : g_u_s;
1509 		break;
1510 	}
1511 }
1512 
1513 unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line)
1514 {
1515 	switch (tpg->fourcc) {
1516 	case V4L2_PIX_FMT_SBGGR8:
1517 	case V4L2_PIX_FMT_SGBRG8:
1518 	case V4L2_PIX_FMT_SGRBG8:
1519 	case V4L2_PIX_FMT_SRGGB8:
1520 	case V4L2_PIX_FMT_SBGGR10:
1521 	case V4L2_PIX_FMT_SGBRG10:
1522 	case V4L2_PIX_FMT_SGRBG10:
1523 	case V4L2_PIX_FMT_SRGGB10:
1524 	case V4L2_PIX_FMT_SBGGR12:
1525 	case V4L2_PIX_FMT_SGBRG12:
1526 	case V4L2_PIX_FMT_SGRBG12:
1527 	case V4L2_PIX_FMT_SRGGB12:
1528 	case V4L2_PIX_FMT_SBGGR16:
1529 	case V4L2_PIX_FMT_SGBRG16:
1530 	case V4L2_PIX_FMT_SGRBG16:
1531 	case V4L2_PIX_FMT_SRGGB16:
1532 		return buf_line & 1;
1533 	default:
1534 		return 0;
1535 	}
1536 }
1537 EXPORT_SYMBOL_GPL(tpg_g_interleaved_plane);
1538 
1539 /* Return how many pattern lines are used by the current pattern. */
1540 static unsigned tpg_get_pat_lines(const struct tpg_data *tpg)
1541 {
1542 	switch (tpg->pattern) {
1543 	case TPG_PAT_CHECKERS_16X16:
1544 	case TPG_PAT_CHECKERS_2X2:
1545 	case TPG_PAT_CHECKERS_1X1:
1546 	case TPG_PAT_COLOR_CHECKERS_2X2:
1547 	case TPG_PAT_COLOR_CHECKERS_1X1:
1548 	case TPG_PAT_ALTERNATING_HLINES:
1549 	case TPG_PAT_CROSS_1_PIXEL:
1550 	case TPG_PAT_CROSS_2_PIXELS:
1551 	case TPG_PAT_CROSS_10_PIXELS:
1552 		return 2;
1553 	case TPG_PAT_100_COLORSQUARES:
1554 	case TPG_PAT_100_HCOLORBAR:
1555 		return 8;
1556 	default:
1557 		return 1;
1558 	}
1559 }
1560 
1561 /* Which pattern line should be used for the given frame line. */
1562 static unsigned tpg_get_pat_line(const struct tpg_data *tpg, unsigned line)
1563 {
1564 	switch (tpg->pattern) {
1565 	case TPG_PAT_CHECKERS_16X16:
1566 		return (line >> 4) & 1;
1567 	case TPG_PAT_CHECKERS_1X1:
1568 	case TPG_PAT_COLOR_CHECKERS_1X1:
1569 	case TPG_PAT_ALTERNATING_HLINES:
1570 		return line & 1;
1571 	case TPG_PAT_CHECKERS_2X2:
1572 	case TPG_PAT_COLOR_CHECKERS_2X2:
1573 		return (line & 2) >> 1;
1574 	case TPG_PAT_100_COLORSQUARES:
1575 	case TPG_PAT_100_HCOLORBAR:
1576 		return (line * 8) / tpg->src_height;
1577 	case TPG_PAT_CROSS_1_PIXEL:
1578 		return line == tpg->src_height / 2;
1579 	case TPG_PAT_CROSS_2_PIXELS:
1580 		return (line + 1) / 2 == tpg->src_height / 4;
1581 	case TPG_PAT_CROSS_10_PIXELS:
1582 		return (line + 10) / 20 == tpg->src_height / 40;
1583 	default:
1584 		return 0;
1585 	}
1586 }
1587 
1588 /*
1589  * Which color should be used for the given pattern line and X coordinate.
1590  * Note: x is in the range 0 to 2 * tpg->src_width.
1591  */
1592 static enum tpg_color tpg_get_color(const struct tpg_data *tpg,
1593 				    unsigned pat_line, unsigned x)
1594 {
1595 	/* Maximum number of bars are TPG_COLOR_MAX - otherwise, the input print code
1596 	   should be modified */
1597 	static const enum tpg_color bars[3][8] = {
1598 		/* Standard ITU-R 75% color bar sequence */
1599 		{ TPG_COLOR_CSC_WHITE,   TPG_COLOR_75_YELLOW,
1600 		  TPG_COLOR_75_CYAN,     TPG_COLOR_75_GREEN,
1601 		  TPG_COLOR_75_MAGENTA,  TPG_COLOR_75_RED,
1602 		  TPG_COLOR_75_BLUE,     TPG_COLOR_100_BLACK, },
1603 		/* Standard ITU-R 100% color bar sequence */
1604 		{ TPG_COLOR_100_WHITE,   TPG_COLOR_100_YELLOW,
1605 		  TPG_COLOR_100_CYAN,    TPG_COLOR_100_GREEN,
1606 		  TPG_COLOR_100_MAGENTA, TPG_COLOR_100_RED,
1607 		  TPG_COLOR_100_BLUE,    TPG_COLOR_100_BLACK, },
1608 		/* Color bar sequence suitable to test CSC */
1609 		{ TPG_COLOR_CSC_WHITE,   TPG_COLOR_CSC_YELLOW,
1610 		  TPG_COLOR_CSC_CYAN,    TPG_COLOR_CSC_GREEN,
1611 		  TPG_COLOR_CSC_MAGENTA, TPG_COLOR_CSC_RED,
1612 		  TPG_COLOR_CSC_BLUE,    TPG_COLOR_CSC_BLACK, },
1613 	};
1614 
1615 	switch (tpg->pattern) {
1616 	case TPG_PAT_75_COLORBAR:
1617 	case TPG_PAT_100_COLORBAR:
1618 	case TPG_PAT_CSC_COLORBAR:
1619 		return bars[tpg->pattern][((x * 8) / tpg->src_width) % 8];
1620 	case TPG_PAT_100_COLORSQUARES:
1621 		return bars[1][(pat_line + (x * 8) / tpg->src_width) % 8];
1622 	case TPG_PAT_100_HCOLORBAR:
1623 		return bars[1][pat_line];
1624 	case TPG_PAT_BLACK:
1625 		return TPG_COLOR_100_BLACK;
1626 	case TPG_PAT_WHITE:
1627 		return TPG_COLOR_100_WHITE;
1628 	case TPG_PAT_RED:
1629 		return TPG_COLOR_100_RED;
1630 	case TPG_PAT_GREEN:
1631 		return TPG_COLOR_100_GREEN;
1632 	case TPG_PAT_BLUE:
1633 		return TPG_COLOR_100_BLUE;
1634 	case TPG_PAT_CHECKERS_16X16:
1635 		return (((x >> 4) & 1) ^ (pat_line & 1)) ?
1636 			TPG_COLOR_100_BLACK : TPG_COLOR_100_WHITE;
1637 	case TPG_PAT_CHECKERS_1X1:
1638 		return ((x & 1) ^ (pat_line & 1)) ?
1639 			TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1640 	case TPG_PAT_COLOR_CHECKERS_1X1:
1641 		return ((x & 1) ^ (pat_line & 1)) ?
1642 			TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1643 	case TPG_PAT_CHECKERS_2X2:
1644 		return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1645 			TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1646 	case TPG_PAT_COLOR_CHECKERS_2X2:
1647 		return (((x >> 1) & 1) ^ (pat_line & 1)) ?
1648 			TPG_COLOR_100_RED : TPG_COLOR_100_BLUE;
1649 	case TPG_PAT_ALTERNATING_HLINES:
1650 		return pat_line ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1651 	case TPG_PAT_ALTERNATING_VLINES:
1652 		return (x & 1) ? TPG_COLOR_100_WHITE : TPG_COLOR_100_BLACK;
1653 	case TPG_PAT_CROSS_1_PIXEL:
1654 		if (pat_line || (x % tpg->src_width) == tpg->src_width / 2)
1655 			return TPG_COLOR_100_BLACK;
1656 		return TPG_COLOR_100_WHITE;
1657 	case TPG_PAT_CROSS_2_PIXELS:
1658 		if (pat_line || ((x % tpg->src_width) + 1) / 2 == tpg->src_width / 4)
1659 			return TPG_COLOR_100_BLACK;
1660 		return TPG_COLOR_100_WHITE;
1661 	case TPG_PAT_CROSS_10_PIXELS:
1662 		if (pat_line || ((x % tpg->src_width) + 10) / 20 == tpg->src_width / 40)
1663 			return TPG_COLOR_100_BLACK;
1664 		return TPG_COLOR_100_WHITE;
1665 	case TPG_PAT_GRAY_RAMP:
1666 		return TPG_COLOR_RAMP + ((x % tpg->src_width) * 256) / tpg->src_width;
1667 	default:
1668 		return TPG_COLOR_100_RED;
1669 	}
1670 }
1671 
1672 /*
1673  * Given the pixel aspect ratio and video aspect ratio calculate the
1674  * coordinates of a centered square and the coordinates of the border of
1675  * the active video area. The coordinates are relative to the source
1676  * frame rectangle.
1677  */
1678 static void tpg_calculate_square_border(struct tpg_data *tpg)
1679 {
1680 	unsigned w = tpg->src_width;
1681 	unsigned h = tpg->src_height;
1682 	unsigned sq_w, sq_h;
1683 
1684 	sq_w = (w * 2 / 5) & ~1;
1685 	if (((w - sq_w) / 2) & 1)
1686 		sq_w += 2;
1687 	sq_h = sq_w;
1688 	tpg->square.width = sq_w;
1689 	if (tpg->vid_aspect == TPG_VIDEO_ASPECT_16X9_ANAMORPHIC) {
1690 		unsigned ana_sq_w = (sq_w / 4) * 3;
1691 
1692 		if (((w - ana_sq_w) / 2) & 1)
1693 			ana_sq_w += 2;
1694 		tpg->square.width = ana_sq_w;
1695 	}
1696 	tpg->square.left = (w - tpg->square.width) / 2;
1697 	if (tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC)
1698 		sq_h = sq_w * 10 / 11;
1699 	else if (tpg->pix_aspect == TPG_PIXEL_ASPECT_PAL)
1700 		sq_h = sq_w * 59 / 54;
1701 	tpg->square.height = sq_h;
1702 	tpg->square.top = (h - sq_h) / 2;
1703 	tpg->border.left = 0;
1704 	tpg->border.width = w;
1705 	tpg->border.top = 0;
1706 	tpg->border.height = h;
1707 	switch (tpg->vid_aspect) {
1708 	case TPG_VIDEO_ASPECT_4X3:
1709 		if (tpg->pix_aspect)
1710 			return;
1711 		if (3 * w >= 4 * h) {
1712 			tpg->border.width = ((4 * h) / 3) & ~1;
1713 			if (((w - tpg->border.width) / 2) & ~1)
1714 				tpg->border.width -= 2;
1715 			tpg->border.left = (w - tpg->border.width) / 2;
1716 			break;
1717 		}
1718 		tpg->border.height = ((3 * w) / 4) & ~1;
1719 		tpg->border.top = (h - tpg->border.height) / 2;
1720 		break;
1721 	case TPG_VIDEO_ASPECT_14X9_CENTRE:
1722 		if (tpg->pix_aspect) {
1723 			tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 420 : 506;
1724 			tpg->border.top = (h - tpg->border.height) / 2;
1725 			break;
1726 		}
1727 		if (9 * w >= 14 * h) {
1728 			tpg->border.width = ((14 * h) / 9) & ~1;
1729 			if (((w - tpg->border.width) / 2) & ~1)
1730 				tpg->border.width -= 2;
1731 			tpg->border.left = (w - tpg->border.width) / 2;
1732 			break;
1733 		}
1734 		tpg->border.height = ((9 * w) / 14) & ~1;
1735 		tpg->border.top = (h - tpg->border.height) / 2;
1736 		break;
1737 	case TPG_VIDEO_ASPECT_16X9_CENTRE:
1738 		if (tpg->pix_aspect) {
1739 			tpg->border.height = tpg->pix_aspect == TPG_PIXEL_ASPECT_NTSC ? 368 : 442;
1740 			tpg->border.top = (h - tpg->border.height) / 2;
1741 			break;
1742 		}
1743 		if (9 * w >= 16 * h) {
1744 			tpg->border.width = ((16 * h) / 9) & ~1;
1745 			if (((w - tpg->border.width) / 2) & ~1)
1746 				tpg->border.width -= 2;
1747 			tpg->border.left = (w - tpg->border.width) / 2;
1748 			break;
1749 		}
1750 		tpg->border.height = ((9 * w) / 16) & ~1;
1751 		tpg->border.top = (h - tpg->border.height) / 2;
1752 		break;
1753 	default:
1754 		break;
1755 	}
1756 }
1757 
1758 static void tpg_precalculate_line(struct tpg_data *tpg)
1759 {
1760 	enum tpg_color contrast;
1761 	u8 pix[TPG_MAX_PLANES][8];
1762 	unsigned pat;
1763 	unsigned p;
1764 	unsigned x;
1765 
1766 	switch (tpg->pattern) {
1767 	case TPG_PAT_GREEN:
1768 		contrast = TPG_COLOR_100_RED;
1769 		break;
1770 	case TPG_PAT_CSC_COLORBAR:
1771 		contrast = TPG_COLOR_CSC_GREEN;
1772 		break;
1773 	default:
1774 		contrast = TPG_COLOR_100_GREEN;
1775 		break;
1776 	}
1777 
1778 	for (pat = 0; pat < tpg_get_pat_lines(tpg); pat++) {
1779 		/* Coarse scaling with Bresenham */
1780 		unsigned int_part = tpg->src_width / tpg->scaled_width;
1781 		unsigned fract_part = tpg->src_width % tpg->scaled_width;
1782 		unsigned src_x = 0;
1783 		unsigned error = 0;
1784 
1785 		for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1786 			unsigned real_x = src_x;
1787 			enum tpg_color color1, color2;
1788 
1789 			real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1790 			color1 = tpg_get_color(tpg, pat, real_x);
1791 
1792 			src_x += int_part;
1793 			error += fract_part;
1794 			if (error >= tpg->scaled_width) {
1795 				error -= tpg->scaled_width;
1796 				src_x++;
1797 			}
1798 
1799 			real_x = src_x;
1800 			real_x = tpg->hflip ? tpg->src_width * 2 - real_x - 2 : real_x;
1801 			color2 = tpg_get_color(tpg, pat, real_x);
1802 
1803 			src_x += int_part;
1804 			error += fract_part;
1805 			if (error >= tpg->scaled_width) {
1806 				error -= tpg->scaled_width;
1807 				src_x++;
1808 			}
1809 
1810 			gen_twopix(tpg, pix, tpg->hflip ? color2 : color1, 0);
1811 			gen_twopix(tpg, pix, tpg->hflip ? color1 : color2, 1);
1812 			for (p = 0; p < tpg->planes; p++) {
1813 				unsigned twopixsize = tpg->twopixelsize[p];
1814 				unsigned hdiv = tpg->hdownsampling[p];
1815 				u8 *pos = tpg->lines[pat][p] + tpg_hdiv(tpg, p, x);
1816 
1817 				memcpy(pos, pix[p], twopixsize / hdiv);
1818 			}
1819 		}
1820 	}
1821 
1822 	if (tpg->vdownsampling[tpg->planes - 1] > 1) {
1823 		unsigned pat_lines = tpg_get_pat_lines(tpg);
1824 
1825 		for (pat = 0; pat < pat_lines; pat++) {
1826 			unsigned next_pat = (pat + 1) % pat_lines;
1827 
1828 			for (p = 1; p < tpg->planes; p++) {
1829 				unsigned w = tpg_hdiv(tpg, p, tpg->scaled_width * 2);
1830 				u8 *pos1 = tpg->lines[pat][p];
1831 				u8 *pos2 = tpg->lines[next_pat][p];
1832 				u8 *dest = tpg->downsampled_lines[pat][p];
1833 
1834 				for (x = 0; x < w; x++, pos1++, pos2++, dest++)
1835 					*dest = ((u16)*pos1 + (u16)*pos2) / 2;
1836 			}
1837 		}
1838 	}
1839 
1840 	gen_twopix(tpg, pix, contrast, 0);
1841 	gen_twopix(tpg, pix, contrast, 1);
1842 	for (p = 0; p < tpg->planes; p++) {
1843 		unsigned twopixsize = tpg->twopixelsize[p];
1844 		u8 *pos = tpg->contrast_line[p];
1845 
1846 		for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1847 			memcpy(pos, pix[p], twopixsize);
1848 	}
1849 
1850 	gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 0);
1851 	gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 1);
1852 	for (p = 0; p < tpg->planes; p++) {
1853 		unsigned twopixsize = tpg->twopixelsize[p];
1854 		u8 *pos = tpg->black_line[p];
1855 
1856 		for (x = 0; x < tpg->scaled_width; x += 2, pos += twopixsize)
1857 			memcpy(pos, pix[p], twopixsize);
1858 	}
1859 
1860 	for (x = 0; x < tpg->scaled_width * 2; x += 2) {
1861 		gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 0);
1862 		gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 1);
1863 		for (p = 0; p < tpg->planes; p++) {
1864 			unsigned twopixsize = tpg->twopixelsize[p];
1865 			u8 *pos = tpg->random_line[p] + x * twopixsize / 2;
1866 
1867 			memcpy(pos, pix[p], twopixsize);
1868 		}
1869 	}
1870 
1871 	gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 0);
1872 	gen_twopix(tpg, tpg->textbg, TPG_COLOR_TEXTBG, 1);
1873 	gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 0);
1874 	gen_twopix(tpg, tpg->textfg, TPG_COLOR_TEXTFG, 1);
1875 }
1876 
1877 /* need this to do rgb24 rendering */
1878 typedef struct { u16 __; u8 _; } __packed x24;
1879 
1880 #define PRINTSTR(PIXTYPE) do {	\
1881 	unsigned vdiv = tpg->vdownsampling[p]; \
1882 	unsigned hdiv = tpg->hdownsampling[p]; \
1883 	int line;	\
1884 	PIXTYPE fg;	\
1885 	PIXTYPE bg;	\
1886 	memcpy(&fg, tpg->textfg[p], sizeof(PIXTYPE));	\
1887 	memcpy(&bg, tpg->textbg[p], sizeof(PIXTYPE));	\
1888 	\
1889 	for (line = first; line < 16; line += vdiv * step) {	\
1890 		int l = tpg->vflip ? 15 - line : line; \
1891 		PIXTYPE *pos = (PIXTYPE *)(basep[p][(line / vdiv) & 1] + \
1892 			       ((y * step + l) / (vdiv * div)) * tpg->bytesperline[p] + \
1893 			       (x / hdiv) * sizeof(PIXTYPE));	\
1894 		unsigned s;	\
1895 	\
1896 		for (s = 0; s < len; s++) {	\
1897 			u8 chr = font8x16[(u8)text[s] * 16 + line];	\
1898 	\
1899 			if (hdiv == 2 && tpg->hflip) { \
1900 				pos[3] = (chr & (0x01 << 6) ? fg : bg);	\
1901 				pos[2] = (chr & (0x01 << 4) ? fg : bg);	\
1902 				pos[1] = (chr & (0x01 << 2) ? fg : bg);	\
1903 				pos[0] = (chr & (0x01 << 0) ? fg : bg);	\
1904 			} else if (hdiv == 2) { \
1905 				pos[0] = (chr & (0x01 << 7) ? fg : bg);	\
1906 				pos[1] = (chr & (0x01 << 5) ? fg : bg);	\
1907 				pos[2] = (chr & (0x01 << 3) ? fg : bg);	\
1908 				pos[3] = (chr & (0x01 << 1) ? fg : bg);	\
1909 			} else if (tpg->hflip) { \
1910 				pos[7] = (chr & (0x01 << 7) ? fg : bg);	\
1911 				pos[6] = (chr & (0x01 << 6) ? fg : bg);	\
1912 				pos[5] = (chr & (0x01 << 5) ? fg : bg);	\
1913 				pos[4] = (chr & (0x01 << 4) ? fg : bg);	\
1914 				pos[3] = (chr & (0x01 << 3) ? fg : bg);	\
1915 				pos[2] = (chr & (0x01 << 2) ? fg : bg);	\
1916 				pos[1] = (chr & (0x01 << 1) ? fg : bg);	\
1917 				pos[0] = (chr & (0x01 << 0) ? fg : bg);	\
1918 			} else { \
1919 				pos[0] = (chr & (0x01 << 7) ? fg : bg);	\
1920 				pos[1] = (chr & (0x01 << 6) ? fg : bg);	\
1921 				pos[2] = (chr & (0x01 << 5) ? fg : bg);	\
1922 				pos[3] = (chr & (0x01 << 4) ? fg : bg);	\
1923 				pos[4] = (chr & (0x01 << 3) ? fg : bg);	\
1924 				pos[5] = (chr & (0x01 << 2) ? fg : bg);	\
1925 				pos[6] = (chr & (0x01 << 1) ? fg : bg);	\
1926 				pos[7] = (chr & (0x01 << 0) ? fg : bg);	\
1927 			} \
1928 	\
1929 			pos += (tpg->hflip ? -8 : 8) / (int)hdiv;	\
1930 		}	\
1931 	}	\
1932 } while (0)
1933 
1934 static noinline void tpg_print_str_2(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1935 			unsigned p, unsigned first, unsigned div, unsigned step,
1936 			int y, int x, const char *text, unsigned len)
1937 {
1938 	PRINTSTR(u8);
1939 }
1940 
1941 static noinline void tpg_print_str_4(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1942 			unsigned p, unsigned first, unsigned div, unsigned step,
1943 			int y, int x, const char *text, unsigned len)
1944 {
1945 	PRINTSTR(u16);
1946 }
1947 
1948 static noinline void tpg_print_str_6(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1949 			unsigned p, unsigned first, unsigned div, unsigned step,
1950 			int y, int x, const char *text, unsigned len)
1951 {
1952 	PRINTSTR(x24);
1953 }
1954 
1955 static noinline void tpg_print_str_8(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1956 			unsigned p, unsigned first, unsigned div, unsigned step,
1957 			int y, int x, const char *text, unsigned len)
1958 {
1959 	PRINTSTR(u32);
1960 }
1961 
1962 void tpg_gen_text(const struct tpg_data *tpg, u8 *basep[TPG_MAX_PLANES][2],
1963 		  int y, int x, const char *text)
1964 {
1965 	unsigned step = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
1966 	unsigned div = step;
1967 	unsigned first = 0;
1968 	unsigned len;
1969 	unsigned p;
1970 
1971 	if (font8x16 == NULL || basep == NULL || text == NULL)
1972 		return;
1973 
1974 	len = strlen(text);
1975 
1976 	/* Checks if it is possible to show string */
1977 	if (y + 16 >= tpg->compose.height || x + 8 >= tpg->compose.width)
1978 		return;
1979 
1980 	if (len > (tpg->compose.width - x) / 8)
1981 		len = (tpg->compose.width - x) / 8;
1982 	if (tpg->vflip)
1983 		y = tpg->compose.height - y - 16;
1984 	if (tpg->hflip)
1985 		x = tpg->compose.width - x - 8;
1986 	y += tpg->compose.top;
1987 	x += tpg->compose.left;
1988 	if (tpg->field == V4L2_FIELD_BOTTOM)
1989 		first = 1;
1990 	else if (tpg->field == V4L2_FIELD_SEQ_TB || tpg->field == V4L2_FIELD_SEQ_BT)
1991 		div = 2;
1992 
1993 	for (p = 0; p < tpg->planes; p++) {
1994 		/* Print text */
1995 		switch (tpg->twopixelsize[p]) {
1996 		case 2:
1997 			tpg_print_str_2(tpg, basep, p, first, div, step, y, x,
1998 					text, len);
1999 			break;
2000 		case 4:
2001 			tpg_print_str_4(tpg, basep, p, first, div, step, y, x,
2002 					text, len);
2003 			break;
2004 		case 6:
2005 			tpg_print_str_6(tpg, basep, p, first, div, step, y, x,
2006 					text, len);
2007 			break;
2008 		case 8:
2009 			tpg_print_str_8(tpg, basep, p, first, div, step, y, x,
2010 					text, len);
2011 			break;
2012 		}
2013 	}
2014 }
2015 EXPORT_SYMBOL_GPL(tpg_gen_text);
2016 
2017 const char *tpg_g_color_order(const struct tpg_data *tpg)
2018 {
2019 	switch (tpg->pattern) {
2020 	case TPG_PAT_75_COLORBAR:
2021 	case TPG_PAT_100_COLORBAR:
2022 	case TPG_PAT_CSC_COLORBAR:
2023 	case TPG_PAT_100_HCOLORBAR:
2024 		return "White, yellow, cyan, green, magenta, red, blue, black";
2025 	case TPG_PAT_BLACK:
2026 		return "Black";
2027 	case TPG_PAT_WHITE:
2028 		return "White";
2029 	case TPG_PAT_RED:
2030 		return "Red";
2031 	case TPG_PAT_GREEN:
2032 		return "Green";
2033 	case TPG_PAT_BLUE:
2034 		return "Blue";
2035 	default:
2036 		return NULL;
2037 	}
2038 }
2039 EXPORT_SYMBOL_GPL(tpg_g_color_order);
2040 
2041 void tpg_update_mv_step(struct tpg_data *tpg)
2042 {
2043 	int factor = tpg->mv_hor_mode > TPG_MOVE_NONE ? -1 : 1;
2044 
2045 	if (tpg->hflip)
2046 		factor = -factor;
2047 	switch (tpg->mv_hor_mode) {
2048 	case TPG_MOVE_NEG_FAST:
2049 	case TPG_MOVE_POS_FAST:
2050 		tpg->mv_hor_step = ((tpg->src_width + 319) / 320) * 4;
2051 		break;
2052 	case TPG_MOVE_NEG:
2053 	case TPG_MOVE_POS:
2054 		tpg->mv_hor_step = ((tpg->src_width + 639) / 640) * 4;
2055 		break;
2056 	case TPG_MOVE_NEG_SLOW:
2057 	case TPG_MOVE_POS_SLOW:
2058 		tpg->mv_hor_step = 2;
2059 		break;
2060 	case TPG_MOVE_NONE:
2061 		tpg->mv_hor_step = 0;
2062 		break;
2063 	}
2064 	if (factor < 0)
2065 		tpg->mv_hor_step = tpg->src_width - tpg->mv_hor_step;
2066 
2067 	factor = tpg->mv_vert_mode > TPG_MOVE_NONE ? -1 : 1;
2068 	switch (tpg->mv_vert_mode) {
2069 	case TPG_MOVE_NEG_FAST:
2070 	case TPG_MOVE_POS_FAST:
2071 		tpg->mv_vert_step = ((tpg->src_width + 319) / 320) * 4;
2072 		break;
2073 	case TPG_MOVE_NEG:
2074 	case TPG_MOVE_POS:
2075 		tpg->mv_vert_step = ((tpg->src_width + 639) / 640) * 4;
2076 		break;
2077 	case TPG_MOVE_NEG_SLOW:
2078 	case TPG_MOVE_POS_SLOW:
2079 		tpg->mv_vert_step = 1;
2080 		break;
2081 	case TPG_MOVE_NONE:
2082 		tpg->mv_vert_step = 0;
2083 		break;
2084 	}
2085 	if (factor < 0)
2086 		tpg->mv_vert_step = tpg->src_height - tpg->mv_vert_step;
2087 }
2088 EXPORT_SYMBOL_GPL(tpg_update_mv_step);
2089 
2090 /* Map the line number relative to the crop rectangle to a frame line number */
2091 static unsigned tpg_calc_frameline(const struct tpg_data *tpg, unsigned src_y,
2092 				    unsigned field)
2093 {
2094 	switch (field) {
2095 	case V4L2_FIELD_TOP:
2096 		return tpg->crop.top + src_y * 2;
2097 	case V4L2_FIELD_BOTTOM:
2098 		return tpg->crop.top + src_y * 2 + 1;
2099 	default:
2100 		return src_y + tpg->crop.top;
2101 	}
2102 }
2103 
2104 /*
2105  * Map the line number relative to the compose rectangle to a destination
2106  * buffer line number.
2107  */
2108 static unsigned tpg_calc_buffer_line(const struct tpg_data *tpg, unsigned y,
2109 				    unsigned field)
2110 {
2111 	y += tpg->compose.top;
2112 	switch (field) {
2113 	case V4L2_FIELD_SEQ_TB:
2114 		if (y & 1)
2115 			return tpg->buf_height / 2 + y / 2;
2116 		return y / 2;
2117 	case V4L2_FIELD_SEQ_BT:
2118 		if (y & 1)
2119 			return y / 2;
2120 		return tpg->buf_height / 2 + y / 2;
2121 	default:
2122 		return y;
2123 	}
2124 }
2125 
2126 static void tpg_recalc(struct tpg_data *tpg)
2127 {
2128 	if (tpg->recalc_colors) {
2129 		tpg->recalc_colors = false;
2130 		tpg->recalc_lines = true;
2131 		tpg->real_xfer_func = tpg->xfer_func;
2132 		tpg->real_ycbcr_enc = tpg->ycbcr_enc;
2133 		tpg->real_hsv_enc = tpg->hsv_enc;
2134 		tpg->real_quantization = tpg->quantization;
2135 
2136 		if (tpg->xfer_func == V4L2_XFER_FUNC_DEFAULT)
2137 			tpg->real_xfer_func =
2138 				V4L2_MAP_XFER_FUNC_DEFAULT(tpg->colorspace);
2139 
2140 		if (tpg->ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT)
2141 			tpg->real_ycbcr_enc =
2142 				V4L2_MAP_YCBCR_ENC_DEFAULT(tpg->colorspace);
2143 
2144 		if (tpg->quantization == V4L2_QUANTIZATION_DEFAULT)
2145 			tpg->real_quantization =
2146 				V4L2_MAP_QUANTIZATION_DEFAULT(
2147 					tpg->color_enc != TGP_COLOR_ENC_YCBCR,
2148 					tpg->colorspace, tpg->real_ycbcr_enc);
2149 
2150 		tpg_precalculate_colors(tpg);
2151 	}
2152 	if (tpg->recalc_square_border) {
2153 		tpg->recalc_square_border = false;
2154 		tpg_calculate_square_border(tpg);
2155 	}
2156 	if (tpg->recalc_lines) {
2157 		tpg->recalc_lines = false;
2158 		tpg_precalculate_line(tpg);
2159 	}
2160 }
2161 
2162 void tpg_calc_text_basep(struct tpg_data *tpg,
2163 		u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf)
2164 {
2165 	unsigned stride = tpg->bytesperline[p];
2166 	unsigned h = tpg->buf_height;
2167 
2168 	tpg_recalc(tpg);
2169 
2170 	basep[p][0] = vbuf;
2171 	basep[p][1] = vbuf;
2172 	h /= tpg->vdownsampling[p];
2173 	if (tpg->field == V4L2_FIELD_SEQ_TB)
2174 		basep[p][1] += h * stride / 2;
2175 	else if (tpg->field == V4L2_FIELD_SEQ_BT)
2176 		basep[p][0] += h * stride / 2;
2177 	if (p == 0 && tpg->interleaved)
2178 		tpg_calc_text_basep(tpg, basep, 1, vbuf);
2179 }
2180 EXPORT_SYMBOL_GPL(tpg_calc_text_basep);
2181 
2182 static int tpg_pattern_avg(const struct tpg_data *tpg,
2183 			   unsigned pat1, unsigned pat2)
2184 {
2185 	unsigned pat_lines = tpg_get_pat_lines(tpg);
2186 
2187 	if (pat1 == (pat2 + 1) % pat_lines)
2188 		return pat2;
2189 	if (pat2 == (pat1 + 1) % pat_lines)
2190 		return pat1;
2191 	return -1;
2192 }
2193 
2194 static const char *tpg_color_enc_str(enum tgp_color_enc
2195 						 color_enc)
2196 {
2197 	switch (color_enc) {
2198 	case TGP_COLOR_ENC_HSV:
2199 		return "HSV";
2200 	case TGP_COLOR_ENC_YCBCR:
2201 		return "Y'CbCr";
2202 	case TGP_COLOR_ENC_LUMA:
2203 		return "Luma";
2204 	case TGP_COLOR_ENC_RGB:
2205 	default:
2206 		return "R'G'B";
2207 
2208 	}
2209 }
2210 
2211 void tpg_log_status(struct tpg_data *tpg)
2212 {
2213 	pr_info("tpg source WxH: %ux%u (%s)\n",
2214 		tpg->src_width, tpg->src_height,
2215 		tpg_color_enc_str(tpg->color_enc));
2216 	pr_info("tpg field: %u\n", tpg->field);
2217 	pr_info("tpg crop: %ux%u@%dx%d\n", tpg->crop.width, tpg->crop.height,
2218 			tpg->crop.left, tpg->crop.top);
2219 	pr_info("tpg compose: %ux%u@%dx%d\n", tpg->compose.width, tpg->compose.height,
2220 			tpg->compose.left, tpg->compose.top);
2221 	pr_info("tpg colorspace: %d\n", tpg->colorspace);
2222 	pr_info("tpg transfer function: %d/%d\n", tpg->xfer_func, tpg->real_xfer_func);
2223 	if (tpg->color_enc == TGP_COLOR_ENC_HSV)
2224 		pr_info("tpg HSV encoding: %d/%d\n",
2225 			tpg->hsv_enc, tpg->real_hsv_enc);
2226 	else if (tpg->color_enc == TGP_COLOR_ENC_YCBCR)
2227 		pr_info("tpg Y'CbCr encoding: %d/%d\n",
2228 			tpg->ycbcr_enc, tpg->real_ycbcr_enc);
2229 	pr_info("tpg quantization: %d/%d\n", tpg->quantization, tpg->real_quantization);
2230 	pr_info("tpg RGB range: %d/%d\n", tpg->rgb_range, tpg->real_rgb_range);
2231 }
2232 EXPORT_SYMBOL_GPL(tpg_log_status);
2233 
2234 /*
2235  * This struct contains common parameters used by both the drawing of the
2236  * test pattern and the drawing of the extras (borders, square, etc.)
2237  */
2238 struct tpg_draw_params {
2239 	/* common data */
2240 	bool is_tv;
2241 	bool is_60hz;
2242 	unsigned twopixsize;
2243 	unsigned img_width;
2244 	unsigned stride;
2245 	unsigned hmax;
2246 	unsigned frame_line;
2247 	unsigned frame_line_next;
2248 
2249 	/* test pattern */
2250 	unsigned mv_hor_old;
2251 	unsigned mv_hor_new;
2252 	unsigned mv_vert_old;
2253 	unsigned mv_vert_new;
2254 
2255 	/* extras */
2256 	unsigned wss_width;
2257 	unsigned wss_random_offset;
2258 	unsigned sav_eav_f;
2259 	unsigned left_pillar_width;
2260 	unsigned right_pillar_start;
2261 };
2262 
2263 static void tpg_fill_params_pattern(const struct tpg_data *tpg, unsigned p,
2264 				    struct tpg_draw_params *params)
2265 {
2266 	params->mv_hor_old =
2267 		tpg_hscale_div(tpg, p, tpg->mv_hor_count % tpg->src_width);
2268 	params->mv_hor_new =
2269 		tpg_hscale_div(tpg, p, (tpg->mv_hor_count + tpg->mv_hor_step) %
2270 			       tpg->src_width);
2271 	params->mv_vert_old = tpg->mv_vert_count % tpg->src_height;
2272 	params->mv_vert_new =
2273 		(tpg->mv_vert_count + tpg->mv_vert_step) % tpg->src_height;
2274 }
2275 
2276 static void tpg_fill_params_extras(const struct tpg_data *tpg,
2277 				   unsigned p,
2278 				   struct tpg_draw_params *params)
2279 {
2280 	unsigned left_pillar_width = 0;
2281 	unsigned right_pillar_start = params->img_width;
2282 
2283 	params->wss_width = tpg->crop.left < tpg->src_width / 2 ?
2284 		tpg->src_width / 2 - tpg->crop.left : 0;
2285 	if (params->wss_width > tpg->crop.width)
2286 		params->wss_width = tpg->crop.width;
2287 	params->wss_width = tpg_hscale_div(tpg, p, params->wss_width);
2288 	params->wss_random_offset =
2289 		params->twopixsize * prandom_u32_max(tpg->src_width / 2);
2290 
2291 	if (tpg->crop.left < tpg->border.left) {
2292 		left_pillar_width = tpg->border.left - tpg->crop.left;
2293 		if (left_pillar_width > tpg->crop.width)
2294 			left_pillar_width = tpg->crop.width;
2295 		left_pillar_width = tpg_hscale_div(tpg, p, left_pillar_width);
2296 	}
2297 	params->left_pillar_width = left_pillar_width;
2298 
2299 	if (tpg->crop.left + tpg->crop.width >
2300 	    tpg->border.left + tpg->border.width) {
2301 		right_pillar_start =
2302 			tpg->border.left + tpg->border.width - tpg->crop.left;
2303 		right_pillar_start =
2304 			tpg_hscale_div(tpg, p, right_pillar_start);
2305 		if (right_pillar_start > params->img_width)
2306 			right_pillar_start = params->img_width;
2307 	}
2308 	params->right_pillar_start = right_pillar_start;
2309 
2310 	params->sav_eav_f = tpg->field ==
2311 			(params->is_60hz ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2312 }
2313 
2314 static void tpg_fill_plane_extras(const struct tpg_data *tpg,
2315 				  const struct tpg_draw_params *params,
2316 				  unsigned p, unsigned h, u8 *vbuf)
2317 {
2318 	unsigned twopixsize = params->twopixsize;
2319 	unsigned img_width = params->img_width;
2320 	unsigned frame_line = params->frame_line;
2321 	const struct v4l2_rect *sq = &tpg->square;
2322 	const struct v4l2_rect *b = &tpg->border;
2323 	const struct v4l2_rect *c = &tpg->crop;
2324 
2325 	if (params->is_tv && !params->is_60hz &&
2326 	    frame_line == 0 && params->wss_width) {
2327 		/*
2328 		 * Replace the first half of the top line of a 50 Hz frame
2329 		 * with random data to simulate a WSS signal.
2330 		 */
2331 		u8 *wss = tpg->random_line[p] + params->wss_random_offset;
2332 
2333 		memcpy(vbuf, wss, params->wss_width);
2334 	}
2335 
2336 	if (tpg->show_border && frame_line >= b->top &&
2337 	    frame_line < b->top + b->height) {
2338 		unsigned bottom = b->top + b->height - 1;
2339 		unsigned left = params->left_pillar_width;
2340 		unsigned right = params->right_pillar_start;
2341 
2342 		if (frame_line == b->top || frame_line == b->top + 1 ||
2343 		    frame_line == bottom || frame_line == bottom - 1) {
2344 			memcpy(vbuf + left, tpg->contrast_line[p],
2345 					right - left);
2346 		} else {
2347 			if (b->left >= c->left &&
2348 			    b->left < c->left + c->width)
2349 				memcpy(vbuf + left,
2350 					tpg->contrast_line[p], twopixsize);
2351 			if (b->left + b->width > c->left &&
2352 			    b->left + b->width <= c->left + c->width)
2353 				memcpy(vbuf + right - twopixsize,
2354 					tpg->contrast_line[p], twopixsize);
2355 		}
2356 	}
2357 	if (tpg->qual != TPG_QUAL_NOISE && frame_line >= b->top &&
2358 	    frame_line < b->top + b->height) {
2359 		memcpy(vbuf, tpg->black_line[p], params->left_pillar_width);
2360 		memcpy(vbuf + params->right_pillar_start, tpg->black_line[p],
2361 		       img_width - params->right_pillar_start);
2362 	}
2363 	if (tpg->show_square && frame_line >= sq->top &&
2364 	    frame_line < sq->top + sq->height &&
2365 	    sq->left < c->left + c->width &&
2366 	    sq->left + sq->width >= c->left) {
2367 		unsigned left = sq->left;
2368 		unsigned width = sq->width;
2369 
2370 		if (c->left > left) {
2371 			width -= c->left - left;
2372 			left = c->left;
2373 		}
2374 		if (c->left + c->width < left + width)
2375 			width -= left + width - c->left - c->width;
2376 		left -= c->left;
2377 		left = tpg_hscale_div(tpg, p, left);
2378 		width = tpg_hscale_div(tpg, p, width);
2379 		memcpy(vbuf + left, tpg->contrast_line[p], width);
2380 	}
2381 	if (tpg->insert_sav) {
2382 		unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width / 3);
2383 		u8 *p = vbuf + offset;
2384 		unsigned vact = 0, hact = 0;
2385 
2386 		p[0] = 0xff;
2387 		p[1] = 0;
2388 		p[2] = 0;
2389 		p[3] = 0x80 | (params->sav_eav_f << 6) |
2390 			(vact << 5) | (hact << 4) |
2391 			((hact ^ vact) << 3) |
2392 			((hact ^ params->sav_eav_f) << 2) |
2393 			((params->sav_eav_f ^ vact) << 1) |
2394 			(hact ^ vact ^ params->sav_eav_f);
2395 	}
2396 	if (tpg->insert_eav) {
2397 		unsigned offset = tpg_hdiv(tpg, p, tpg->compose.width * 2 / 3);
2398 		u8 *p = vbuf + offset;
2399 		unsigned vact = 0, hact = 1;
2400 
2401 		p[0] = 0xff;
2402 		p[1] = 0;
2403 		p[2] = 0;
2404 		p[3] = 0x80 | (params->sav_eav_f << 6) |
2405 			(vact << 5) | (hact << 4) |
2406 			((hact ^ vact) << 3) |
2407 			((hact ^ params->sav_eav_f) << 2) |
2408 			((params->sav_eav_f ^ vact) << 1) |
2409 			(hact ^ vact ^ params->sav_eav_f);
2410 	}
2411 	if (tpg->insert_hdmi_video_guard_band) {
2412 		unsigned int i;
2413 
2414 		switch (tpg->fourcc) {
2415 		case V4L2_PIX_FMT_BGR24:
2416 		case V4L2_PIX_FMT_RGB24:
2417 			for (i = 0; i < 3 * 4; i += 3) {
2418 				vbuf[i] = 0xab;
2419 				vbuf[i + 1] = 0x55;
2420 				vbuf[i + 2] = 0xab;
2421 			}
2422 			break;
2423 		case V4L2_PIX_FMT_RGB32:
2424 		case V4L2_PIX_FMT_ARGB32:
2425 		case V4L2_PIX_FMT_XRGB32:
2426 		case V4L2_PIX_FMT_BGRX32:
2427 		case V4L2_PIX_FMT_BGRA32:
2428 			for (i = 0; i < 4 * 4; i += 4) {
2429 				vbuf[i] = 0x00;
2430 				vbuf[i + 1] = 0xab;
2431 				vbuf[i + 2] = 0x55;
2432 				vbuf[i + 3] = 0xab;
2433 			}
2434 			break;
2435 		case V4L2_PIX_FMT_BGR32:
2436 		case V4L2_PIX_FMT_XBGR32:
2437 		case V4L2_PIX_FMT_ABGR32:
2438 		case V4L2_PIX_FMT_RGBX32:
2439 		case V4L2_PIX_FMT_RGBA32:
2440 			for (i = 0; i < 4 * 4; i += 4) {
2441 				vbuf[i] = 0xab;
2442 				vbuf[i + 1] = 0x55;
2443 				vbuf[i + 2] = 0xab;
2444 				vbuf[i + 3] = 0x00;
2445 			}
2446 			break;
2447 		}
2448 	}
2449 }
2450 
2451 static void tpg_fill_plane_pattern(const struct tpg_data *tpg,
2452 				   const struct tpg_draw_params *params,
2453 				   unsigned p, unsigned h, u8 *vbuf)
2454 {
2455 	unsigned twopixsize = params->twopixsize;
2456 	unsigned img_width = params->img_width;
2457 	unsigned mv_hor_old = params->mv_hor_old;
2458 	unsigned mv_hor_new = params->mv_hor_new;
2459 	unsigned mv_vert_old = params->mv_vert_old;
2460 	unsigned mv_vert_new = params->mv_vert_new;
2461 	unsigned frame_line = params->frame_line;
2462 	unsigned frame_line_next = params->frame_line_next;
2463 	unsigned line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
2464 	bool even;
2465 	bool fill_blank = false;
2466 	unsigned pat_line_old;
2467 	unsigned pat_line_new;
2468 	u8 *linestart_older;
2469 	u8 *linestart_newer;
2470 	u8 *linestart_top;
2471 	u8 *linestart_bottom;
2472 
2473 	even = !(frame_line & 1);
2474 
2475 	if (h >= params->hmax) {
2476 		if (params->hmax == tpg->compose.height)
2477 			return;
2478 		if (!tpg->perc_fill_blank)
2479 			return;
2480 		fill_blank = true;
2481 	}
2482 
2483 	if (tpg->vflip) {
2484 		frame_line = tpg->src_height - frame_line - 1;
2485 		frame_line_next = tpg->src_height - frame_line_next - 1;
2486 	}
2487 
2488 	if (fill_blank) {
2489 		linestart_older = tpg->contrast_line[p];
2490 		linestart_newer = tpg->contrast_line[p];
2491 	} else if (tpg->qual != TPG_QUAL_NOISE &&
2492 		   (frame_line < tpg->border.top ||
2493 		    frame_line >= tpg->border.top + tpg->border.height)) {
2494 		linestart_older = tpg->black_line[p];
2495 		linestart_newer = tpg->black_line[p];
2496 	} else if (tpg->pattern == TPG_PAT_NOISE || tpg->qual == TPG_QUAL_NOISE) {
2497 		linestart_older = tpg->random_line[p] +
2498 				  twopixsize * prandom_u32_max(tpg->src_width / 2);
2499 		linestart_newer = tpg->random_line[p] +
2500 				  twopixsize * prandom_u32_max(tpg->src_width / 2);
2501 	} else {
2502 		unsigned frame_line_old =
2503 			(frame_line + mv_vert_old) % tpg->src_height;
2504 		unsigned frame_line_new =
2505 			(frame_line + mv_vert_new) % tpg->src_height;
2506 		unsigned pat_line_next_old;
2507 		unsigned pat_line_next_new;
2508 
2509 		pat_line_old = tpg_get_pat_line(tpg, frame_line_old);
2510 		pat_line_new = tpg_get_pat_line(tpg, frame_line_new);
2511 		linestart_older = tpg->lines[pat_line_old][p] + mv_hor_old;
2512 		linestart_newer = tpg->lines[pat_line_new][p] + mv_hor_new;
2513 
2514 		if (tpg->vdownsampling[p] > 1 && frame_line != frame_line_next) {
2515 			int avg_pat;
2516 
2517 			/*
2518 			 * Now decide whether we need to use downsampled_lines[].
2519 			 * That's necessary if the two lines use different patterns.
2520 			 */
2521 			pat_line_next_old = tpg_get_pat_line(tpg,
2522 					(frame_line_next + mv_vert_old) % tpg->src_height);
2523 			pat_line_next_new = tpg_get_pat_line(tpg,
2524 					(frame_line_next + mv_vert_new) % tpg->src_height);
2525 
2526 			switch (tpg->field) {
2527 			case V4L2_FIELD_INTERLACED:
2528 			case V4L2_FIELD_INTERLACED_BT:
2529 			case V4L2_FIELD_INTERLACED_TB:
2530 				avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_new);
2531 				if (avg_pat < 0)
2532 					break;
2533 				linestart_older = tpg->downsampled_lines[avg_pat][p] + mv_hor_old;
2534 				linestart_newer = linestart_older;
2535 				break;
2536 			case V4L2_FIELD_NONE:
2537 			case V4L2_FIELD_TOP:
2538 			case V4L2_FIELD_BOTTOM:
2539 			case V4L2_FIELD_SEQ_BT:
2540 			case V4L2_FIELD_SEQ_TB:
2541 				avg_pat = tpg_pattern_avg(tpg, pat_line_old, pat_line_next_old);
2542 				if (avg_pat >= 0)
2543 					linestart_older = tpg->downsampled_lines[avg_pat][p] +
2544 						mv_hor_old;
2545 				avg_pat = tpg_pattern_avg(tpg, pat_line_new, pat_line_next_new);
2546 				if (avg_pat >= 0)
2547 					linestart_newer = tpg->downsampled_lines[avg_pat][p] +
2548 						mv_hor_new;
2549 				break;
2550 			}
2551 		}
2552 		linestart_older += line_offset;
2553 		linestart_newer += line_offset;
2554 	}
2555 	if (tpg->field_alternate) {
2556 		linestart_top = linestart_bottom = linestart_older;
2557 	} else if (params->is_60hz) {
2558 		linestart_top = linestart_newer;
2559 		linestart_bottom = linestart_older;
2560 	} else {
2561 		linestart_top = linestart_older;
2562 		linestart_bottom = linestart_newer;
2563 	}
2564 
2565 	switch (tpg->field) {
2566 	case V4L2_FIELD_INTERLACED:
2567 	case V4L2_FIELD_INTERLACED_TB:
2568 	case V4L2_FIELD_SEQ_TB:
2569 	case V4L2_FIELD_SEQ_BT:
2570 		if (even)
2571 			memcpy(vbuf, linestart_top, img_width);
2572 		else
2573 			memcpy(vbuf, linestart_bottom, img_width);
2574 		break;
2575 	case V4L2_FIELD_INTERLACED_BT:
2576 		if (even)
2577 			memcpy(vbuf, linestart_bottom, img_width);
2578 		else
2579 			memcpy(vbuf, linestart_top, img_width);
2580 		break;
2581 	case V4L2_FIELD_TOP:
2582 		memcpy(vbuf, linestart_top, img_width);
2583 		break;
2584 	case V4L2_FIELD_BOTTOM:
2585 		memcpy(vbuf, linestart_bottom, img_width);
2586 		break;
2587 	case V4L2_FIELD_NONE:
2588 	default:
2589 		memcpy(vbuf, linestart_older, img_width);
2590 		break;
2591 	}
2592 }
2593 
2594 void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
2595 			   unsigned p, u8 *vbuf)
2596 {
2597 	struct tpg_draw_params params;
2598 	unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
2599 
2600 	/* Coarse scaling with Bresenham */
2601 	unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
2602 	unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
2603 	unsigned src_y = 0;
2604 	unsigned error = 0;
2605 	unsigned h;
2606 
2607 	tpg_recalc(tpg);
2608 
2609 	params.is_tv = std;
2610 	params.is_60hz = std & V4L2_STD_525_60;
2611 	params.twopixsize = tpg->twopixelsize[p];
2612 	params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
2613 	params.stride = tpg->bytesperline[p];
2614 	params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
2615 
2616 	tpg_fill_params_pattern(tpg, p, &params);
2617 	tpg_fill_params_extras(tpg, p, &params);
2618 
2619 	vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
2620 
2621 	for (h = 0; h < tpg->compose.height; h++) {
2622 		unsigned buf_line;
2623 
2624 		params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
2625 		params.frame_line_next = params.frame_line;
2626 		buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
2627 		src_y += int_part;
2628 		error += fract_part;
2629 		if (error >= tpg->compose.height) {
2630 			error -= tpg->compose.height;
2631 			src_y++;
2632 		}
2633 
2634 		/*
2635 		 * For line-interleaved formats determine the 'plane'
2636 		 * based on the buffer line.
2637 		 */
2638 		if (tpg_g_interleaved(tpg))
2639 			p = tpg_g_interleaved_plane(tpg, buf_line);
2640 
2641 		if (tpg->vdownsampling[p] > 1) {
2642 			/*
2643 			 * When doing vertical downsampling the field setting
2644 			 * matters: for SEQ_BT/TB we downsample each field
2645 			 * separately (i.e. lines 0+2 are combined, as are
2646 			 * lines 1+3), for the other field settings we combine
2647 			 * odd and even lines. Doing that for SEQ_BT/TB would
2648 			 * be really weird.
2649 			 */
2650 			if (tpg->field == V4L2_FIELD_SEQ_BT ||
2651 			    tpg->field == V4L2_FIELD_SEQ_TB) {
2652 				unsigned next_src_y = src_y;
2653 
2654 				if ((h & 3) >= 2)
2655 					continue;
2656 				next_src_y += int_part;
2657 				if (error + fract_part >= tpg->compose.height)
2658 					next_src_y++;
2659 				params.frame_line_next =
2660 					tpg_calc_frameline(tpg, next_src_y, tpg->field);
2661 			} else {
2662 				if (h & 1)
2663 					continue;
2664 				params.frame_line_next =
2665 					tpg_calc_frameline(tpg, src_y, tpg->field);
2666 			}
2667 
2668 			buf_line /= tpg->vdownsampling[p];
2669 		}
2670 		tpg_fill_plane_pattern(tpg, &params, p, h,
2671 				vbuf + buf_line * params.stride);
2672 		tpg_fill_plane_extras(tpg, &params, p, h,
2673 				vbuf + buf_line * params.stride);
2674 	}
2675 }
2676 EXPORT_SYMBOL_GPL(tpg_fill_plane_buffer);
2677 
2678 void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf)
2679 {
2680 	unsigned offset = 0;
2681 	unsigned i;
2682 
2683 	if (tpg->buffers > 1) {
2684 		tpg_fill_plane_buffer(tpg, std, p, vbuf);
2685 		return;
2686 	}
2687 
2688 	for (i = 0; i < tpg_g_planes(tpg); i++) {
2689 		tpg_fill_plane_buffer(tpg, std, i, vbuf + offset);
2690 		offset += tpg_calc_plane_size(tpg, i);
2691 	}
2692 }
2693 EXPORT_SYMBOL_GPL(tpg_fillbuffer);
2694 
2695 MODULE_DESCRIPTION("V4L2 Test Pattern Generator");
2696 MODULE_AUTHOR("Hans Verkuil");
2697 MODULE_LICENSE("GPL");
2698