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