1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *
4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
5  */
6 
7 #include "pvrusb2-std.h"
8 #include "pvrusb2-debug.h"
9 #include <asm/string.h>
10 #include <linux/slab.h>
11 
12 struct std_name {
13 	const char *name;
14 	v4l2_std_id id;
15 };
16 
17 
18 #define CSTD_PAL \
19 	(V4L2_STD_PAL_B| \
20 	 V4L2_STD_PAL_B1| \
21 	 V4L2_STD_PAL_G| \
22 	 V4L2_STD_PAL_H| \
23 	 V4L2_STD_PAL_I| \
24 	 V4L2_STD_PAL_D| \
25 	 V4L2_STD_PAL_D1| \
26 	 V4L2_STD_PAL_K| \
27 	 V4L2_STD_PAL_M| \
28 	 V4L2_STD_PAL_N| \
29 	 V4L2_STD_PAL_Nc| \
30 	 V4L2_STD_PAL_60)
31 
32 #define CSTD_NTSC \
33 	(V4L2_STD_NTSC_M| \
34 	 V4L2_STD_NTSC_M_JP| \
35 	 V4L2_STD_NTSC_M_KR| \
36 	 V4L2_STD_NTSC_443)
37 
38 #define CSTD_ATSC \
39 	(V4L2_STD_ATSC_8_VSB| \
40 	 V4L2_STD_ATSC_16_VSB)
41 
42 #define CSTD_SECAM \
43 	(V4L2_STD_SECAM_B| \
44 	 V4L2_STD_SECAM_D| \
45 	 V4L2_STD_SECAM_G| \
46 	 V4L2_STD_SECAM_H| \
47 	 V4L2_STD_SECAM_K| \
48 	 V4L2_STD_SECAM_K1| \
49 	 V4L2_STD_SECAM_L| \
50 	 V4L2_STD_SECAM_LC)
51 
52 #define TSTD_B   (V4L2_STD_PAL_B|V4L2_STD_SECAM_B)
53 #define TSTD_B1  (V4L2_STD_PAL_B1)
54 #define TSTD_D   (V4L2_STD_PAL_D|V4L2_STD_SECAM_D)
55 #define TSTD_D1  (V4L2_STD_PAL_D1)
56 #define TSTD_G   (V4L2_STD_PAL_G|V4L2_STD_SECAM_G)
57 #define TSTD_H   (V4L2_STD_PAL_H|V4L2_STD_SECAM_H)
58 #define TSTD_I   (V4L2_STD_PAL_I)
59 #define TSTD_K   (V4L2_STD_PAL_K|V4L2_STD_SECAM_K)
60 #define TSTD_K1  (V4L2_STD_SECAM_K1)
61 #define TSTD_L   (V4L2_STD_SECAM_L)
62 #define TSTD_M   (V4L2_STD_PAL_M|V4L2_STD_NTSC_M)
63 #define TSTD_N   (V4L2_STD_PAL_N)
64 #define TSTD_Nc  (V4L2_STD_PAL_Nc)
65 #define TSTD_60  (V4L2_STD_PAL_60)
66 
67 #define CSTD_ALL (CSTD_PAL|CSTD_NTSC|CSTD_ATSC|CSTD_SECAM)
68 
69 /* Mapping of standard bits to color system */
70 static const struct std_name std_groups[] = {
71 	{"PAL",CSTD_PAL},
72 	{"NTSC",CSTD_NTSC},
73 	{"SECAM",CSTD_SECAM},
74 	{"ATSC",CSTD_ATSC},
75 };
76 
77 /* Mapping of standard bits to modulation system */
78 static const struct std_name std_items[] = {
79 	{"B",TSTD_B},
80 	{"B1",TSTD_B1},
81 	{"D",TSTD_D},
82 	{"D1",TSTD_D1},
83 	{"G",TSTD_G},
84 	{"H",TSTD_H},
85 	{"I",TSTD_I},
86 	{"K",TSTD_K},
87 	{"K1",TSTD_K1},
88 	{"L",TSTD_L},
89 	{"LC",V4L2_STD_SECAM_LC},
90 	{"M",TSTD_M},
91 	{"Mj",V4L2_STD_NTSC_M_JP},
92 	{"443",V4L2_STD_NTSC_443},
93 	{"Mk",V4L2_STD_NTSC_M_KR},
94 	{"N",TSTD_N},
95 	{"Nc",TSTD_Nc},
96 	{"60",TSTD_60},
97 	{"8VSB",V4L2_STD_ATSC_8_VSB},
98 	{"16VSB",V4L2_STD_ATSC_16_VSB},
99 };
100 
101 
102 // Search an array of std_name structures and return a pointer to the
103 // element with the matching name.
104 static const struct std_name *find_std_name(const struct std_name *arrPtr,
105 					    unsigned int arrSize,
106 					    const char *bufPtr,
107 					    unsigned int bufSize)
108 {
109 	unsigned int idx;
110 	const struct std_name *p;
111 	for (idx = 0; idx < arrSize; idx++) {
112 		p = arrPtr + idx;
113 		if (strlen(p->name) != bufSize) continue;
114 		if (!memcmp(bufPtr,p->name,bufSize)) return p;
115 	}
116 	return NULL;
117 }
118 
119 
120 int pvr2_std_str_to_id(v4l2_std_id *idPtr,const char *bufPtr,
121 		       unsigned int bufSize)
122 {
123 	v4l2_std_id id = 0;
124 	v4l2_std_id cmsk = 0;
125 	v4l2_std_id t;
126 	int mMode = 0;
127 	unsigned int cnt;
128 	char ch;
129 	const struct std_name *sp;
130 
131 	while (bufSize) {
132 		if (!mMode) {
133 			cnt = 0;
134 			while ((cnt < bufSize) && (bufPtr[cnt] != '-')) cnt++;
135 			if (cnt >= bufSize) return 0; // No more characters
136 			sp = find_std_name(std_groups, ARRAY_SIZE(std_groups),
137 					   bufPtr,cnt);
138 			if (!sp) return 0; // Illegal color system name
139 			cnt++;
140 			bufPtr += cnt;
141 			bufSize -= cnt;
142 			mMode = !0;
143 			cmsk = sp->id;
144 			continue;
145 		}
146 		cnt = 0;
147 		while (cnt < bufSize) {
148 			ch = bufPtr[cnt];
149 			if (ch == ';') {
150 				mMode = 0;
151 				break;
152 			}
153 			if (ch == '/') break;
154 			cnt++;
155 		}
156 		sp = find_std_name(std_items, ARRAY_SIZE(std_items),
157 				   bufPtr,cnt);
158 		if (!sp) return 0; // Illegal modulation system ID
159 		t = sp->id & cmsk;
160 		if (!t) return 0; // Specific color + modulation system illegal
161 		id |= t;
162 		if (cnt < bufSize) cnt++;
163 		bufPtr += cnt;
164 		bufSize -= cnt;
165 	}
166 
167 	if (idPtr) *idPtr = id;
168 	return !0;
169 }
170 
171 
172 unsigned int pvr2_std_id_to_str(char *bufPtr, unsigned int bufSize,
173 				v4l2_std_id id)
174 {
175 	unsigned int idx1,idx2;
176 	const struct std_name *ip,*gp;
177 	int gfl,cfl;
178 	unsigned int c1,c2;
179 	cfl = 0;
180 	c1 = 0;
181 	for (idx1 = 0; idx1 < ARRAY_SIZE(std_groups); idx1++) {
182 		gp = std_groups + idx1;
183 		gfl = 0;
184 		for (idx2 = 0; idx2 < ARRAY_SIZE(std_items); idx2++) {
185 			ip = std_items + idx2;
186 			if (!(gp->id & ip->id & id)) continue;
187 			if (!gfl) {
188 				if (cfl) {
189 					c2 = scnprintf(bufPtr,bufSize,";");
190 					c1 += c2;
191 					bufSize -= c2;
192 					bufPtr += c2;
193 				}
194 				cfl = !0;
195 				c2 = scnprintf(bufPtr,bufSize,
196 					       "%s-",gp->name);
197 				gfl = !0;
198 			} else {
199 				c2 = scnprintf(bufPtr,bufSize,"/");
200 			}
201 			c1 += c2;
202 			bufSize -= c2;
203 			bufPtr += c2;
204 			c2 = scnprintf(bufPtr,bufSize,
205 				       ip->name);
206 			c1 += c2;
207 			bufSize -= c2;
208 			bufPtr += c2;
209 		}
210 	}
211 	return c1;
212 }
213 
214 
215 // Template data for possible enumerated video standards.  Here we group
216 // standards which share common frame rates and resolution.
217 static struct v4l2_standard generic_standards[] = {
218 	{
219 		.id             = (TSTD_B|TSTD_B1|
220 				   TSTD_D|TSTD_D1|
221 				   TSTD_G|
222 				   TSTD_H|
223 				   TSTD_I|
224 				   TSTD_K|TSTD_K1|
225 				   TSTD_L|
226 				   V4L2_STD_SECAM_LC |
227 				   TSTD_N|TSTD_Nc),
228 		.frameperiod    =
229 		{
230 			.numerator  = 1,
231 			.denominator= 25
232 		},
233 		.framelines     = 625,
234 		.reserved       = {0,0,0,0}
235 	}, {
236 		.id             = (TSTD_M|
237 				   V4L2_STD_NTSC_M_JP|
238 				   V4L2_STD_NTSC_M_KR),
239 		.frameperiod    =
240 		{
241 			.numerator  = 1001,
242 			.denominator= 30000
243 		},
244 		.framelines     = 525,
245 		.reserved       = {0,0,0,0}
246 	}, { // This is a total wild guess
247 		.id             = (TSTD_60),
248 		.frameperiod    =
249 		{
250 			.numerator  = 1001,
251 			.denominator= 30000
252 		},
253 		.framelines     = 525,
254 		.reserved       = {0,0,0,0}
255 	}, { // This is total wild guess
256 		.id             = V4L2_STD_NTSC_443,
257 		.frameperiod    =
258 		{
259 			.numerator  = 1001,
260 			.denominator= 30000
261 		},
262 		.framelines     = 525,
263 		.reserved       = {0,0,0,0}
264 	}
265 };
266 
267 static struct v4l2_standard *match_std(v4l2_std_id id)
268 {
269 	unsigned int idx;
270 	for (idx = 0; idx < ARRAY_SIZE(generic_standards); idx++) {
271 		if (generic_standards[idx].id & id) {
272 			return generic_standards + idx;
273 		}
274 	}
275 	return NULL;
276 }
277 
278 static int pvr2_std_fill(struct v4l2_standard *std,v4l2_std_id id)
279 {
280 	struct v4l2_standard *template;
281 	int idx;
282 	unsigned int bcnt;
283 	template = match_std(id);
284 	if (!template) return 0;
285 	idx = std->index;
286 	memcpy(std,template,sizeof(*template));
287 	std->index = idx;
288 	std->id = id;
289 	bcnt = pvr2_std_id_to_str(std->name,sizeof(std->name)-1,id);
290 	std->name[bcnt] = 0;
291 	pvr2_trace(PVR2_TRACE_STD,"Set up standard idx=%u name=%s",
292 		   std->index,std->name);
293 	return !0;
294 }
295 
296 /* These are special cases of combined standards that we should enumerate
297    separately if the component pieces are present. */
298 static v4l2_std_id std_mixes[] = {
299 	V4L2_STD_PAL_B | V4L2_STD_PAL_G,
300 	V4L2_STD_PAL_D | V4L2_STD_PAL_K,
301 	V4L2_STD_SECAM_B | V4L2_STD_SECAM_G,
302 	V4L2_STD_SECAM_D | V4L2_STD_SECAM_K,
303 };
304 
305 struct v4l2_standard *pvr2_std_create_enum(unsigned int *countptr,
306 					   v4l2_std_id id)
307 {
308 	unsigned int std_cnt = 0;
309 	unsigned int idx,bcnt,idx2;
310 	v4l2_std_id idmsk,cmsk,fmsk;
311 	struct v4l2_standard *stddefs;
312 
313 	if (pvrusb2_debug & PVR2_TRACE_STD) {
314 		char buf[100];
315 		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),id);
316 		pvr2_trace(
317 			PVR2_TRACE_STD,"Mapping standards mask=0x%x (%.*s)",
318 			(int)id,bcnt,buf);
319 	}
320 
321 	*countptr = 0;
322 	std_cnt = 0;
323 	fmsk = 0;
324 	for (idmsk = 1, cmsk = id; cmsk; idmsk <<= 1) {
325 		if (!(idmsk & cmsk)) continue;
326 		cmsk &= ~idmsk;
327 		if (match_std(idmsk)) {
328 			std_cnt++;
329 			continue;
330 		}
331 		fmsk |= idmsk;
332 	}
333 
334 	for (idx2 = 0; idx2 < ARRAY_SIZE(std_mixes); idx2++) {
335 		if ((id & std_mixes[idx2]) == std_mixes[idx2]) std_cnt++;
336 	}
337 
338 	/* Don't complain about ATSC standard values */
339 	fmsk &= ~CSTD_ATSC;
340 
341 	if (fmsk) {
342 		char buf[100];
343 		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),fmsk);
344 		pvr2_trace(
345 			PVR2_TRACE_ERROR_LEGS,
346 			"***WARNING*** Failed to classify the following standard(s): %.*s",
347 			bcnt,buf);
348 	}
349 
350 	pvr2_trace(PVR2_TRACE_STD,"Setting up %u unique standard(s)",
351 		   std_cnt);
352 	if (!std_cnt) return NULL; // paranoia
353 
354 	stddefs = kcalloc(std_cnt, sizeof(struct v4l2_standard),
355 			  GFP_KERNEL);
356 	if (!stddefs)
357 		return NULL;
358 
359 	for (idx = 0; idx < std_cnt; idx++)
360 		stddefs[idx].index = idx;
361 
362 	idx = 0;
363 
364 	/* Enumerate potential special cases */
365 	for (idx2 = 0; (idx2 < ARRAY_SIZE(std_mixes)) && (idx < std_cnt);
366 	     idx2++) {
367 		if (!(id & std_mixes[idx2])) continue;
368 		if (pvr2_std_fill(stddefs+idx,std_mixes[idx2])) idx++;
369 	}
370 	/* Now enumerate individual pieces */
371 	for (idmsk = 1, cmsk = id; cmsk && (idx < std_cnt); idmsk <<= 1) {
372 		if (!(idmsk & cmsk)) continue;
373 		cmsk &= ~idmsk;
374 		if (!pvr2_std_fill(stddefs+idx,idmsk)) continue;
375 		idx++;
376 	}
377 
378 	*countptr = std_cnt;
379 	return stddefs;
380 }
381 
382 v4l2_std_id pvr2_std_get_usable(void)
383 {
384 	return CSTD_ALL;
385 }
386