mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 53 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190602204653.904365654@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
385 lines
8.5 KiB
C
385 lines
8.5 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
*
|
|
* Copyright (C) 2005 Mike Isely <isely@pobox.com>
|
|
*/
|
|
|
|
#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;
|
|
}
|