[deliverable/linux.git] / drivers / media / video / pvrusb2 / pvrusb2-std.c

/*
 *
 *
 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "pvrusb2-std.h"
#include "pvrusb2-debug.h"
#include <asm/string.h>
#include <linux/slab.h>

struct std_name {
	const char *name;
	v4l2_std_id id;
};


#define CSTD_PAL \
	(V4L2_STD_PAL_B| \
	 V4L2_STD_PAL_B1| \
	 V4L2_STD_PAL_G| \
	 V4L2_STD_PAL_H| \
	 V4L2_STD_PAL_I| \
	 V4L2_STD_PAL_D| \
	 V4L2_STD_PAL_D1| \
	 V4L2_STD_PAL_K| \
	 V4L2_STD_PAL_M| \
	 V4L2_STD_PAL_N| \
	 V4L2_STD_PAL_Nc| \
	 V4L2_STD_PAL_60)

#define CSTD_NTSC \
	(V4L2_STD_NTSC_M| \
	 V4L2_STD_NTSC_M_JP| \
	 V4L2_STD_NTSC_M_KR| \
	 V4L2_STD_NTSC_443)

#define CSTD_ATSC \
	(V4L2_STD_ATSC_8_VSB| \
	 V4L2_STD_ATSC_16_VSB)

#define CSTD_SECAM \
	(V4L2_STD_SECAM_B| \
	 V4L2_STD_SECAM_D| \
	 V4L2_STD_SECAM_G| \
	 V4L2_STD_SECAM_H| \
	 V4L2_STD_SECAM_K| \
	 V4L2_STD_SECAM_K1| \
	 V4L2_STD_SECAM_L| \
	 V4L2_STD_SECAM_LC)

#define TSTD_B   (V4L2_STD_PAL_B|V4L2_STD_SECAM_B)
#define TSTD_B1  (V4L2_STD_PAL_B1)
#define TSTD_D   (V4L2_STD_PAL_D|V4L2_STD_SECAM_D)
#define TSTD_D1  (V4L2_STD_PAL_D1)
#define TSTD_G   (V4L2_STD_PAL_G|V4L2_STD_SECAM_G)
#define TSTD_H   (V4L2_STD_PAL_H|V4L2_STD_SECAM_H)
#define TSTD_I   (V4L2_STD_PAL_I)
#define TSTD_K   (V4L2_STD_PAL_K|V4L2_STD_SECAM_K)
#define TSTD_K1  (V4L2_STD_SECAM_K1)
#define TSTD_L   (V4L2_STD_SECAM_L)
#define TSTD_M   (V4L2_STD_PAL_M|V4L2_STD_NTSC_M)
#define TSTD_N   (V4L2_STD_PAL_N)
#define TSTD_Nc  (V4L2_STD_PAL_Nc)
#define TSTD_60  (V4L2_STD_PAL_60)

#define CSTD_ALL (CSTD_PAL|CSTD_NTSC|CSTD_ATSC|CSTD_SECAM)

/* Mapping of standard bits to color system */
static const struct std_name std_groups[] = {
	{"PAL",CSTD_PAL},
	{"NTSC",CSTD_NTSC},
	{"SECAM",CSTD_SECAM},
	{"ATSC",CSTD_ATSC},
};

/* Mapping of standard bits to modulation system */
static const struct std_name std_items[] = {
	{"B",TSTD_B},
	{"B1",TSTD_B1},
	{"D",TSTD_D},
	{"D1",TSTD_D1},
	{"G",TSTD_G},
	{"H",TSTD_H},
	{"I",TSTD_I},
	{"K",TSTD_K},
	{"K1",TSTD_K1},
	{"L",TSTD_L},
	{"LC",V4L2_STD_SECAM_LC},
	{"M",TSTD_M},
	{"Mj",V4L2_STD_NTSC_M_JP},
	{"443",V4L2_STD_NTSC_443},
	{"Mk",V4L2_STD_NTSC_M_KR},
	{"N",TSTD_N},
	{"Nc",TSTD_Nc},
	{"60",TSTD_60},
	{"8VSB",V4L2_STD_ATSC_8_VSB},
	{"16VSB",V4L2_STD_ATSC_16_VSB},
};


// Search an array of std_name structures and return a pointer to the
// element with the matching name.
static const struct std_name *find_std_name(const struct std_name *arrPtr,
					    unsigned int arrSize,
					    const char *bufPtr,
					    unsigned int bufSize)
{
	unsigned int idx;
	const struct std_name *p;
	for (idx = 0; idx < arrSize; idx++) {
		p = arrPtr + idx;
		if (strlen(p->name) != bufSize) continue;
		if (!memcmp(bufPtr,p->name,bufSize)) return p;
	}
	return NULL;
}


int pvr2_std_str_to_id(v4l2_std_id *idPtr,const char *bufPtr,
		       unsigned int bufSize)
{
	v4l2_std_id id = 0;
	v4l2_std_id cmsk = 0;
	v4l2_std_id t;
	int mMode = 0;
	unsigned int cnt;
	char ch;
	const struct std_name *sp;

	while (bufSize) {
		if (!mMode) {
			cnt = 0;
			while ((cnt < bufSize) && (bufPtr[cnt] != '-')) cnt++;
			if (cnt >= bufSize) return 0; // No more characters
			sp = find_std_name(std_groups, ARRAY_SIZE(std_groups),
					   bufPtr,cnt);
			if (!sp) return 0; // Illegal color system name
			cnt++;
			bufPtr += cnt;
			bufSize -= cnt;
			mMode = !0;
			cmsk = sp->id;
			continue;
		}
		cnt = 0;
		while (cnt < bufSize) {
			ch = bufPtr[cnt];
			if (ch == ';') {
				mMode = 0;
				break;
			}
			if (ch == '/') break;
			cnt++;
		}
		sp = find_std_name(std_items, ARRAY_SIZE(std_items),
				   bufPtr,cnt);
		if (!sp) return 0; // Illegal modulation system ID
		t = sp->id & cmsk;
		if (!t) return 0; // Specific color + modulation system illegal
		id |= t;
		if (cnt < bufSize) cnt++;
		bufPtr += cnt;
		bufSize -= cnt;
	}

	if (idPtr) *idPtr = id;
	return !0;
}


unsigned int pvr2_std_id_to_str(char *bufPtr, unsigned int bufSize,
				v4l2_std_id id)
{
	unsigned int idx1,idx2;
	const struct std_name *ip,*gp;
	int gfl,cfl;
	unsigned int c1,c2;
	cfl = 0;
	c1 = 0;
	for (idx1 = 0; idx1 < ARRAY_SIZE(std_groups); idx1++) {
		gp = std_groups + idx1;
		gfl = 0;
		for (idx2 = 0; idx2 < ARRAY_SIZE(std_items); idx2++) {
			ip = std_items + idx2;
			if (!(gp->id & ip->id & id)) continue;
			if (!gfl) {
				if (cfl) {
					c2 = scnprintf(bufPtr,bufSize,";");
					c1 += c2;
					bufSize -= c2;
					bufPtr += c2;
				}
				cfl = !0;
				c2 = scnprintf(bufPtr,bufSize,
					       "%s-",gp->name);
				gfl = !0;
			} else {
				c2 = scnprintf(bufPtr,bufSize,"/");
			}
			c1 += c2;
			bufSize -= c2;
			bufPtr += c2;
			c2 = scnprintf(bufPtr,bufSize,
				       ip->name);
			c1 += c2;
			bufSize -= c2;
			bufPtr += c2;
		}
	}
	return c1;
}


// Template data for possible enumerated video standards.  Here we group
// standards which share common frame rates and resolution.
static struct v4l2_standard generic_standards[] = {
	{
		.id             = (TSTD_B|TSTD_B1|
				   TSTD_D|TSTD_D1|
				   TSTD_G|
				   TSTD_H|
				   TSTD_I|
				   TSTD_K|TSTD_K1|
				   TSTD_L|
				   V4L2_STD_SECAM_LC |
				   TSTD_N|TSTD_Nc),
		.frameperiod    =
		{
			.numerator  = 1,
			.denominator= 25
		},
		.framelines     = 625,
		.reserved       = {0,0,0,0}
	}, {
		.id             = (TSTD_M|
				   V4L2_STD_NTSC_M_JP|
				   V4L2_STD_NTSC_M_KR),
		.frameperiod    =
		{
			.numerator  = 1001,
			.denominator= 30000
		},
		.framelines     = 525,
		.reserved       = {0,0,0,0}
	}, { // This is a total wild guess
		.id             = (TSTD_60),
		.frameperiod    =
		{
			.numerator  = 1001,
			.denominator= 30000
		},
		.framelines     = 525,
		.reserved       = {0,0,0,0}
	}, { // This is total wild guess
		.id             = V4L2_STD_NTSC_443,
		.frameperiod    =
		{
			.numerator  = 1001,
			.denominator= 30000
		},
		.framelines     = 525,
		.reserved       = {0,0,0,0}
	}
};

#define generic_standards_cnt ARRAY_SIZE(generic_standards)

static struct v4l2_standard *match_std(v4l2_std_id id)
{
	unsigned int idx;
	for (idx = 0; idx < generic_standards_cnt; idx++) {
		if (generic_standards[idx].id & id) {
			return generic_standards + idx;
		}
	}
	return NULL;
}

static int pvr2_std_fill(struct v4l2_standard *std,v4l2_std_id id)
{
	struct v4l2_standard *template;
	int idx;
	unsigned int bcnt;
	template = match_std(id);
	if (!template) return 0;
	idx = std->index;
	memcpy(std,template,sizeof(*template));
	std->index = idx;
	std->id = id;
	bcnt = pvr2_std_id_to_str(std->name,sizeof(std->name)-1,id);
	std->name[bcnt] = 0;
	pvr2_trace(PVR2_TRACE_STD,"Set up standard idx=%u name=%s",
		   std->index,std->name);
	return !0;
}

/* These are special cases of combined standards that we should enumerate
   separately if the component pieces are present. */
static v4l2_std_id std_mixes[] = {
	V4L2_STD_PAL_B | V4L2_STD_PAL_G,
	V4L2_STD_PAL_D | V4L2_STD_PAL_K,
	V4L2_STD_SECAM_B | V4L2_STD_SECAM_G,
	V4L2_STD_SECAM_D | V4L2_STD_SECAM_K,
};

struct v4l2_standard *pvr2_std_create_enum(unsigned int *countptr,
					   v4l2_std_id id)
{
	unsigned int std_cnt = 0;
	unsigned int idx,bcnt,idx2;
	v4l2_std_id idmsk,cmsk,fmsk;
	struct v4l2_standard *stddefs;

	if (pvrusb2_debug & PVR2_TRACE_STD) {
		char buf[100];
		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),id);
		pvr2_trace(
			PVR2_TRACE_STD,"Mapping standards mask=0x%x (%.*s)",
			(int)id,bcnt,buf);
	}

	*countptr = 0;
	std_cnt = 0;
	fmsk = 0;
	for (idmsk = 1, cmsk = id; cmsk; idmsk <<= 1) {
		if (!(idmsk & cmsk)) continue;
		cmsk &= ~idmsk;
		if (match_std(idmsk)) {
			std_cnt++;
			continue;
		}
		fmsk |= idmsk;
	}

	for (idx2 = 0; idx2 < ARRAY_SIZE(std_mixes); idx2++) {
		if ((id & std_mixes[idx2]) == std_mixes[idx2]) std_cnt++;
	}

	/* Don't complain about ATSC standard values */
	fmsk &= ~CSTD_ATSC;

	if (fmsk) {
		char buf[100];
		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),fmsk);
		pvr2_trace(
			PVR2_TRACE_ERROR_LEGS,
			"WARNING:"
			" Failed to classify the following standard(s): %.*s",
			bcnt,buf);
	}

	pvr2_trace(PVR2_TRACE_STD,"Setting up %u unique standard(s)",
		   std_cnt);
	if (!std_cnt) return NULL; // paranoia

	stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt,
			  GFP_KERNEL);
	if (!stddefs)
		return NULL;

	for (idx = 0; idx < std_cnt; idx++)
		stddefs[idx].index = idx;

	idx = 0;

	/* Enumerate potential special cases */
	for (idx2 = 0; (idx2 < ARRAY_SIZE(std_mixes)) && (idx < std_cnt);
	     idx2++) {
		if (!(id & std_mixes[idx2])) continue;
		if (pvr2_std_fill(stddefs+idx,std_mixes[idx2])) idx++;
	}
	/* Now enumerate individual pieces */
	for (idmsk = 1, cmsk = id; cmsk && (idx < std_cnt); idmsk <<= 1) {
		if (!(idmsk & cmsk)) continue;
		cmsk &= ~idmsk;
		if (!pvr2_std_fill(stddefs+idx,idmsk)) continue;
		idx++;
	}

	*countptr = std_cnt;
	return stddefs;
}

v4l2_std_id pvr2_std_get_usable(void)
{
	return CSTD_ALL;
}


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