| /* |
| * |
| * |
| * 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. |
| * |
| */ |
| |
| #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} |
| } |
| }; |
| |
| static struct v4l2_standard *match_std(v4l2_std_id id) |
| { |
| unsigned int idx; |
| for (idx = 0; idx < ARRAY_SIZE(generic_standards); 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 = kcalloc(std_cnt, sizeof(struct v4l2_standard), |
| 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; |
| } |