1/* 2 * 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" 23#include <asm/string.h> 24#include <linux/slab.h> 25 26struct 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 52#define CSTD_ATSC \ 53 (V4L2_STD_ATSC_8_VSB| \ 54 V4L2_STD_ATSC_16_VSB) 55 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 81#define CSTD_ALL (CSTD_PAL|CSTD_NTSC|CSTD_ATSC|CSTD_SECAM) 82 83/* Mapping of standard bits to color system */ 84static const struct std_name std_groups[] = { 85 {"PAL",CSTD_PAL}, 86 {"NTSC",CSTD_NTSC}, 87 {"SECAM",CSTD_SECAM}, 88 {"ATSC",CSTD_ATSC}, 89}; 90 91/* Mapping of standard bits to modulation system */ 92static const struct std_name std_items[] = { 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}, 111 {"8VSB",V4L2_STD_ATSC_8_VSB}, 112 {"16VSB",V4L2_STD_ATSC_16_VSB}, 113}; 114 115 116// Search an array of std_name structures and return a pointer to the 117// element with the matching name. 118static 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 } 130 return NULL; 131} 132 133 134int 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 150 sp = find_std_name(std_groups, ARRAY_SIZE(std_groups), 151 bufPtr,cnt); 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 } 170 sp = find_std_name(std_items, ARRAY_SIZE(std_items), 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 186unsigned 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; 195 for (idx1 = 0; idx1 < ARRAY_SIZE(std_groups); idx1++) { 196 gp = std_groups + idx1; 197 gfl = 0; 198 for (idx2 = 0; idx2 < ARRAY_SIZE(std_items); idx2++) { 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. 231static 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 281#define generic_standards_cnt ARRAY_SIZE(generic_standards) 282 283static 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 } 291 return NULL; 292} 293 294static 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; 307 pvr2_trace(PVR2_TRACE_STD,"Set up standard idx=%u name=%s", 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. */ 314static 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 321struct 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 329 if (pvrusb2_debug & PVR2_TRACE_STD) { 330 char buf[100]; 331 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),id); 332 pvr2_trace( 333 PVR2_TRACE_STD,"Mapping standards mask=0x%x (%.*s)", 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 350 for (idx2 = 0; idx2 < ARRAY_SIZE(std_mixes); idx2++) { 351 if ((id & std_mixes[idx2]) == std_mixes[idx2]) std_cnt++; 352 } 353 354 /* Don't complain about ATSC standard values */ 355 fmsk &= ~CSTD_ATSC; 356 357 if (fmsk) { 358 char buf[100]; 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 367 pvr2_trace(PVR2_TRACE_STD,"Setting up %u unique standard(s)", 368 std_cnt); 369 if (!std_cnt) return NULL; // paranoia 370 371 stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt, 372 GFP_KERNEL); 373 for (idx = 0; idx < std_cnt; idx++) stddefs[idx].index = idx; 374 375 idx = 0; 376 377 /* Enumerate potential special cases */ 378 for (idx2 = 0; (idx2 < ARRAY_SIZE(std_mixes)) && (idx < std_cnt); 379 idx2++) { 380 if (!(id & std_mixes[idx2])) continue; 381 if (pvr2_std_fill(stddefs+idx,std_mixes[idx2])) idx++; 382 } 383 /* Now enumerate individual pieces */ 384 for (idmsk = 1, cmsk = id; cmsk && (idx < std_cnt); idmsk <<= 1) { 385 if (!(idmsk & cmsk)) continue; 386 cmsk &= ~idmsk; 387 if (!pvr2_std_fill(stddefs+idx,idmsk)) continue; 388 idx++; 389 } 390 391 *countptr = std_cnt; 392 return stddefs; 393} 394 395v4l2_std_id pvr2_std_get_usable(void) 396{ 397 return CSTD_ALL; 398} 399 400 401/* 402 Stuff for Emacs to see, in order to encourage consistent editing style: 403 *** Local Variables: *** 404 *** mode: c *** 405 *** fill-column: 75 *** 406 *** tab-width: 8 *** 407 *** c-basic-offset: 8 *** 408 *** End: *** 409 */ 410