Major pvrusb2 rework to remove translations

From: Mike Isely <isely@pobox.com>

Rework entire internal controls interface to eliminate the need for
visibly defined control IDs which must otherwise be translated by the
V4L2 public interface.  As part of this work, internal structures
which mimiced various V4L2 structures (video standards, audio modes)
have been reworked to actually use the native structures.  This
triggered a _significant_ rework for how video standards are dealt
with (and what is in place now should be much more flexible and
forgiving for various handling less-common video standards).

Signed-off-by: Mike Isely <isely@pobox.com>

10 files changed, 1134 insertions, 776 deletions

diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-audio.c b/linux/drivers/media/video/pvrusb2/pvrusb2-audio.c
index 79395d540..ae34ff9e4 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-audio.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-audio.c
@@ -37,26 +37,6 @@ struct pvr2_msp3400_handler {
 };
 
 
-static int xlat_audiomode_to_v4l2(int id)
-{
-	switch (id) {
-	case PVR2_CVAL_AUDIOMODE_MONO:
-		return V4L2_TUNER_MODE_MONO;
-	case PVR2_CVAL_AUDIOMODE_STEREO:
-		return V4L2_TUNER_MODE_STEREO;
-	case PVR2_CVAL_AUDIOMODE_SAP:
-		return V4L2_TUNER_MODE_SAP;
-	case PVR2_CVAL_AUDIOMODE_LANG1:
-		return V4L2_TUNER_MODE_LANG1;
-	case PVR2_CVAL_AUDIOMODE_LANG2:
-		return V4L2_TUNER_MODE_LANG2;
-	case PVR2_CVAL_AUDIOMODE_LANG1_LANG2:
-		return V4L2_TUNER_MODE_LANG1_LANG2;
-	}
-	return V4L2_TUNER_MODE_STEREO;
-}
-
-
 /* This function selects the correct audio input source */
 static void set_stereo(struct pvr2_msp3400_handler *ctxt)
 {
@@ -68,8 +48,7 @@ static void set_stereo(struct pvr2_msp3400_handler *ctxt)
 	if (hdw->controls[PVR2_CID_INPUT].value == PVR2_CVAL_INPUT_TV) {
 		struct v4l2_tuner vt;
 		memset(&vt,0,sizeof(vt));
-		vt.audmode = xlat_audiomode_to_v4l2(
-			hdw->controls[PVR2_CID_AUDIOMODE].value);
+		vt.audmode = hdw->controls[PVR2_CID_AUDIOMODE].value;
 		pvr2_i2c_client_cmd(ctxt->client,VIDIOC_S_TUNER,&vt);
 	}
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.c b/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.c
index 60ee45ca2..634095efc 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.c
@@ -204,7 +204,7 @@ int pvr2_eeprom_analyze(struct pvr2_hdw *hdw)
 	trace_eeprom("rev_str=%s",tvdata.rev_str);
 	hdw->tuner_type = tvdata.tuner_type;
 	hdw->serial_number = tvdata.serial_number;
-	hdw->video_standards = tvdata.tuner_formats;
+	pvr2_hdw_internal_set_std_avail(hdw,tvdata.tuner_formats);
 
 	kfree(eeprom);
 
@@ -222,48 +222,6 @@ int pvr2_eeprom_analyze(struct pvr2_hdw *hdw)
 
 
 
-static v4l2_std_id std_choices[] = {
-	[PVR2_CVAL_VIDEOSTANDARD_NTSC_M]  = V4L2_STD_NTSC_M,
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_BG]  = V4L2_STD_PAL_BG,
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_I]   = V4L2_STD_PAL_I,
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_DK]  = V4L2_STD_PAL_DK,
-	[PVR2_CVAL_VIDEOSTANDARD_SECAM_L] = V4L2_STD_SECAM_L,
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_M]   = V4L2_STD_PAL_M,
-};
-
-void pvr2_eeprom_set_default_standard(struct pvr2_hdw *hdw)
-{
-	int vstd_value = 0;
-	int vstd_found = 0;
-	unsigned int idx;
-	v4l2_std_id vs = (v4l2_std_id)hdw->video_standards;
-
-	for (idx = 0; idx < sizeof(std_choices)/sizeof(std_choices[0]);
-	     idx++) {
-		if (!(vs & std_choices[idx])) continue;
-		trace_eeprom("Detected video standard %s (from eeprom)",
-			     pvr2_hdw_get_ctl_value_name(
-				     hdw,PVR2_CID_VIDEOSTANDARD,idx));
-		if (vstd_found) continue;
-		vstd_value = idx;
-		vstd_found = !0;
-	}
-
-	if (!vstd_found) {
-		trace_eeprom("eeprom unable to recognize"
-			     " a known video standard");
-		return;
-	}
-
-	trace_eeprom("Setting initial video standard to %s"
-		     " (detected from eeprom)",
-		     pvr2_hdw_get_ctl_value_name(hdw,
-						 PVR2_CID_VIDEOSTANDARD,
-						 vstd_value));
-	pvr2_hdw_set_ctl_value_internal(hdw,PVR2_CID_VIDEOSTANDARD,vstd_value);
-}
-
-
 /*
   Stuff for Emacs to see, in order to encourage consistent editing style:
   *** Local Variables: ***
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.h b/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.h
index 061cecd91..84242975d 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.h
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-eeprom.h
@@ -26,7 +26,6 @@
 struct pvr2_hdw;
 
 int pvr2_eeprom_analyze(struct pvr2_hdw *);
-void pvr2_eeprom_set_default_standard(struct pvr2_hdw *);
 
 #endif /* __PVRUSB2_EEPROM_H */
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-encoder.c b/linux/drivers/media/video/pvrusb2/pvrusb2-encoder.c
index 553bd2d7b..2de5b6c8f 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-encoder.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-encoder.c
@@ -268,26 +268,22 @@ static int pvr2_write_encoder_vcmd (struct pvr2_hdw *hdw, u8 cmd,
 int pvr2_encoder_configure(struct pvr2_hdw *hdw)
 {
 	int ret = 0, audio, i;
-	int vd_std = hdw->controls[PVR2_CID_VIDEOSTANDARD].value;
+	int vd_std = hdw->controls[PVR2_CID_STDCUR].value;
 	int height = hdw->controls[PVR2_CID_VRES].value;
 	int width = hdw->controls[PVR2_CID_HRES].value;
 	int height_full = !hdw->controls[PVR2_CID_INTERLACE].value;
 
 	int is_30fps, is_ntsc;
 
-	switch (vd_std) {
-	case PVR2_CVAL_VIDEOSTANDARD_NTSC_M:
+	if (vd_std & V4L2_STD_NTSC) {
 		is_ntsc=1;
 		is_30fps=1;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_PAL_M:
+	} else if (vd_std & V4L2_STD_PAL_M) {
 		is_ntsc=0;
 		is_30fps=1;
-		break;
-	default:
+	} else {
 		is_ntsc=0;
 		is_30fps=0;
-		break;
 	}
 
 	pvr2_trace(PVR2_TRACE_ENCODER,"pvr2_encoder_configure");
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
index 25854375b..189075bbe 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
@@ -45,6 +45,83 @@
 #include "pvrusb2-hdw.h"
 #include "pvrusb2-io.h"
 
+
+/* Definition of state variables that we can inspect & change.  Numbers are
+   assigned from zero counting up with no gaps. */
+#define PVR2_CID_BRIGHTNESS 0
+#define PVR2_CID_CONTRAST 1
+#define PVR2_CID_SATURATION 2
+#define PVR2_CID_HUE 3
+#define PVR2_CID_VOLUME 4
+#define PVR2_CID_BALANCE 5
+#define PVR2_CID_BASS 6
+#define PVR2_CID_TREBLE 7
+#define PVR2_CID_MUTE 8
+#define PVR2_CID_SRATE 9
+#define PVR2_CID_AUDIOBITRATE 10
+#define PVR2_CID_AUDIOCRC 11
+#define PVR2_CID_AUDIOEMPHASIS 12
+#define PVR2_CID_VBR 13
+#define PVR2_CID_AVERAGEVIDEOBITRATE 14
+#define PVR2_CID_PEAKVIDEOBITRATE 15
+#define PVR2_CID_STDAVAIL 16 // V4L2 video standard bit mask
+#define PVR2_CID_INPUT 17
+#define PVR2_CID_AUDIOMODE 18 // V4L2 standard audio mode enum
+#define PVR2_CID_FREQUENCY 19 // Units of Hz
+#define PVR2_CID_HRES 20
+#define PVR2_CID_VRES 21
+#define PVR2_CID_INTERLACE 22
+#define PVR2_CID_AUDIOLAYER 23
+#define PVR2_CID_CHANNEL 24
+#define PVR2_CID_CHANPROG_ID 25
+#define PVR2_CID_CHANPROG_FREQ 26
+#define PVR2_CID_SIGNAL_PRESENT 27
+#define PVR2_CID_STREAMING_ENABLED 28
+#define PVR2_CID_HSM 29
+#define PVR2_CID_SUBSYS_MASK 30
+#define PVR2_CID_SUBSYS_STREAM_MASK 31
+#define PVR2_CID_STDCUR 32 // V4L2 video standard bit mask
+#define PVR2_CID_STDNAME 33 // Enumeration of available standards
+
+/* Legal values for the SRATE state variable */
+#define PVR2_CVAL_SRATE_48 0
+#define PVR2_CVAL_SRATE_44_1 1
+#define PVR2_CVAL_SRATE_MIN PVR2_CVAL_SRATE_48
+#define PVR2_CVAL_SRATE_MAX PVR2_CVAL_SRATE_44_1
+
+/* Legal values for the AUDIOBITRATE state variable */
+#define PVR2_CVAL_AUDIOBITRATE_384 0
+#define PVR2_CVAL_AUDIOBITRATE_320 1
+#define PVR2_CVAL_AUDIOBITRATE_256 2
+#define PVR2_CVAL_AUDIOBITRATE_224 3
+#define PVR2_CVAL_AUDIOBITRATE_192 4
+#define PVR2_CVAL_AUDIOBITRATE_160 5
+#define PVR2_CVAL_AUDIOBITRATE_128 6
+#define PVR2_CVAL_AUDIOBITRATE_112 7
+#define PVR2_CVAL_AUDIOBITRATE_96 8
+#define PVR2_CVAL_AUDIOBITRATE_80 9
+#define PVR2_CVAL_AUDIOBITRATE_64 10
+#define PVR2_CVAL_AUDIOBITRATE_56 11
+#define PVR2_CVAL_AUDIOBITRATE_48 12
+#define PVR2_CVAL_AUDIOBITRATE_32 13
+#define PVR2_CVAL_AUDIOBITRATE_VBR 14
+#define PVR2_CVAL_AUDIOBITRATE_MIN PVR2_CVAL_AUDIOBITRATE_384
+#define PVR2_CVAL_AUDIOBITRATE_MAX PVR2_CVAL_AUDIOBITRATE_VBR
+
+/* Legal values for the AUDIOEMPHASIS state variable */
+#define PVR2_CVAL_AUDIOEMPHASIS_NONE 0
+#define PVR2_CVAL_AUDIOEMPHASIS_50_15 1
+#define PVR2_CVAL_AUDIOEMPHASIS_CCITT 2
+#define PVR2_CVAL_AUDIOEMPHASIS_MIN PVR2_CVAL_AUDIOEMPHASIS_NONE
+#define PVR2_CVAL_AUDIOEMPHASIS_MAX PVR2_CVAL_AUDIOEMPHASIS_CCITT
+
+/* Legal values for PVR2_CID_HSM */
+#define PVR2_CVAL_HSM_FAIL 0
+#define PVR2_CVAL_HSM_FULL 1
+#define PVR2_CVAL_HSM_HIGH 2
+#define PVR2_CVAL_HSM_MIN PVR2_CVAL_HSM_FAIL
+#define PVR2_CVAL_HSM_MAX PVR2_CVAL_HSM_HIGH
+
 #define PVR2_VID_ENDPOINT        0x84
 #define PVR2_UNK_ENDPOINT        0x86    /* maybe raw yuv ? */
 #define PVR2_VBI_ENDPOINT        0x88
@@ -58,7 +135,33 @@
 
 struct pvr2_decoder;
 
-struct pvr2_ctl_state {
+struct pvr2_ctl_def;
+struct pvr2_ctrl;
+
+typedef int (*pvr2_ctl_set_func)(struct pvr2_ctrl *,int val);
+typedef int (*pvr2_ctl_get_func)(struct pvr2_ctrl *);
+
+struct pvr2_ctl_def {
+	int id;
+	const char *name;
+	const char *desc;
+	pvr2_ctl_set_func set_func;
+	pvr2_ctl_get_func get_func;
+	int mask_value;
+	int max_value;
+	int min_value;
+	int skip_init;
+	int default_value;
+	int is_valid;
+	const char **value_defs_ptr;
+	unsigned int value_defs_count;
+};
+
+
+struct pvr2_ctrl {
+	struct pvr2_hdw *hdw;
+	const struct pvr2_ctl_def *ctl_def;
+	int is_valid;
 	int value;
 	int dirty;
 };
@@ -191,7 +294,13 @@ struct pvr2_hdw {
 	/* Tuner / frequency control stuff */
 	unsigned int tuner_type;
 	int tuner_updated;
-	unsigned long video_standards;
+	v4l2_std_id video_std_avail;
+	v4l2_std_id video_std_cur;
+	struct pvr2_ctl_def video_std_enum;
+	struct v4l2_standard *std_defs;
+	const char **video_std_names;
+	unsigned int std_cnt;
+	int std_id;
 
 	int unit_number;             /* ID for driver instance */
 	unsigned long serial_number; /* ID for hardware itself */
@@ -211,13 +320,17 @@ struct pvr2_hdw {
 	struct pvr2_audio_stat *audio_stat;
 
 	/* Every last bit of controllable state */
-	struct pvr2_ctl_state *controls;
+	struct pvr2_ctrl *controls;
 };
 
-int pvr2_hdw_set_ctl_value_internal(struct pvr2_hdw *hdw,
-				    unsigned int ctl_id,int value);
 int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw);
 
+int pvr2_ctrl_internal_set_value(struct pvr2_ctrl *cptr,int val);
+int pvr2_ctrl_internal_get_value(struct pvr2_ctrl *cptr);
+
+int pvr2_hdw_internal_set_stdenum_cur(struct pvr2_hdw *hdw,int val);
+void pvr2_hdw_internal_set_std_cur(struct pvr2_hdw *hdw,int msk);
+void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw,int msk);
 
 #endif /* __PVRUSB2_HDW_INTERNAL_H */
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index a0b0cd8aa..585f4ee0b 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -24,6 +24,7 @@
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/firmware.h>
+#include <linux/videodev2.h>
 #include <asm/semaphore.h>
 #include "pvrusb2.h"
 #include "pvrusb2-util.h"
@@ -86,23 +87,6 @@ MODULE_PARM_DESC(tolerance,"specify stream error tolerance");
 /* size of a firmware chunk */
 #define FIRMWARE_CHUNK_SIZE 0x2000
 
-typedef int (*pvr2_ctl_set_func)(struct pvr2_hdw *,int ctl_id,int val);
-typedef int (*pvr2_ctl_get_func)(struct pvr2_hdw *,int ctl_id);
-
-struct pvr2_ctl_def {
-	const char *name;
-	pvr2_ctl_set_func set_func;
-	pvr2_ctl_get_func get_func;
-	int max_value;
-	int min_value;
-	int skip_init;
-	int default_value;
-	int is_valid;
-	const char **value_defs_ptr;
-	unsigned int value_defs_count;
-};
-
-
 static const char *control_values_srate[] = {
 	[PVR2_CVAL_SRATE_48]   = "48KHz",
 	[PVR2_CVAL_SRATE_44_1] = "44.1KHz",
@@ -136,12 +120,35 @@ static const char *control_values_audioemphasis[] = {
 
 
 static const char *control_values_videostandard[] = {
-	[PVR2_CVAL_VIDEOSTANDARD_NTSC_M]  = "NTSC-M",
-	[PVR2_CVAL_VIDEOSTANDARD_SECAM_L] = "SECAM-L",
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_BG]  = "PAL-BG",
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_I]   = "PAL-I",
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_DK]  = "PAL-DK",
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_M]   = "PAL-M",
+	"PAL-B",
+	"PAL-B1",
+	"PAL-G",
+	"PAL-H",
+
+	"PAL-I",
+	"PAL-D",
+	"PAL-D1",
+	"PAL-K",
+
+	"PAL-M",
+	"PAL-N",
+	"PAL-Nc",
+	"PAL-60",
+
+	"NTSC-M",
+	"NTSC-M-JP",
+	"NTSC-443",
+	0,
+
+	"SECAM-B",
+	"SECAM-D",
+	"SECAM-G",
+	"SECAM-H",
+
+	"SECAM-K",
+	"SECAM-K1",
+	"SECAM-L",
+	"SECAM-LC",
 };
 
 
@@ -154,12 +161,11 @@ static const char *control_values_input[] = {
 
 
 static const char *control_values_audiomode[] = {
-	[PVR2_CVAL_AUDIOMODE_MONO]   = "Mono",
-	[PVR2_CVAL_AUDIOMODE_STEREO] = "Stereo",
-	[PVR2_CVAL_AUDIOMODE_SAP]    = "SAP",
-	[PVR2_CVAL_AUDIOMODE_LANG1]  = "Lang1",
-	[PVR2_CVAL_AUDIOMODE_LANG2]  = "Lang2",
-	[PVR2_CVAL_AUDIOMODE_LANG1_LANG2] = "Lang1+Lang2",
+	[V4L2_TUNER_MODE_MONO]   = "Mono",
+	[V4L2_TUNER_MODE_STEREO] = "Stereo",
+	[V4L2_TUNER_MODE_LANG1]  = "Lang1",
+	[V4L2_TUNER_MODE_LANG2]  = "Lang2",
+	[V4L2_TUNER_MODE_LANG1_LANG2] = "Lang1+Lang2",
 };
 
 
@@ -174,210 +180,265 @@ static const char *control_values_hsm[] = {
     .value_defs_ptr = x, \
     .value_defs_count = (sizeof(x)/sizeof(x[0]))
 
-static int pvr2_ctl_set_chanprog_id(struct pvr2_hdw *hdw,int ctl_id,int value);
-static int pvr2_ctl_get_chanprog_id(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_get_signal(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_get_streaming(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_get_hsm(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_get_subsys_mask(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_set_subsys_mask(struct pvr2_hdw *hdw,int ctl_id,int val);
-static int pvr2_ctl_get_subsys_stream_mask(struct pvr2_hdw *hdw,int ctl_id);
-static int pvr2_ctl_set_subsys_stream_mask(struct pvr2_hdw *hdw,int ctl_id,
-					   int val);
+static int pvr2_ctl_set_chanprog_id(struct pvr2_ctrl *cptr,int value);
+static int pvr2_ctl_get_chanprog_id(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_get_signal(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_get_streaming(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_get_hsm(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_get_subsys_mask(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_set_subsys_mask(struct pvr2_ctrl *cptr,int val);
+static int pvr2_ctl_get_subsys_stream_mask(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_set_subsys_stream_mask(struct pvr2_ctrl *cptr,int val);
+static int pvr2_ctl_set_stdcur(struct pvr2_ctrl *cptr,int val);
+static int pvr2_ctl_get_stdcur(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_get_stdavail(struct pvr2_ctrl *cptr);
+static int pvr2_ctl_set_stdenumcur(struct pvr2_ctrl *cptr,int val);
+static int pvr2_ctl_get_stdenumcur(struct pvr2_ctrl *cptr);
 
 static struct pvr2_ctl_def control_defs[] =
 {
 	[PVR2_CID_BRIGHTNESS] = {
+		.id = V4L2_CID_BRIGHTNESS,
 		.is_valid = !0,
-		.name = "Brightness",
+		.desc = "Brightness",
+		.name = "brightness",
 		.min_value = 0,
 		.max_value = 255,
 		.default_value = 128,
 	},
 	[PVR2_CID_CONTRAST] = {
+		.id = V4L2_CID_CONTRAST,
 		.is_valid = !0,
-		.name = "Contrast",
+		.desc = "Contrast",
+		.name = "contrast",
 		.min_value = 0,
 		.max_value = 127,
 		.default_value = 68,
 	},
 	[PVR2_CID_SATURATION] = {
+		.id = V4L2_CID_SATURATION,
 		.is_valid = !0,
-		.name = "Saturation",
+		.desc = "Saturation",
+		.name = "saturation",
 		.min_value = 0,
 		.max_value = 127,
 		.default_value = 64,
 	},
 	[PVR2_CID_HUE] = {
+		.id = V4L2_CID_HUE,
 		.is_valid = !0,
-		.name = "Hue",
+		.desc = "Hue",
+		.name = "hue",
 		.min_value = -128,
 		.max_value = 127,
 		.default_value = 0,
 	},
 	[PVR2_CID_VOLUME] = {
+		.id = V4L2_CID_AUDIO_VOLUME,
 		.is_valid = !0,
-		.name = "Volume",
+		.desc = "Volume",
+		.name = "volume",
 		.min_value = 0,
 		.max_value = 65535,
 		.default_value = 65535,
 	},
 	[PVR2_CID_BALANCE] = {
+		.id = V4L2_CID_AUDIO_BALANCE,
 		.is_valid = !0,
-		.name = "Balance",
+		.desc = "Balance",
+		.name = "balance",
 		.min_value = -32768,
 		.max_value = 32767,
 		.default_value = 0,
 	},
 	[PVR2_CID_BASS] = {
+		.id = V4L2_CID_AUDIO_BASS,
 		.is_valid = !0,
-		.name = "Bass",
+		.desc = "Bass",
+		.name = "bass",
 		.min_value = -32768,
 		.max_value = 32767,
 		.default_value = 0,
 	},
 	[PVR2_CID_TREBLE] = {
+		.id = V4L2_CID_AUDIO_TREBLE,
 		.is_valid = !0,
-		.name = "Treble",
+		.desc = "Treble",
+		.name = "treble",
 		.min_value = -32768,
 		.max_value = 32767,
 		.default_value = 0,
 	},
 	[PVR2_CID_MUTE] = {
+		.id = V4L2_CID_AUDIO_MUTE,
 		.is_valid = !0,
-		.name = "Mute",
+		.desc = "Mute",
+		.name = "mute",
 		.min_value = 0,
 		.max_value = 1,
 		.default_value = 0,
 	},
 	[PVR2_CID_SRATE] = {
+		.id = V4L2_CID_PVR_SRATE,
 		.is_valid = !0,
-		.name = "Sample rate",
+		.desc = "Sample rate",
+		.name = "srate",
 		.min_value = PVR2_CVAL_SRATE_MIN,
 		.max_value = PVR2_CVAL_SRATE_MAX,
 		.default_value = PVR2_CVAL_SRATE_48,
 		VDEF(control_values_srate),
 	},
 	[PVR2_CID_AUDIOBITRATE] = {
+		.id = V4L2_CID_PVR_AUDIOBITRATE,
 		.is_valid = !0,
-		.name = "Audio Bitrate",
+		.desc = "Audio Bitrate",
+		.name = "audio_bitrate",
 		.min_value = PVR2_CVAL_AUDIOBITRATE_MIN,
 		.max_value = PVR2_CVAL_AUDIOBITRATE_MAX,
 		.default_value = PVR2_CVAL_AUDIOBITRATE_224,
 		VDEF(control_values_audiobitrate),
 	},
 	[PVR2_CID_AUDIOCRC] = {
+		.id = V4L2_CID_PVR_AUDIOCRC,
 		.is_valid = !0,
-		.name = "Audio CRC",
+		.desc = "Audio CRC",
+		.name = "audio_crc",
 		.min_value = 0,
 		.max_value = 1,
 		.default_value = 1,
 	},
 	[PVR2_CID_AUDIOEMPHASIS] = {
+		.id = V4L2_CID_PVR_AUDIOEMPHASIS,
 		.is_valid = !0,
-		.name = "Audio Emphasis",
+		.desc = "Audio Emphasis",
+		.name = "audio_emphasis",
 		.min_value = PVR2_CVAL_AUDIOEMPHASIS_MIN,
 		.max_value = PVR2_CVAL_AUDIOEMPHASIS_MAX,
 		.default_value = PVR2_CVAL_AUDIOEMPHASIS_NONE,
 		VDEF(control_values_audioemphasis),
 	},
 	[PVR2_CID_VBR] = {
+		.id = V4L2_CID_PVR_VBR,
 		.is_valid = !0,
-		.name = "Variable video bitrate",
+		.desc = "Variable video bitrate",
+		.name = "vbr",
 		.min_value = 0,
 		.max_value = 1,
 		.default_value = 0,
 	},
 	[PVR2_CID_AVERAGEVIDEOBITRATE] = {
+		.id = V4L2_CID_PVR_VIDEOBITRATE,
 		.is_valid = !0,
-		.name = "Average video bitrate",
+		.desc = "Average video bitrate",
+		.name = "video_average_bitrate",
 		.min_value = 1,
 		.max_value = 20000000,
 		.default_value = 6000000,
 	},
 	[PVR2_CID_PEAKVIDEOBITRATE] = {
+		.id = V4L2_CID_PVR_VIDEOPEAK,
 		.is_valid = !0,
-		.name = "Peak video bitrate",
+		.desc = "Peak video bitrate",
+		.name = "video_peak_bitrate",
 		.min_value = 1,
 		.max_value = 20000000,
 		.default_value = 6000000,
 	},
-	[PVR2_CID_VIDEOSTANDARD] = {
+	[PVR2_CID_STDAVAIL] = {
 		.is_valid = !0,
-		.name = "Video Standard",
-		.min_value = PVR2_CVAL_VIDEOSTANDARD_MIN,
-		.max_value = PVR2_CVAL_VIDEOSTANDARD_MAX,
-		.default_value = PVR2_CVAL_VIDEOSTANDARD_NTSC_M,
+		.desc = "Video Standards Available Mask",
+		.name = "video_standard_mask_available",
+		.min_value = 0,
+		.max_value = 0,
+		.default_value = (int)V4L2_STD_UNKNOWN,
+		.mask_value = (int)V4L2_STD_ALL,
+		.get_func = pvr2_ctl_get_stdavail,
 		VDEF(control_values_videostandard),
 	},
 	[PVR2_CID_INPUT] = {
+		.id = V4L2_CID_PVR_INPUT,
 		.is_valid = !0,
-		.name = "Video Source",
+		.desc = "Video Source",
+		.name = "input",
 		.min_value = PVR2_CVAL_INPUT_MIN,
 		.max_value = PVR2_CVAL_INPUT_MAX,
 		.default_value = PVR2_CVAL_INPUT_TV,
 		VDEF(control_values_input),
 	},
 	[PVR2_CID_AUDIOMODE] = {
+		.id = V4L2_CID_PVR_AUDIOMODE,
 		.is_valid = !0,
-		.name = "Audio Mode",
-		.min_value = PVR2_CVAL_AUDIOMODE_MIN,
-		.max_value = PVR2_CVAL_AUDIOMODE_MAX,
-		.default_value = PVR2_CVAL_AUDIOMODE_STEREO,
+		.desc = "Audio Mode",
+		.name = "audio_mode",
+		.min_value = V4L2_TUNER_MODE_MONO,
+		.max_value = V4L2_TUNER_MODE_LANG1_LANG2,
+		.default_value = V4L2_TUNER_MODE_STEREO,
 		VDEF(control_values_audiomode),
 	},
 	[PVR2_CID_FREQUENCY] = {
+		.id = V4L2_CID_PVR_FREQUENCY,
 		.is_valid = !0,
-		.name = "Tuner Frequency (Hz)",
+		.desc = "Tuner Frequency (Hz)",
+		.name = "frequency",
 		.min_value = 55250000L,
 		.max_value = 850000000L,
 		.default_value = 175250000L,
 	},
 	[PVR2_CID_HRES] = {
+		.id = V4L2_CID_PVR_HRES,
 		.is_valid = !0,
-		.name = "Horizontal capture resolution",
+		.desc = "Horizontal capture resolution",
+		.name = "resolution_hor",
 		.min_value = 320,
 		.max_value = 720,
 		.default_value = 720,
 	},
 	[PVR2_CID_VRES] = {
+		.id = V4L2_CID_PVR_VRES,
 		.is_valid = !0,
-		.name = "Vertical capture resolution",
+		.desc = "Vertical capture resolution",
+		.name = "resolution_ver",
 		.min_value = 200,
 		.max_value = 625,
 		.default_value = 480,
 	},
 	[PVR2_CID_INTERLACE] = {
+		.id = V4L2_CID_PVR_INTERLACE,
 		.is_valid = !0,
-		.name = "Interlace mode",
+		.desc = "Interlace mode",
+		.name = "interlace",
 		.min_value = 0,
 		.max_value = 1,
 		.default_value = 0,
 	},
 	[PVR2_CID_AUDIOLAYER] = {
 		.is_valid = !0,
-		.name = "Audio Layer",
+		.desc = "Audio Layer",
+		.name = "audio_layer",
 		.min_value = 0, /* This is all a wild guess */
 		.max_value = 3,
 		.default_value = 2, /* Appears to be all that is supported */
 	},
 	[PVR2_CID_CHANNEL] = {
 		.is_valid = !0,
-		.name = "Channel",
+		.desc = "Channel",
+		.name = "channel",
 		.min_value = 0,
 		.max_value = FREQTABLE_SIZE,
 		.default_value = 0,
 	},
 	[PVR2_CID_CHANPROG_ID] = {
 		.is_valid = !0,
-		.name = "Channel Program ID",
+		.desc = "Channel Program ID",
+		.name = "freq_table_channel",
 		.min_value = 0,
 		.max_value = FREQTABLE_SIZE,
 		.default_value = 0,
 	},
 	[PVR2_CID_CHANPROG_FREQ] = {
 		.is_valid = !0,
-		.name = "Channel Program Frequency",
+		.desc = "Channel Program Frequency",
+		.name = "freq_table_value",
 		.min_value = 55250000L,
 		.max_value = 850000000L,
 		.skip_init = !0,
@@ -386,21 +447,24 @@ static struct pvr2_ctl_def control_defs[] =
 	},
 	[PVR2_CID_SIGNAL_PRESENT] = {
 		.is_valid = !0,
-		.name = "Signal Present",
+		.desc = "Signal Present",
+		.name = "signal_present",
 		.min_value = 0,
 		.max_value = 1,
 		.get_func = pvr2_ctl_get_signal,
 	},
 	[PVR2_CID_STREAMING_ENABLED] = {
 		.is_valid = !0,
-		.name = "Streaming Enabled",
+		.desc = "Streaming Enabled",
+		.name = "streaming_enabled",
 		.min_value = 0,
 		.max_value = 1,
 		.get_func = pvr2_ctl_get_streaming,
 	},
 	[PVR2_CID_HSM] = {
 		.is_valid = !0,
-		.name = "USB Speed",
+		.desc = "USB Speed",
+		.name = "usb_speed",
 		.min_value = PVR2_CVAL_HSM_MIN,
 		.max_value = PVR2_CVAL_HSM_MAX,
 		.get_func = pvr2_ctl_get_hsm,
@@ -408,7 +472,8 @@ static struct pvr2_ctl_def control_defs[] =
 	},
 	[PVR2_CID_SUBSYS_MASK] = {
 		.is_valid = !0,
-		.name = "Subsystem enabled mask",
+		.desc = "Subsystem enabled mask",
+		.name = "debug_subsys_mask",
 		.min_value = 0,
 		.max_value = 0x7fffffff,
 		.skip_init = !0,
@@ -417,18 +482,33 @@ static struct pvr2_ctl_def control_defs[] =
 	},
 	[PVR2_CID_SUBSYS_STREAM_MASK] = {
 		.is_valid = !0,
-		.name = "Subsystem stream mask",
+		.desc = "Subsystem stream mask",
+		.name = "debug_subsys_stream_mask",
 		.min_value = 0,
 		.max_value = 0x7fffffff,
 		.skip_init = !0,
 		.get_func = pvr2_ctl_get_subsys_stream_mask,
 		.set_func = pvr2_ctl_set_subsys_stream_mask,
 	},
+	[PVR2_CID_STDCUR] = {
+		.id = V4L2_CID_PVR_STDCUR,
+		.is_valid = !0,
+		.desc = "Video Standard In Use Mask",
+		.name = "video_standard_mask_active",
+		.min_value = 0,
+		.max_value = 0,
+		.default_value = (int)V4L2_STD_UNKNOWN,
+		.mask_value = (int)V4L2_STD_ALL,
+		.set_func = pvr2_ctl_set_stdcur,
+		.get_func = pvr2_ctl_get_stdcur,
+		VDEF(control_values_videostandard),
+	},
 };
 
 #undef VDEF
 
-#define CTRL_COUNT (sizeof(control_defs)/sizeof(control_defs[0]))
+#define CTRL_DEF_COUNT (sizeof(control_defs)/sizeof(control_defs[0]))
+#define CTRL_COUNT CTRL_DEF_COUNT+1
 
 const char *pvr2_config_get_name(enum pvr2_config cfg)
 {
@@ -978,9 +1058,9 @@ void pvr2_hdw_subsys_stream_bit_chg(struct pvr2_hdw *hdw,
 }
 
 
-static int pvr2_ctl_get_streaming(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_streaming(struct pvr2_ctrl *cptr)
 {
-	return hdw->flag_streaming_enabled != 0;
+	return cptr->hdw->flag_streaming_enabled != 0;
 }
 
 
@@ -1095,6 +1175,7 @@ static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
 {
 	int ret;
 	unsigned int idx;
+	struct pvr2_ctrl *cptr;
 	int reloadFl = 0;
 	if (!reloadFl) {
 		reloadFl = (hdw->usb_intf->cur_altsetting->desc.bNumEndpoints
@@ -1141,9 +1222,11 @@ static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
 	if (!pvr2_hdw_dev_ok(hdw)) return;
 
 	for (idx = 0; idx < CTRL_COUNT; idx++) {
-		if (control_defs[idx].skip_init) continue;
-		pvr2_hdw_set_ctl_value_internal(
-			hdw,idx,control_defs[idx].default_value);
+		cptr = hdw->controls + idx;
+		if (!pvr2_ctrl_is_valid(cptr)) continue;
+		if (cptr->ctl_def->skip_init) continue;
+		pvr2_ctrl_internal_set_value(cptr,
+					     cptr->ctl_def->default_value);
 	}
 
 	pvr2_reset_ctl_endpoints(hdw);
@@ -1172,7 +1255,21 @@ static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
 
 	if (!pvr2_hdw_dev_ok(hdw)) return;
 
-	pvr2_eeprom_set_default_standard(hdw);
+	for (idx = 0; idx < hdw->std_cnt; idx++) {
+		pvr2_trace(PVR2_TRACE_EEPROM,
+			   "Detected video standard %s (from eeprom)",
+			   hdw->std_defs[idx].name);
+	}
+	if (hdw->std_cnt) {
+		pvr2_trace(PVR2_TRACE_EEPROM,
+			   "Initial video standard set to %s"
+			   " (detected from eeprom)",
+			   hdw->std_defs[hdw->std_id].name);
+	} else {
+		pvr2_trace(PVR2_TRACE_EEPROM,
+			   "Unable to select a viable video standard");
+	}
+
 	if (!pvr2_hdw_dev_ok(hdw)) return;
 
 	pvr2_hdw_commit_ctl_internal(hdw);
@@ -1293,11 +1390,35 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
 		   hdw,pvr2_device_names[hdw_type]);
 	if (!hdw) goto fail;
 	memset(hdw,0,sizeof(*hdw));
-	hdw->controls = kmalloc(sizeof(struct pvr2_ctl_state) * CTRL_COUNT,
+
+	// Initialize video standard enum dynamic control
+	hdw->video_std_enum.name = "video_standard";
+	hdw->video_std_enum.desc = "Video Standard Name";
+	hdw->video_std_enum.id = 0; // ?????
+	hdw->video_std_enum.set_func = pvr2_ctl_set_stdenumcur;
+	hdw->video_std_enum.get_func = pvr2_ctl_get_stdenumcur;
+	hdw->video_std_enum.mask_value = 0;
+	hdw->video_std_enum.max_value = 0;
+	hdw->video_std_enum.min_value = 0;
+	hdw->video_std_enum.default_value = 0;
+	hdw->video_std_enum.is_valid = !0;
+
+	hdw->controls = kmalloc(sizeof(struct pvr2_ctrl) * CTRL_COUNT,
 				GFP_KERNEL);
 	if (!hdw->controls) goto fail;
+	memset(hdw->controls,0,sizeof(struct pvr2_ctrl) * CTRL_COUNT);
 	hdw->hdw_type = hdw_type;
 
+	for (idx = 0; idx < CTRL_DEF_COUNT; idx++) {
+		hdw->controls[idx].hdw = hdw;
+		hdw->controls[idx].ctl_def = control_defs + idx;
+		hdw->controls[idx].is_valid =
+			hdw->controls[idx].ctl_def->is_valid;
+	}
+	hdw->controls[PVR2_CID_STDNAME].hdw = hdw;
+	hdw->controls[PVR2_CID_STDNAME].ctl_def = &hdw->video_std_enum;
+	hdw->controls[PVR2_CID_STDNAME].is_valid = !0;
+
 	hdw->eeprom_addr = -1;
 	hdw->unit_number = -1;
 	hdw->v4l_minor_number = -1;
@@ -1425,6 +1546,8 @@ void pvr2_hdw_destroy(struct pvr2_hdw *hdw)
 		}
 	} while (0); up(&pvr2_unit_sem);
 	kfree(hdw->controls);
+	if (hdw->std_defs) kfree(hdw->std_defs);
+	if (hdw->video_std_names) kfree(hdw->video_std_names);
 	kfree(hdw);
 }
 
@@ -1453,10 +1576,11 @@ void pvr2_hdw_disconnect(struct pvr2_hdw *hdw)
 }
 
 
-static int pvr2_ctl_set_chanprog_id(struct pvr2_hdw *hdw,int ctl_id,int value)
+static int pvr2_ctl_set_chanprog_id(struct pvr2_ctrl *cptr,int value)
 {
 	/* This is a special case; the value to store is to an array, and
 	   the element to select is determined by PVR_CID_CHANPROG_ID. */
+	struct pvr2_hdw *hdw = cptr->hdw;
 	int id = hdw->controls[PVR2_CID_CHANPROG_ID].value;
 	if ((id < 1) || (id > FREQTABLE_SIZE)) return 0;
 	hdw->freqTable[id-1] = value;
@@ -1470,149 +1594,584 @@ static int pvr2_ctl_set_chanprog_id(struct pvr2_hdw *hdw,int ctl_id,int value)
 }
 
 
-static int pvr2_ctl_get_chanprog_id(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_chanprog_id(struct pvr2_ctrl *cptr)
 {
 	/* This is a special case; the value to return is from an array,
 	   and the element to select is determined by
 	   PVR_CID_CHANPROG_ID. */
+	struct pvr2_hdw *hdw = cptr->hdw;
 	int id = hdw->controls[PVR2_CID_CHANPROG_ID].value;
 	if ((id < 1) || (id > FREQTABLE_SIZE)) return 0;
 	return hdw->freqTable[id-1];
 }
 
+// Template data for possible enumerated video standards
+static struct v4l2_standard pvr_standards[] = {
+	{
+		.id             = V4L2_STD_PAL_BG,
+		.frameperiod    =
+		{
+			.numerator  = 1,
+			.denominator= 25
+		},
+		.framelines     = 625,
+		.reserved       = {0,0,0,0}
+	}, {
+		.id             = V4L2_STD_PAL_I,
+		.frameperiod    =
+		{
+			.numerator  = 1,
+			.denominator= 25
+		},
+		.framelines     = 625,
+		.reserved       = {0,0,0,0}
+	}, {
+		.id             = V4L2_STD_PAL_DK,
+		.frameperiod    =
+		{
+			.numerator  = 1,
+			.denominator= 25
+		},
+		.framelines     = 625,
+		.reserved       = {0,0,0,0}
+	}, {
+		.id             = V4L2_STD_SECAM,
+		.frameperiod    =
+		{
+			.numerator  = 1,
+			.denominator= 25
+		},
+		.framelines     = 625,
+		.reserved       = {0,0,0,0}
+	}, {
+		.id             = V4L2_STD_NTSC_M,
+		.frameperiod    =
+		{
+			.numerator =  1001,
+			.denominator= 30000
+		},
+		.framelines     = 525,
+		.reserved       = {0,0,0,0}
+	}, {
+		.id             = V4L2_STD_PAL_M,
+		.frameperiod    =
+		{
+			.numerator =  1001,
+			.denominator= 30000
+		},
+		.framelines     = 525,
+		.reserved       = {0,0,0,0}
+	}
+};
+
+#define pvr_standards_cnt (sizeof(pvr_standards)/sizeof(pvr_standards[0]))
+
 
-/* Retrieve current value for a given control */
-int pvr2_hdw_get_ctl_value(struct pvr2_hdw *hdw,unsigned int ctl_id)
+struct name_data {
+	struct v4l2_standard *std;
+	unsigned int bcnt;
+	unsigned int scnt;
+};
+
+static void name_build(struct name_data *dp,const char *str)
 {
-	int ret = 0;
+	if (!dp->bcnt) {
+		dp->bcnt = scnprintf(dp->std->name,
+				     sizeof(dp->std->name)-1,"%s",str);
+		dp->scnt = 0;
+		return;
+	}
+
+	dp->bcnt += scnprintf(dp->std->name+dp->bcnt,
+			      sizeof(dp->std->name)-(1+dp->bcnt),
+			      "%s%s",
+			      (dp->scnt ? "/" : "-"),str);
+	(dp->scnt)++;
+}
+
+// Generate a descriptive name for a given standard
+static void name_bucket(struct v4l2_standard *std)
+{
+	struct name_data nd;
+	nd.std = std;
+	nd.bcnt = 0;
+	if (std->id & (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)) {
+		name_build(&nd,"PAL");
+		if (std->id & V4L2_STD_PAL_B) name_build(&nd,"B");
+		if (std->id & V4L2_STD_PAL_B1) name_build(&nd,"B1");
+		if (std->id & V4L2_STD_PAL_D) name_build(&nd,"D");
+		if (std->id & V4L2_STD_PAL_D1) name_build(&nd,"D1");
+		if (std->id & V4L2_STD_PAL_G) name_build(&nd,"G");
+		if (std->id & V4L2_STD_PAL_H) name_build(&nd,"H");
+		if (std->id & V4L2_STD_PAL_I) name_build(&nd,"I");
+		if (std->id & V4L2_STD_PAL_K) name_build(&nd,"K");
+		if (std->id & V4L2_STD_PAL_M) name_build(&nd,"M");
+		if (std->id & V4L2_STD_PAL_N) name_build(&nd,"N");
+		if (std->id & V4L2_STD_PAL_Nc) name_build(&nd,"Nc");
+		if (std->id & V4L2_STD_PAL_60) name_build(&nd,"60");
+		std->name[nd.bcnt] = 0;
+		return;
+	}
+	if (std->id & (V4L2_STD_NTSC_M|
+		       V4L2_STD_NTSC_M_JP|
+		       V4L2_STD_NTSC_443)) {
+		name_build(&nd,"NTSC");
+		if (std->id & V4L2_STD_NTSC_M) name_build(&nd,"M");
+		if (std->id & V4L2_STD_NTSC_M_JP) name_build(&nd,"Mjp");
+		if (std->id & V4L2_STD_NTSC_443) name_build(&nd,"443");
+		std->name[nd.bcnt] = 0;
+		return;
+	}
+	if (std->id & (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)) {
+		name_build(&nd,"SECAM");
+		if (std->id & V4L2_STD_SECAM_B) name_build(&nd,"B");
+		if (std->id & V4L2_STD_SECAM_D) name_build(&nd,"D");
+		if (std->id & V4L2_STD_SECAM_G) name_build(&nd,"G");
+		if (std->id & V4L2_STD_SECAM_H) name_build(&nd,"H");
+		if (std->id & V4L2_STD_SECAM_K) name_build(&nd,"K");
+		if (std->id & V4L2_STD_SECAM_K1) name_build(&nd,"K1");
+		if (std->id & V4L2_STD_SECAM_L) name_build(&nd,"L");
+		if (std->id & V4L2_STD_SECAM_LC) name_build(&nd,"LC");
+		std->name[nd.bcnt] = 0;
+		return;
+	}
+	std->name[0] = 0;
+}
 
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
 
-	LOCK_TAKE(hdw->big_lock); do {
-		if (control_defs[ctl_id].get_func) {
-			ret = control_defs[ctl_id].get_func(hdw,ctl_id);
-			break;
+// Given a mask of viable video standards to choose from, generate an
+// appropriate array of v4l2_standard data that corresponds to it and set
+// up related state in the driver to match.
+void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw,int arg)
+{
+	v4l2_std_id buckets[pvr_standards_cnt];
+	unsigned int idx1,idx2,std_cnt;
+	v4l2_std_id mmsk,amsk;
+
+	amsk = (v4l2_std_id)arg;
+
+	// Figure out which standard groups we can work with
+	std_cnt = 0;
+	mmsk = 0;
+	for (idx1 = 0; idx1 < pvr_standards_cnt; idx1++) {
+		buckets[idx1] = pvr_standards[idx1].id & amsk;
+		if (!buckets[idx1]) continue;
+		mmsk |= buckets[idx1];
+		amsk &= ~buckets[idx1];
+		std_cnt++;
+	}
+
+	if (amsk) {
+		pvr2_trace(
+			PVR2_TRACE_ERROR_LEGS,
+			"Failed to bucketize the following standards: 0x%llx",
+			amsk);
+	}
+
+	if (hdw->std_defs) {
+		kfree(hdw->std_defs);
+		hdw->std_defs = 0;
+	}
+	if (hdw->video_std_names) {
+		kfree(hdw->video_std_names);
+		hdw->video_std_names = 0;
+	}
+	hdw->std_cnt = 0;
+
+	if (!std_cnt) {
+		pvr2_trace(
+			PVR2_TRACE_ERROR_LEGS,
+			"Failed to identify any viable standard groups");
+		hdw->video_std_avail = 0;
+		pvr2_hdw_internal_set_std_cur(hdw,0);
+		return;
+	}
+
+	if (std_cnt) {
+		// Allocate new video standard array
+		hdw->std_defs = kmalloc(sizeof(struct v4l2_standard) * std_cnt,
+					GFP_KERNEL);
+		hdw->std_cnt = std_cnt;
+		memset(hdw->std_defs,0,sizeof(struct v4l2_standard) * std_cnt);
+		hdw->video_std_names = kmalloc(sizeof(char *) * std_cnt,
+					       GFP_KERNEL);
+		memset(hdw->video_std_names,0,sizeof(char *) * std_cnt);
+		idx2 = 0;
+
+		// Initialize video standard array
+		for (idx1 = 0; idx1 < pvr_standards_cnt; idx1++) {
+			if (!buckets[idx1]) continue;
+			memcpy(hdw->std_defs + idx2,
+			       pvr_standards + idx1,
+			       sizeof(struct v4l2_standard));
+			hdw->std_defs[idx2].id = buckets[idx1];
+			idx2++;
 		}
-		ret = hdw->controls[ctl_id].value;
-	} while(0); LOCK_GIVE(hdw->big_lock);
-	return ret;
+
+		// Generate a name for each known video standard
+		for (idx1 = 0; idx1 < std_cnt; idx1++) {
+			name_bucket(hdw->std_defs + idx1);
+			hdw->video_std_names[idx1] =
+				hdw->std_defs[idx1].name;
+		}
+
+		// Set up the dynamic control for this standard
+		hdw->video_std_enum.value_defs_ptr = hdw->video_std_names;
+		hdw->video_std_enum.value_defs_count = std_cnt;
+	}
+
+	hdw->video_std_avail = mmsk;
+	if (!(hdw->video_std_avail & hdw->video_std_cur)) {
+		// Reselect standard if there isn't one that matches...
+		pvr2_hdw_internal_set_stdenum_cur(hdw,0);
+	}
 }
 
 
-/* Return true if control is writable */
-int pvr2_hdw_get_ctl_rw(struct pvr2_hdw *hdw,unsigned int ctl_id)
+unsigned int pvr2_hdw_get_stdenum_count(struct pvr2_hdw *hdw)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	if (control_defs[ctl_id].get_func && !control_defs[ctl_id].set_func) {
-		return 0;
+	return hdw->std_cnt;
+}
+
+
+const struct v4l2_standard *pvr2_hdw_get_stdenum_value(struct pvr2_hdw *hdw,
+						       unsigned int idx)
+{
+	if (idx >= hdw->std_cnt) return 0;
+	return hdw->std_defs + idx;
+}
+
+
+int pvr2_hdw_internal_set_stdenum_cur(struct pvr2_hdw *hdw,int val)
+{
+	if (val < 0) return -EINVAL;
+	if (val >= hdw->std_cnt) return -EINVAL;
+	pvr2_hdw_internal_set_std_cur(hdw,hdw->std_defs[val].id);
+	return 0;
+}
+
+
+void pvr2_hdw_internal_set_std_cur(struct pvr2_hdw *hdw,int val)
+{
+	unsigned int idx;
+	v4l2_std_id msk,id;
+
+	id = (v4l2_std_id)val;
+	// Only select from available standards
+	id &= hdw->video_std_avail;
+
+	// Only select a single bit
+	for (idx = 0, msk = 1; msk; idx++, msk <<= 1) {
+		if (!(id & msk)) continue;
+		id = msk;
+		break;
 	}
-	return !0;
+
+	// Get out if nothing found
+	if (!msk) return;
+
+	// Fix up standard group now
+	hdw->video_std_cur = id;
+	hdw->controls[PVR2_CID_STDCUR].value = id;
+	hdw->controls[PVR2_CID_STDCUR].dirty = !0;
+	for (idx = 0; idx < hdw->std_cnt; idx++) {
+		if (hdw->std_defs[idx].id & id) {
+			hdw->std_id = idx;
+			return;
+		}
+	}
+
+	// Should never really get here, but just in case...
+	hdw->std_id = 0;
 }
 
 
-/* Retrieve legal minimum value for a given control */
-int pvr2_hdw_get_ctl_min_value(struct pvr2_hdw *hdw,unsigned int ctl_id)
+static int pvr2_ctl_set_stdcur(struct pvr2_ctrl *cptr,int val)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	return control_defs[ctl_id].min_value;
+	pvr2_hdw_internal_set_std_cur(cptr->hdw,val);
+	return 0;
+}
+
+
+static int pvr2_ctl_get_stdcur(struct pvr2_ctrl *cptr)
+{
+	return (int)(cptr->hdw->video_std_cur);
+}
+
+
+static int pvr2_ctl_set_stdenumcur(struct pvr2_ctrl *cptr,int val)
+{
+	if (val < 0) return -EINVAL;
+	if (val >= cptr->hdw->std_cnt) return -EINVAL;
+	cptr->hdw->std_id = val;
+	pvr2_hdw_internal_set_std_cur(cptr->hdw,
+				      cptr->hdw->std_id);
+	return 0;
 }
 
 
-/* Retrieve legal maximum value for a given control */
-int pvr2_hdw_get_ctl_max_value(struct pvr2_hdw *hdw,unsigned int ctl_id)
+static int pvr2_ctl_get_stdenumcur(struct pvr2_ctrl *cptr)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	return control_defs[ctl_id].max_value;
+	return cptr->hdw->std_id;
 }
 
 
-/* Retrieve default value for a given control */
-int pvr2_hdw_get_ctl_default_value(struct pvr2_hdw *hdw,unsigned int ctl_id)
+static int pvr2_ctl_get_stdavail(struct pvr2_ctrl *cptr)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	return control_defs[ctl_id].default_value;
+	return (int)(cptr->hdw->video_std_avail);
 }
 
 
-/* Set current value for given control - normally this is just stored and
-   the hardware isn't updated until the commit function is called. */
-int pvr2_hdw_set_ctl_value_internal(struct pvr2_hdw *hdw,
-				    unsigned int ctl_id,int value)
+/* Get the number of defined controls */
+unsigned int pvr2_hdw_get_ctrl_count(struct pvr2_hdw *hdw)
 {
+	return CTRL_COUNT;
+}
+
+
+/* Retrieve a control handle given its index (0..count-1) */
+struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_index(struct pvr2_hdw *hdw,
+					     unsigned int idx)
+{
+	if (idx < 0) return 0;
+	if (idx >= CTRL_COUNT) return 0;
+	return hdw->controls + idx;
+}
+
+
+/* Given an ID, retrieve the control structure associated with it. */
+struct pvr2_ctrl *pvr2_hdw_get_ctrl(struct pvr2_hdw *hdw,unsigned int ctl_id)
+{
+	struct pvr2_ctrl *cptr;
+	unsigned int idx;
+	int i;
+
+	/* This could be made a lot more efficient, but for now... */
+	for (idx = 0; idx < CTRL_COUNT; idx++) {
+		cptr = hdw->controls + idx;
+		i = cptr->ctl_def->id;
+		if (i && (i == ctl_id)) return cptr;
+	}
+
+	return 0;
+}
+
+
+/* Set the current value of a given control.  This assumes we are already
+   inside our critical region. */
+int pvr2_ctrl_internal_set_value(struct pvr2_ctrl *cptr,int value)
+{
+	const struct pvr2_ctl_def *dptr;
 	int ret;
-	if (ctl_id >= CTRL_COUNT) return -EINVAL;
-	if (!control_defs[ctl_id].is_valid) return -EINVAL;
-	if (value < control_defs[ctl_id].min_value) return -EINVAL;
-	if (value > control_defs[ctl_id].max_value) return -EINVAL;
-	if (control_defs[ctl_id].set_func) {
-		ret = control_defs[ctl_id].set_func(hdw,ctl_id,value);
-		pvr2_i2c_core_check_stale(hdw);
-		pvr2_i2c_core_sync(hdw);
+	if (!cptr) return -EINVAL;
+	if (!cptr->is_valid) return -EINVAL;
+	dptr = cptr->ctl_def;
+	if (!dptr->is_valid) return -EINVAL;
+	if (value < dptr->min_value) return -EINVAL;
+	if (value > dptr->max_value) return -EINVAL;
+	if (dptr->set_func) {
+		ret = dptr->set_func(cptr,value);
+		pvr2_i2c_core_check_stale(cptr->hdw);
+		pvr2_i2c_core_sync(cptr->hdw);
 		return ret;
-	} else if (control_defs[ctl_id].get_func) {
+	} else if (dptr->get_func) {
 		/* If there's no "set" function yet there is still a "get"
 		   function, then treat this as a read-only value. */
 		return -EINVAL;
 	}
-	if ((hdw->controls[ctl_id].value != value) || (ctlchg != 0)) {
-		hdw->controls[ctl_id].value = value;
-		hdw->controls[ctl_id].dirty = !0;
+	if ((cptr->value != value) || (ctlchg != 0)) {
+		cptr->value = value;
+		cptr->dirty = !0;
 	}
 	return 0;
 }
 
 
-/* Set current value for given control - this is just stored; the hardware
-   isn't updated until the commit function is called. */
-int pvr2_hdw_set_ctl_value(struct pvr2_hdw *hdw,unsigned int ctl_id,int value)
+/* Get the current value of a given control.  This assumes that we are
+   already inside our critical region. */
+int pvr2_ctrl_internal_get_value(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	if (!cptr->is_valid) return 0;
+	dptr = cptr->ctl_def;
+	if (!dptr->is_valid) return 0;
+	if (dptr->get_func) {
+		return dptr->get_func(cptr);
+	}
+
+	return cptr->value;
+}
+
+
+/* Set the current value of the given control. */
+int pvr2_ctrl_set_value(struct pvr2_ctrl *cptr,int val)
 {
 	int ret;
-	LOCK_TAKE(hdw->big_lock); do {
-		ret = pvr2_hdw_set_ctl_value_internal(hdw,ctl_id,value);
-	} while (0); LOCK_GIVE(hdw->big_lock);
+	if (!cptr) return -EINVAL;
+	LOCK_TAKE(cptr->hdw->big_lock); do {
+		ret = pvr2_ctrl_internal_set_value(cptr,val);
+	} while(0); LOCK_GIVE(cptr->hdw->big_lock);
 	return ret;
 }
 
 
-/* Retrieve string name for a given control value (returns a null pointer
-   for any invalid combinations). */
-const char *pvr2_hdw_get_ctl_value_name(struct pvr2_hdw *hdw,
-					unsigned int ctl_id,
-					int value)
+/* Get the current value of the given control. */
+int pvr2_ctrl_get_value(struct pvr2_ctrl *cptr)
 {
-	struct pvr2_ctl_def *cdef;
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	cdef = control_defs + ctl_id;
-	if (! cdef->value_defs_ptr) return 0;
-	if (value >= cdef->value_defs_count) return 0;
-	return cdef->value_defs_ptr[value];
+	int ret;
+	if (!cptr) return -EINVAL;
+	LOCK_TAKE(cptr->hdw->big_lock); do {
+		ret = pvr2_ctrl_internal_get_value(cptr);
+	} while(0); LOCK_GIVE(cptr->hdw->big_lock);
+	return ret;
 }
 
 
-/* Retrieve string name for given control */
-const char *pvr2_hdw_get_ctl_name(struct pvr2_hdw *hdw,unsigned int ctl_id)
+/* Return the type of the given control (int, enum, or bit mask). */
+int pvr2_ctrl_get_type(struct pvr2_ctrl *cptr)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
-	return control_defs[ctl_id].name;
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return PVR2_CTRL_TYPE_INVALID;
+	dptr = cptr->ctl_def;
+	if (dptr->mask_value) {
+		return PVR2_CTRL_TYPE_BITMASK;
+	}
+	if (dptr->value_defs_ptr) {
+		return PVR2_CTRL_TYPE_ENUM;
+	}
+	return PVR2_CTRL_TYPE_INT;
 }
 
 
-/* Return true if control ID is a valid id */
-int pvr2_hdw_get_ctl_valid(struct pvr2_hdw *hdw,unsigned int ctl_id)
+/* Return the minimum legal value for a given control.  This command is
+   only relevant for int or enum types. */
+int pvr2_ctrl_get_min_value(struct pvr2_ctrl *cptr)
 {
-	if (ctl_id >= CTRL_COUNT) return 0;
-	if (!control_defs[ctl_id].is_valid) return 0;
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->min_value;
+}
+
+
+/* Return the maximum legal value for a given control.  This command is
+   only relevant for int or enum types. */
+int pvr2_ctrl_get_max_value(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->max_value;
+}
+
+
+/* Return the default value for a given control. */
+int pvr2_ctrl_get_default_value(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->default_value;
+}
+
+
+/* Return a mask of which bits are used within the bit mask of a given
+   control.  This command is only relevant for bit mask types. */
+int pvr2_ctrl_get_mask_value(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->mask_value;
+}
+
+
+/* Return true if this is a valid control. */
+int pvr2_ctrl_is_valid(struct pvr2_ctrl *cptr)
+{
+	if (!cptr) return 0;
+	return cptr->is_valid;
+}
+
+
+/* Return true if the control can be set (otherwise it may only be read,
+   assuming that it is valid). */
+int pvr2_ctrl_is_writeable(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	if (!dptr->is_valid) return 0;
+	if (dptr->set_func) return !0;
+	if (dptr->get_func) return 0;
 	return !0;
 }
 
 
+/* Return the control's name, or null if there isn't a name or the control
+   isn't otherwise valid. */
+const char *pvr2_ctrl_get_name(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->name;
+}
+
+
+/* Return the control's description, or null if there isn't a name or the
+   control isn't otherwise valid. */
+const char *pvr2_ctrl_get_desc(struct pvr2_ctrl *cptr)
+{
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	return dptr->desc;
+}
+
+
+/* Return the name for an enumeration value or bit mask position for the
+   given control.  If the control is not an enumeration or bit mask type,
+   then return null. */
+const char *pvr2_ctrl_get_value_name(struct pvr2_ctrl *cptr,int val)
+{
+	int msk,idx;
+	const struct pvr2_ctl_def *dptr;
+	if (!cptr) return 0;
+	dptr = cptr->ctl_def;
+	if (dptr->mask_value) {
+		for (idx = 0, msk = 1;
+		     (idx < dptr->value_defs_count) && msk;
+		     idx++, msk <<= 1) {
+			if (val & msk) {
+				return dptr->value_defs_ptr[idx];
+			}
+		}
+	} else {
+		val -= dptr->min_value;
+		if (val < 0) return 0;
+		if (val >= dptr->value_defs_count) return 0;
+		return dptr->value_defs_ptr[val];
+	}
+	return 0;
+}
+
+
 /* Commit all control changes made up to this point.  Subsystems can be
    indirectly affected by these changes.  For a given set of things being
    committed, we'll clear the affected subsystem bits and then once we're
@@ -1625,6 +2184,8 @@ int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw)
 	unsigned long saved_subsys_mask = hdw->subsys_enabled_mask;
 	unsigned long stale_subsys_mask = 0;
 	unsigned int idx;
+	const struct pvr2_ctl_def *dptr;
+	struct pvr2_ctrl *cptr;
 	int value;
 	const char *ctl_name;
 	const char *ctl_value;
@@ -1661,16 +2222,17 @@ int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw)
 	}
 
 	for (idx = 0; idx < CTRL_COUNT; idx++) {
-		if (!hdw->controls[idx].dirty) continue;
+		cptr = hdw->controls + idx;
+		if (!cptr->dirty) continue;
 		if (!commit_flag) {
 			commit_flag = !0;
 		}
-		value = hdw->controls[idx].value;
-		ctl_name = control_defs[idx].name;
-		if (control_defs[idx].value_defs_ptr) {
-			if (value < control_defs[idx].value_defs_count) {
-				ctl_value =
-					control_defs[idx].value_defs_ptr[value];
+		value = cptr->value;
+		dptr = cptr->ctl_def;
+		ctl_name = dptr->name;
+		if (dptr->value_defs_ptr) {
+			if (value < dptr->value_defs_count) {
+				ctl_value = dptr->value_defs_ptr[value];
 			} else {
 				ctl_value = "<out of range>";
 			}
@@ -1690,16 +2252,13 @@ int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw)
 	/* When video standard changes, reset the hres and vres values -
 	   but if the user has pending changes there, then let the changes
 	   take priority. */
-	if (hdw->controls[PVR2_CID_VIDEOSTANDARD].dirty) {
+	if (hdw->controls[PVR2_CID_STDCUR].dirty) {
 		/* Rewrite the vertical resolution to be appropriate to the
 		   video standard that has been selected. */
-		int nvres = hdw->controls[PVR2_CID_VRES].value;
-		switch (hdw->controls[PVR2_CID_VIDEOSTANDARD].value) {
-		case PVR2_CVAL_VIDEOSTANDARD_NTSC_M:
-		case PVR2_CVAL_VIDEOSTANDARD_PAL_M:
+		int nvres;
+		if (hdw->video_std_cur & V4L2_STD_525_60) {
 			nvres = 480;
-			break;
-		default:
+		} else {
 			nvres = 576;
 		}
 		if (nvres != hdw->controls[PVR2_CID_VRES].value) {
@@ -1712,7 +2271,7 @@ int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw)
 		}
 	}
 
-	if (hdw->controls[PVR2_CID_VIDEOSTANDARD].dirty ||
+	if (hdw->controls[PVR2_CID_STDCUR].dirty ||
 	    hdw->controls[PVR2_CID_VRES].dirty ||
 	    hdw->controls[PVR2_CID_HRES].dirty ||
 	    hdw->controls[PVR2_CID_INTERLACE].dirty ||
@@ -1737,7 +2296,8 @@ int pvr2_hdw_commit_ctl_internal(struct pvr2_hdw *hdw)
 	pvr2_i2c_core_check_stale(hdw);
 
 	for (idx = 0; idx < CTRL_COUNT; idx++) {
-		hdw->controls[idx].dirty = 0;
+		cptr = hdw->controls + idx;
+		cptr->dirty = 0;
 	}
 
 	/* Now execute i2c core update */
@@ -1794,14 +2354,6 @@ void pvr2_hdw_poll_trigger(struct pvr2_hdw *hdw)
 }
 
 
-/* Find out how many controls there are.  Legal ids are numbered from 1
-   through this value. */
-unsigned int pvr2_hdw_get_ctl_count(struct pvr2_hdw *hdw)
-{
-	return CTRL_COUNT;
-}
-
-
 /* Return name for this driver instance */
 const char *pvr2_hdw_get_driver_name(struct pvr2_hdw *hdw)
 {
@@ -1837,36 +2389,36 @@ unsigned int pvr2_hdw_get_signal_status_internal(struct pvr2_hdw *hdw)
 }
 
 
-static int pvr2_ctl_get_subsys_mask(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_subsys_mask(struct pvr2_ctrl *cptr)
 {
-	return hdw->subsys_enabled_mask;
+	return cptr->hdw->subsys_enabled_mask;
 }
 
 
-static int pvr2_ctl_set_subsys_mask(struct pvr2_hdw *hdw,int ctl_id,int val)
+static int pvr2_ctl_set_subsys_mask(struct pvr2_ctrl *cptr,int val)
 {
-	pvr2_hdw_subsys_bit_chg_no_lock(hdw,~0,val);
+	pvr2_hdw_subsys_bit_chg_no_lock(cptr->hdw,~0,val);
 	return 0;
 }
 
 
-static int pvr2_ctl_get_subsys_stream_mask(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_subsys_stream_mask(struct pvr2_ctrl *cptr)
 {
-	return hdw->subsys_stream_mask;
+	return cptr->hdw->subsys_stream_mask;
 }
 
 
-static int pvr2_ctl_set_subsys_stream_mask(struct pvr2_hdw *hdw,int ctl_id,
+static int pvr2_ctl_set_subsys_stream_mask(struct pvr2_ctrl *cptr,
 					   int val)
 {
-	pvr2_hdw_subsys_stream_bit_chg_no_lock(hdw,~0,val);
+	pvr2_hdw_subsys_stream_bit_chg_no_lock(cptr->hdw,~0,val);
 	return 0;
 }
 
 
-static int pvr2_ctl_get_hsm(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_hsm(struct pvr2_ctrl *cptr)
 {
-	int result = pvr2_hdw_is_hsm(hdw);
+	int result = pvr2_hdw_is_hsm(cptr->hdw);
 	if (result < 0) return PVR2_CVAL_HSM_FAIL;
 	if (result) return PVR2_CVAL_HSM_HIGH;
 	return PVR2_CVAL_HSM_FULL;
@@ -1888,10 +2440,10 @@ int pvr2_hdw_is_hsm(struct pvr2_hdw *hdw)
 }
 
 
-static int pvr2_ctl_get_signal(struct pvr2_hdw *hdw,int ctl_id)
+static int pvr2_ctl_get_signal(struct pvr2_ctrl *cptr)
 {
-	return ((pvr2_hdw_get_signal_status_internal(hdw) & PVR2_SIGNAL_OK) ?
-		1 : 0);
+	return ((pvr2_hdw_get_signal_status_internal(cptr->hdw) &
+		 PVR2_SIGNAL_OK) ? 1 : 0);
 }
 
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.h b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.h
index d7749138c..4101f4097 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.h
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-hdw.h
@@ -21,86 +21,37 @@
 #ifndef __PVRUSB2_HDW_H
 #define __PVRUSB2_HDW_H
 
+#include "compat.h"
 #include <linux/usb.h>
+#include <linux/videodev2.h>
 #include "pvrusb2-io.h"
 
-/* Definition of state variables that we can inspect & change.  Numbers are
-   assigned from zero counting up with no gaps. */
-#define PVR2_CID_BRIGHTNESS 0
-#define PVR2_CID_CONTRAST 1
-#define PVR2_CID_SATURATION 2
-#define PVR2_CID_HUE 3
-#define PVR2_CID_VOLUME 4
-#define PVR2_CID_BALANCE 5
-#define PVR2_CID_BASS 6
-#define PVR2_CID_TREBLE 7
-#define PVR2_CID_MUTE 8
-#define PVR2_CID_SRATE 9
-#define PVR2_CID_AUDIOBITRATE 10
-#define PVR2_CID_AUDIOCRC 11
-#define PVR2_CID_AUDIOEMPHASIS 12
-#define PVR2_CID_VBR 13
-#define PVR2_CID_AVERAGEVIDEOBITRATE 14
-#define PVR2_CID_PEAKVIDEOBITRATE 15
-#define PVR2_CID_VIDEOSTANDARD 16
-#define PVR2_CID_INPUT 17
-#define PVR2_CID_AUDIOMODE 18
-#define PVR2_CID_FREQUENCY 19 // Units of Hz
-#define PVR2_CID_HRES 20
-#define PVR2_CID_VRES 21
-#define PVR2_CID_INTERLACE 22
-#define PVR2_CID_AUDIOLAYER 23
-#define PVR2_CID_CHANNEL 24
-#define PVR2_CID_CHANPROG_ID 25
-#define PVR2_CID_CHANPROG_FREQ 26
-#define PVR2_CID_SIGNAL_PRESENT 27
-#define PVR2_CID_STREAMING_ENABLED 28
-#define PVR2_CID_HSM 29
-#define PVR2_CID_SUBSYS_MASK 30
-#define PVR2_CID_SUBSYS_STREAM_MASK 31
-
-/* Legal values for the SRATE state variable */
-#define PVR2_CVAL_SRATE_48 0
-#define PVR2_CVAL_SRATE_44_1 1
-#define PVR2_CVAL_SRATE_MIN PVR2_CVAL_SRATE_48
-#define PVR2_CVAL_SRATE_MAX PVR2_CVAL_SRATE_44_1
-
-/* Legal values for the AUDIOBITRATE state variable */
-#define PVR2_CVAL_AUDIOBITRATE_384 0
-#define PVR2_CVAL_AUDIOBITRATE_320 1
-#define PVR2_CVAL_AUDIOBITRATE_256 2
-#define PVR2_CVAL_AUDIOBITRATE_224 3
-#define PVR2_CVAL_AUDIOBITRATE_192 4
-#define PVR2_CVAL_AUDIOBITRATE_160 5
-#define PVR2_CVAL_AUDIOBITRATE_128 6
-#define PVR2_CVAL_AUDIOBITRATE_112 7
-#define PVR2_CVAL_AUDIOBITRATE_96 8
-#define PVR2_CVAL_AUDIOBITRATE_80 9
-#define PVR2_CVAL_AUDIOBITRATE_64 10
-#define PVR2_CVAL_AUDIOBITRATE_56 11
-#define PVR2_CVAL_AUDIOBITRATE_48 12
-#define PVR2_CVAL_AUDIOBITRATE_32 13
-#define PVR2_CVAL_AUDIOBITRATE_VBR 14
-#define PVR2_CVAL_AUDIOBITRATE_MIN PVR2_CVAL_AUDIOBITRATE_384
-#define PVR2_CVAL_AUDIOBITRATE_MAX PVR2_CVAL_AUDIOBITRATE_VBR
-
-/* Legal values for the AUDIOEMPHASIS state variable */
-#define PVR2_CVAL_AUDIOEMPHASIS_NONE 0
-#define PVR2_CVAL_AUDIOEMPHASIS_50_15 1
-#define PVR2_CVAL_AUDIOEMPHASIS_CCITT 2
-#define PVR2_CVAL_AUDIOEMPHASIS_MIN PVR2_CVAL_AUDIOEMPHASIS_NONE
-#define PVR2_CVAL_AUDIOEMPHASIS_MAX PVR2_CVAL_AUDIOEMPHASIS_CCITT
-
-/* Legal values for the VIDEOSTANDARD state variable */
-#define PVR2_CVAL_VIDEOSTANDARD_NTSC_M 0
-#define PVR2_CVAL_VIDEOSTANDARD_PAL_BG 1
-#define PVR2_CVAL_VIDEOSTANDARD_PAL_I 2
-#define PVR2_CVAL_VIDEOSTANDARD_PAL_DK 3
-#define PVR2_CVAL_VIDEOSTANDARD_PAL_M 4
-#define PVR2_CVAL_VIDEOSTANDARD_SECAM_L 5
-
-#define PVR2_CVAL_VIDEOSTANDARD_MIN PVR2_CVAL_VIDEOSTANDARD_NTSC_M
-#define PVR2_CVAL_VIDEOSTANDARD_MAX PVR2_CVAL_VIDEOSTANDARD_SECAM_L
+#define PVR2_CTRL_TYPE_INVALID 0
+#define PVR2_CTRL_TYPE_ENUM 1
+#define PVR2_CTRL_TYPE_INT 2
+#define PVR2_CTRL_TYPE_BITMASK 3
+
+/* Private V4L2-compatible controls available in this driver */
+#define V4L2_CID_PVR_SRATE          (V4L2_CID_PRIVATE_BASE)
+#define V4L2_CID_PVR_AUDIOBITRATE   (V4L2_CID_PRIVATE_BASE+1)
+#define V4L2_CID_PVR_AUDIOCRC       (V4L2_CID_PRIVATE_BASE+2)
+#define V4L2_CID_PVR_AUDIOEMPHASIS  (V4L2_CID_PRIVATE_BASE+3)
+#define V4L2_CID_PVR_VBR            (V4L2_CID_PRIVATE_BASE+4)
+#define V4L2_CID_PVR_VIDEOBITRATE   (V4L2_CID_PRIVATE_BASE+5)
+#define V4L2_CID_PVR_VIDEOPEAK      (V4L2_CID_PRIVATE_BASE+6)
+#define V4L2_CID_PVR_VIDEOSTANDARD  (V4L2_CID_PRIVATE_BASE+7)
+
+/* Deliberate gap for CIDs we don't want apps to discover */
+#define V4L2_CID_PVR_GAP            (V4L2_CID_PRIVATE_BASE+8)
+
+/* Additional explicit controls needed by V4L2 ioctl implementation */
+#define V4L2_CID_PVR_STDCUR         (V4L2_CID_PVR_GAP+1)
+#define V4L2_CID_PVR_INPUT          (V4L2_CID_PVR_GAP+2)
+#define V4L2_CID_PVR_AUDIOMODE      (V4L2_CID_PVR_GAP+3)
+#define V4L2_CID_PVR_FREQUENCY      (V4L2_CID_PVR_GAP+4)
+#define V4L2_CID_PVR_HRES           (V4L2_CID_PVR_GAP+5)
+#define V4L2_CID_PVR_VRES           (V4L2_CID_PVR_GAP+6)
+#define V4L2_CID_PVR_INTERLACE      (V4L2_CID_PVR_GAP+7)
 
 /* Legal values for the INPUT state variable */
 #define PVR2_CVAL_INPUT_TV 0
@@ -110,27 +61,11 @@
 #define PVR2_CVAL_INPUT_MIN PVR2_CVAL_INPUT_TV
 #define PVR2_CVAL_INPUT_MAX PVR2_CVAL_INPUT_RADIO
 
-/* Legal values for the AUDIOMODE state variable */
-#define PVR2_CVAL_AUDIOMODE_MONO 0
-#define PVR2_CVAL_AUDIOMODE_STEREO 1
-#define PVR2_CVAL_AUDIOMODE_SAP 2
-#define PVR2_CVAL_AUDIOMODE_LANG1 3
-#define PVR2_CVAL_AUDIOMODE_LANG2 4
-#define PVR2_CVAL_AUDIOMODE_LANG1_LANG2 5
-#define PVR2_CVAL_AUDIOMODE_MIN PVR2_CVAL_AUDIOMODE_MONO
-#define PVR2_CVAL_AUDIOMODE_MAX PVR2_CVAL_AUDIOMODE_LANG1_LANG2
-
 /* Values that pvr2_hdw_get_signal_status() returns */
 #define PVR2_SIGNAL_OK     0x0001
 #define PVR2_SIGNAL_STEREO 0x0002
 #define PVR2_SIGNAL_SAP    0x0004
 
-/* Legal values for PVR2_CID_HSM */
-#define PVR2_CVAL_HSM_FAIL 0
-#define PVR2_CVAL_HSM_FULL 1
-#define PVR2_CVAL_HSM_HIGH 2
-#define PVR2_CVAL_HSM_MIN PVR2_CVAL_HSM_FAIL
-#define PVR2_CVAL_HSM_MAX PVR2_CVAL_HSM_HIGH
 
 /* Subsystem definitions - these are various pieces that can be
    independently stopped / started.  Usually you don't want to mess with
@@ -164,6 +99,8 @@ const char *pvr2_config_get_name(enum pvr2_config);
 
 struct pvr2_hdw;
 
+struct pvr2_ctrl;
+
 /* Create and return a structure for interacting with the underlying
    hardware */
 struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
@@ -212,43 +149,69 @@ unsigned long pvr2_hdw_get_sn(struct pvr2_hdw *);
 /* Called when hardware has been unplugged */
 void pvr2_hdw_disconnect(struct pvr2_hdw *);
 
-/* Retrieve current value for a given control */
-int pvr2_hdw_get_ctl_value(struct pvr2_hdw *,unsigned int ctl_id);
+/* Get the number of defined controls */
+unsigned int pvr2_hdw_get_ctrl_count(struct pvr2_hdw *);
+
+/* Retrieve a control handle given its index (0..count-1) */
+struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_index(struct pvr2_hdw *,unsigned int);
+
+/* Retrieve a control handle given its well known ID */
+struct pvr2_ctrl *pvr2_hdw_get_ctrl(struct pvr2_hdw *,unsigned int ctl_id);
+
+/* Set the current value of the given control. */
+int pvr2_ctrl_set_value(struct pvr2_ctrl *,int val);
+
+/* Get the current value of the given control. */
+int pvr2_ctrl_get_value(struct pvr2_ctrl *);
 
-/* Return true if control is writable */
-int pvr2_hdw_get_ctl_rw(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return the type of the given control (int, enum, or bit mask). */
+int pvr2_ctrl_get_type(struct pvr2_ctrl *);
 
-/* Retrieve legal minimum value for a given control */
-int pvr2_hdw_get_ctl_min_value(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return the minimum legal value for a given control.  This command is
+   only relevant for int or enum types. */
+int pvr2_ctrl_get_min_value(struct pvr2_ctrl *);
 
-/* Retrieve legal maximum value for a given control */
-int pvr2_hdw_get_ctl_max_value(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return the maximum legal value for a given control.  This command is
+   only relevant for int or enum types. */
+int pvr2_ctrl_get_max_value(struct pvr2_ctrl *);
 
-/* Retrieve legal maximum value for a given control */
-int pvr2_hdw_get_ctl_default_value(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return a mask of which bits are used within the bit mask of a given
+   control.  This command is only relevant for bit mask types. */
+int pvr2_ctrl_get_mask_value(struct pvr2_ctrl *);
 
-/* Set current value for given control - this is just stored; the hardware
-   isn't updated until the commit function is called. */
-int pvr2_hdw_set_ctl_value(struct pvr2_hdw *,unsigned int ctl_id,int value);
+/* Return the default value for a given control. */
+int pvr2_ctrl_get_default_value(struct pvr2_ctrl *);
 
-/* Retrieve string name for given control */
-const char *pvr2_hdw_get_ctl_name(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return true if this is a valid control. */
+int pvr2_ctrl_is_valid(struct pvr2_ctrl *);
 
-/* Return true if control id is a valid id */
-int pvr2_hdw_get_ctl_valid(struct pvr2_hdw *,unsigned int ctl_id);
+/* Return true if the control can be set (otherwise it may only be read,
+   assuming that it is valid). */
+int pvr2_ctrl_is_writeable(struct pvr2_ctrl *);
 
-/* Retrieve string name for a given control value (returns a null pointer
-   for any invalid combinations). */
-const char *pvr2_hdw_get_ctl_value_name(struct pvr2_hdw *,
-					unsigned int ctl_id,int value);
+/* Return the control's name, or null if there isn't a name or the control
+   isn't otherwise valid. */
+const char *pvr2_ctrl_get_name(struct pvr2_ctrl *);
+
+/* Return the control's description, or null if there isn't a name or the
+   control isn't otherwise valid. */
+const char *pvr2_ctrl_get_desc(struct pvr2_ctrl *);
+
+/* Return the name for an enumeration value or bit mask position for the
+   given control.  If the control is not an enumeration or bit mask type,
+   then return null. */
+const char *pvr2_ctrl_get_value_name(struct pvr2_ctrl *,int val);
+
+/* Return the number of support standard groups */
+unsigned int pvr2_hdw_get_stdenum_count(struct pvr2_hdw *);
+
+/* Return a pointer to a v4l2 standard descriptor for a given group */
+const struct v4l2_standard *pvr2_hdw_get_stdenum_value(struct pvr2_hdw *,
+						       unsigned int idx);
 
 /* Commit all control changes made up to this point */
 int pvr2_hdw_commit_ctl(struct pvr2_hdw *);
 
-/* Find out how many controls there are.  Legal ids are numbered from 0
-   through this value - 1. */
-unsigned int pvr2_hdw_get_ctl_count(struct pvr2_hdw *);
-
 /* Return name for this driver instance */
 const char *pvr2_hdw_get_driver_name(struct pvr2_hdw *);
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-i2c-cmd-v4l2.c b/linux/drivers/media/video/pvrusb2/pvrusb2-i2c-cmd-v4l2.c
index 000c26911..b3d2ce926 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-i2c-cmd-v4l2.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-i2c-cmd-v4l2.c
@@ -24,43 +24,23 @@
 #include "pvrusb2-hdw-internal.h"
 #include "pvrusb2-debug.h"
 #include <linux/videodev.h>
+#include <linux/videodev2.h>
 
 
 static void set_standard(struct pvr2_hdw *hdw)
 {
-	int cvstd = hdw->controls[PVR2_CID_VIDEOSTANDARD].value;
 	v4l2_std_id vs;
+	vs = hdw->controls[PVR2_CID_STDCUR].value;
 	pvr2_trace(PVR2_TRACE_CHIPS,
-		   "i2c v4l2 set_standard(%d)",cvstd);
-
-	switch (cvstd) {
-	default:
-	case PVR2_CVAL_VIDEOSTANDARD_NTSC_M:
-		vs = V4L2_STD_NTSC_M;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_SECAM_L:
-		vs = V4L2_STD_SECAM;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_PAL_BG:
-		vs = V4L2_STD_PAL_BG;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_PAL_I:
-		vs = V4L2_STD_PAL_I;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_PAL_DK:
-		vs = V4L2_STD_PAL_DK;
-		break;
-	case PVR2_CVAL_VIDEOSTANDARD_PAL_M:
-		vs = V4L2_STD_PAL_M;
-		break;
-	}
+		   "i2c v4l2 set_standard(0x%llx)",(__u64)vs);
+
 	pvr2_i2c_core_cmd(hdw,VIDIOC_S_STD,&vs);
 }
 
 
 static int check_standard(struct pvr2_hdw *hdw)
 {
-	return hdw->controls[PVR2_CID_VIDEOSTANDARD].dirty != 0;
+	return hdw->controls[PVR2_CID_STDCUR].dirty != 0;
 }
 
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-sysfs.c b/linux/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
index 6b81def26..0ded41fcb 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
@@ -30,41 +30,6 @@
 
 #define pvr2_sysfs_trace(...) pvr2_trace(PVR2_TRACE_SYSFS,__VA_ARGS__)
 
-static char *item_names[] = {
-	[PVR2_CID_BRIGHTNESS] = "ctl_brightness",
-	[PVR2_CID_CONTRAST] = "ctl_contrast",
-	[PVR2_CID_SATURATION] = "ctl_saturation",
-	[PVR2_CID_HUE] = "ctl_hue",
-	[PVR2_CID_VOLUME] = "ctl_volume",
-	[PVR2_CID_BALANCE] = "ctl_balance",
-	[PVR2_CID_BASS] = "ctl_bass",
-	[PVR2_CID_TREBLE] = "ctl_treble",
-	[PVR2_CID_MUTE] = "ctl_mute",
-	[PVR2_CID_SRATE] = "ctl_srate",
-	[PVR2_CID_AUDIOBITRATE] = "ctl_audio_bitrate",
-	[PVR2_CID_AUDIOCRC] = "ctl_audio_crc",
-	[PVR2_CID_AUDIOEMPHASIS] = "ctl_audio_emphasis",
-	[PVR2_CID_VBR] = "ctl_vbr",
-	[PVR2_CID_AVERAGEVIDEOBITRATE] = "ctl_video_average_bitrate",
-	[PVR2_CID_PEAKVIDEOBITRATE] = "ctl_video_peak_bitrate",
-	[PVR2_CID_VIDEOSTANDARD] = "ctl_video_standard",
-	[PVR2_CID_INPUT] = "ctl_input",
-	[PVR2_CID_AUDIOMODE] = "ctl_audio_mode",
-	[PVR2_CID_FREQUENCY] = "ctl_frequency",
-	[PVR2_CID_HRES] = "ctl_resolution_hor",
-	[PVR2_CID_VRES] = "ctl_resolution_ver",
-	[PVR2_CID_INTERLACE] = "ctl_interlace",
-	[PVR2_CID_AUDIOLAYER] = "ctl_audio_layer",
-	[PVR2_CID_CHANNEL] = "ctl_channel",
-	[PVR2_CID_CHANPROG_ID] = "ctl_freq_table_channel",
-	[PVR2_CID_CHANPROG_FREQ] = "ctl_freq_table_value",
-	[PVR2_CID_SIGNAL_PRESENT] = "ctl_signal_present",
-	[PVR2_CID_STREAMING_ENABLED] = "ctl_streaming_enabled",
-	[PVR2_CID_HSM] = "ctl_usb_speed",
-	[PVR2_CID_SUBSYS_MASK] = "ctl_debug_subsys_mask",
-	[PVR2_CID_SUBSYS_STREAM_MASK] = "ctl_debug_subsys_stream_mask",
-};
-
 struct pvr2_sysfs {
 	struct pvr2_channel channel;
 	struct class_device *class_dev;
@@ -88,11 +53,12 @@ struct pvr2_sysfs_ctl_item {
 	struct class_device_attribute attr_max;
 	struct class_device_attribute attr_enum;
 	struct class_device_attribute attr_val;
-	int attr_id;
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *chptr;
 	struct pvr2_sysfs_ctl_item *item_next;
 	struct attribute *attr_gen[5];
 	struct attribute_group grp;
+	char name[25];
 };
 
 struct pvr2_sysfs_class {
@@ -101,13 +67,16 @@ struct pvr2_sysfs_class {
 
 static ssize_t show_name(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	const char *name;
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	name = pvr2_hdw_get_ctl_name(sfp->channel.hdw,id);
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
 
+	name = pvr2_ctrl_get_desc(cptr);
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_name(cid=%d) is %s",sfp,id,name);
 
 	if (!name) return -EINVAL;
@@ -117,13 +86,15 @@ static ssize_t show_name(int id,struct class_device *class_dev,char *buf)
 
 static ssize_t show_min(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	int val;
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	val = pvr2_hdw_get_ctl_min_value(sfp->channel.hdw,id);
-
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
+	val = pvr2_ctrl_get_min_value(cptr);
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_min(cid=%d) is %d",sfp,id,val);
 
 	return scnprintf(buf,PAGE_SIZE,"%d\n",val);
@@ -131,12 +102,15 @@ static ssize_t show_min(int id,struct class_device *class_dev,char *buf)
 
 static ssize_t show_max(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	int val;
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	val = pvr2_hdw_get_ctl_max_value(sfp->channel.hdw,id);
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
+	val = pvr2_ctrl_get_max_value(cptr);
 
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_max(cid=%d) is %d",sfp,id,val);
 
@@ -145,12 +119,15 @@ static ssize_t show_max(int id,struct class_device *class_dev,char *buf)
 
 static ssize_t show_val_int(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	int val;
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	val = pvr2_hdw_get_ctl_value(sfp->channel.hdw,id);
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
+	val = pvr2_ctrl_get_value(cptr);
 
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_int(cid=%d) is %d",
 			 sfp,id,val);
@@ -160,15 +137,18 @@ static ssize_t show_val_int(int id,struct class_device *class_dev,char *buf)
 
 static ssize_t show_val_enum(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	int val;
 	const char *name;
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	val = pvr2_hdw_get_ctl_value(sfp->channel.hdw,id);
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
 
-	name = pvr2_hdw_get_ctl_value_name(sfp->channel.hdw,id,val);
+	val = pvr2_ctrl_get_value(cptr);
+	name = pvr2_ctrl_get_value_name(cptr,val);
 
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_enum(cid=%d) is %s (%d)",
 			 sfp,id,name,val);
@@ -178,6 +158,7 @@ static ssize_t show_val_enum(int id,struct class_device *class_dev,char *buf)
 
 static ssize_t show_enum(int id,struct class_device *class_dev,char *buf)
 {
+	struct pvr2_ctrl *cptr;
 	struct pvr2_sysfs *sfp;
 	int minval,maxval,val;
 	const char *name;
@@ -185,10 +166,12 @@ static ssize_t show_enum(int id,struct class_device *class_dev,char *buf)
 
 	sfp = (struct pvr2_sysfs *)class_dev->class_data;
 	if (!sfp) return -EINVAL;
-	minval = pvr2_hdw_get_ctl_min_value(sfp->channel.hdw,id);
-	maxval = pvr2_hdw_get_ctl_max_value(sfp->channel.hdw,id);
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
+	minval = pvr2_ctrl_get_min_value(cptr);
+	maxval = pvr2_ctrl_get_max_value(cptr);
 	for (val = minval; val <= maxval; val++) {
-		name = pvr2_hdw_get_ctl_value_name(sfp->channel.hdw,id,val);
+		name = pvr2_ctrl_get_value_name(cptr,val);
 		cnt += scnprintf(buf+cnt,PAGE_SIZE-cnt,"%s\n",name);
 	}
 	pvr2_sysfs_trace("pvr2_sysfs(%p) show_enum(cid=%d)",sfp,id);
@@ -198,6 +181,7 @@ static ssize_t show_enum(int id,struct class_device *class_dev,char *buf)
 static int store_val_any(int id,struct pvr2_sysfs *sfp,
 			 const char *buf,unsigned int count)
 {
+	struct pvr2_ctrl *cptr;
 	int val,minval,maxval;
 	int ch,ret;
 	const char *nv;
@@ -217,11 +201,14 @@ static int store_val_any(int id,struct pvr2_sysfs *sfp,
 		count--;
 	}
 
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
+	if (!pvr2_ctrl_is_valid(cptr)) return -EINVAL;
+
 	/* Is this an enum?  Look for a string value */
-	minval = pvr2_hdw_get_ctl_min_value(sfp->channel.hdw,id);
-	maxval = pvr2_hdw_get_ctl_max_value(sfp->channel.hdw,id);
+	minval = pvr2_ctrl_get_min_value(cptr);
+	maxval = pvr2_ctrl_get_max_value(cptr);
 	for (val = minval; val <= maxval; val++) {
-		nv = pvr2_hdw_get_ctl_value_name(sfp->channel.hdw,id,val);
+		nv = pvr2_ctrl_get_value_name(cptr,val);
 		if ((!nv) && (val == minval)) break; /* Not an enum */
 		pvr2_sysfs_trace("pvr2_sysfs(%p) trying ctl_id %d val %d",
 				 sfp,id,val);
@@ -246,7 +233,7 @@ static int store_val_any(int id,struct pvr2_sysfs *sfp,
 		pvr2_sysfs_trace("pvr2_sysfs(%p) store_val_any(cid=%d)"
 				 " is enum %s",
 				 sfp,id,nv);
-		ret = pvr2_hdw_set_ctl_value(sfp->channel.hdw,id,val);
+		ret = pvr2_ctrl_set_value(cptr,val);
 		pvr2_hdw_commit_ctl(sfp->channel.hdw);
 		return 0;
 	}
@@ -284,7 +271,7 @@ static int store_val_any(int id,struct pvr2_sysfs *sfp,
 				 " int is %d",
 				 sfp,id,val);
 
-		ret = pvr2_hdw_set_ctl_value(sfp->channel.hdw,id,val);
+		ret = pvr2_ctrl_set_value(cptr,val);
 		pvr2_hdw_commit_ctl(sfp->channel.hdw);
 		return ret;
 	}
@@ -395,6 +382,8 @@ CREATE_BATCH(28)
 CREATE_BATCH(29)
 CREATE_BATCH(30)
 CREATE_BATCH(31)
+CREATE_BATCH(32)
+CREATE_BATCH(33)
 
 struct pvr2_sysfs_func_set {
 	ssize_t (*show_name)(struct class_device *,char *);
@@ -454,6 +443,8 @@ static struct pvr2_sysfs_func_set funcs[] = {
 	INIT_BATCH(29),
 	INIT_BATCH(30),
 	INIT_BATCH(31),
+	INIT_BATCH(32),
+	INIT_BATCH(33),
 };
 
 
@@ -461,19 +452,23 @@ static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
 {
 	struct pvr2_sysfs_ctl_item *cip;
 	struct pvr2_sysfs_func_set *fp;
+	struct pvr2_ctrl *cptr;
+	unsigned int cnt;
 
 	if ((ctl_id < 0) || (ctl_id >= (sizeof(funcs)/sizeof(funcs[0])))) {
 		return;
 	}
 
 	fp = funcs + ctl_id;
+	cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,ctl_id);
+	if (!cptr) return;
 
 	cip = kmalloc(sizeof(*cip),GFP_KERNEL);
 	if (!cip) return;
 	memset(cip,0,sizeof(*cip));
 	pvr2_sysfs_trace("Creating pvr2_sysfs_ctl_item id=%p",cip);
 
-	cip->attr_id = ctl_id;
+	cip->cptr = cptr;
 
 	cip->chptr = sfp;
 	cip->item_next = 0;
@@ -508,15 +503,13 @@ static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
 	cip->attr_enum.attr.mode = S_IRUGO;
 	cip->attr_enum.show = fp->show_enum;
 
-	if (pvr2_hdw_get_ctl_rw(sfp->channel.hdw,ctl_id)) {
+	if (pvr2_ctrl_is_writeable(cptr)) {
 		cip->attr_val.attr.mode |= S_IWUSR|S_IWGRP;
 	}
 
 	cip->attr_gen[0] = &cip->attr_name.attr;
 	cip->attr_gen[1] = &cip->attr_val.attr;
-	if (pvr2_hdw_get_ctl_value_name(
-		    sfp->channel.hdw,ctl_id,
-		    pvr2_hdw_get_ctl_min_value(sfp->channel.hdw,ctl_id))) {
+	if (pvr2_ctrl_get_type(cptr) == PVR2_CTRL_TYPE_ENUM) {
 		// Control is an enumeration
 		cip->attr_gen[2] = &cip->attr_enum.attr;
 		cip->attr_val.show = fp->show_val_enum;
@@ -529,7 +522,10 @@ static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
 		cip->attr_gen[3] = &cip->attr_max.attr;
 	}
 
-	cip->grp.name = item_names[ctl_id];
+	cnt = scnprintf(cip->name,sizeof(cip->name)-1,"ctl_%s",
+			pvr2_ctrl_get_name(cptr));
+	cip->name[cnt] = 0;
+	cip->grp.name = cip->name;
 	cip->grp.attrs = cip->attr_gen;
 
 	sysfs_create_group(&sfp->class_dev->kobj,&cip->grp);
@@ -573,12 +569,10 @@ static void pvr2_sysfs_tear_down_debugifc(struct pvr2_sysfs *sfp)
 
 static void pvr2_sysfs_add_controls(struct pvr2_sysfs *sfp)
 {
-	unsigned int ctl_id;
-
-	for (ctl_id = 0;
-	     ctl_id < (sizeof(item_names)/sizeof(item_names[0])); ctl_id++) {
-		if (!item_names[ctl_id]) continue;
-		pvr2_sysfs_add_control(sfp,ctl_id);
+	unsigned int idx,cnt;
+	cnt = pvr2_hdw_get_ctrl_count(sfp->channel.hdw);
+	for (idx = 0; idx < cnt; idx++) {
+		pvr2_sysfs_add_control(sfp,idx);
 	}
 }
 
diff --git a/linux/drivers/media/video/pvrusb2/pvrusb2-v4l2.c b/linux/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
index 4cdd08708..fe7045e8f 100644
--- a/linux/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
+++ b/linux/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
@@ -80,22 +80,6 @@ static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
 module_param_array(video_nr, int, NULL, 0444);
 MODULE_PARM_DESC(video_nr, "Offset for device's minor");
 
-#define V4L2_CID_PVR_SRATE          (V4L2_CID_PRIVATE_BASE)
-#define V4L2_CID_PVR_AUDIOBITRATE   (V4L2_CID_PRIVATE_BASE+1)
-#define V4L2_CID_PVR_AUDIOCRC       (V4L2_CID_PRIVATE_BASE+2)
-#define V4L2_CID_PVR_AUDIOEMPHASIS  (V4L2_CID_PRIVATE_BASE+3)
-#define V4L2_CID_PVR_VBR            (V4L2_CID_PRIVATE_BASE+4)
-#define V4L2_CID_PVR_VIDEOBITRATE   (V4L2_CID_PRIVATE_BASE+5)
-#define V4L2_CID_PVR_VIDEOPEAK      (V4L2_CID_PRIVATE_BASE+6)
-#define V4L2_CID_PVR_VIDEOSTANDARD  (V4L2_CID_PRIVATE_BASE+7)
-#define V4L2_CID_PVR_INPUT          (V4L2_CID_PRIVATE_BASE+8)
-#define V4L2_CID_PVR_AUDIOMODE      (V4L2_CID_PRIVATE_BASE+9)
-#define V4L2_CID_PVR_FREQUENCY      (V4L2_CID_PRIVATE_BASE+10)
-#define V4L2_CID_PVR_HRES           (V4L2_CID_PRIVATE_BASE+11)
-#define V4L2_CID_PVR_VRES           (V4L2_CID_PRIVATE_BASE+12)
-
-#define V4L2_CID_PVR_MAX            (V4L2_CID_PRIVATE_BASE+12)
-
 struct v4l2_capability pvr_capability ={
 	.driver         = "pvrusb2",
 	.card           = "Hauppauge WinTV pvr-usb2",
@@ -141,69 +125,6 @@ static struct v4l2_tuner pvr_v4l2_tuners[]= {
 #endif
 };
 
-struct v4l2_standard pvr_standards[] = {
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_BG] = {
-		.id             = V4L2_STD_PAL_BG,
-		.frameperiod    =
-		{
-			.numerator  = 1,
-			.denominator= 25
-		},
-		.framelines     = 625,
-		.reserved       = {0,0,0,0}
-	},
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_I] = {
-		.id             = V4L2_STD_PAL_I,
-		.frameperiod    =
-		{
-			.numerator  = 1,
-			.denominator= 25
-		},
-		.framelines     = 625,
-		.reserved       = {0,0,0,0}
-	},
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_DK] = {
-		.id             = V4L2_STD_PAL_DK,
-		.frameperiod    =
-		{
-			.numerator  = 1,
-			.denominator= 25
-		},
-		.framelines     = 625,
-		.reserved       = {0,0,0,0}
-	},
-	[PVR2_CVAL_VIDEOSTANDARD_SECAM_L] = {
-		.id             = V4L2_STD_SECAM,
-		.frameperiod    =
-		{
-			.numerator  = 1,
-			.denominator= 25
-		},
-		.framelines     = 625,
-		.reserved       = {0,0,0,0}
-	},
-	[PVR2_CVAL_VIDEOSTANDARD_NTSC_M] = {
-		.id             = V4L2_STD_NTSC_M,
-		.frameperiod    =
-		{
-			.numerator =  1001,
-			.denominator= 30000
-		},
-		.framelines     = 525,
-		.reserved       = {0,0,0,0}
-	},
-	[PVR2_CVAL_VIDEOSTANDARD_PAL_M] = {
-		.id             = V4L2_STD_PAL_M,
-		.frameperiod    =
-		{
-			.numerator =  1001,
-			.denominator= 30000
-		},
-		.framelines     = 525,
-		.reserved       = {0,0,0,0}
-	}
-};
-
 struct v4l2_fmtdesc pvr_fmtdesc [] = {
 	{
 		.index          = 0,
@@ -257,84 +178,6 @@ struct v4l2_format pvr_format [] = {
 	}
 };
 
-static int cnv_cid_v4l2_pvr2(int id)
-{
-	switch (id) {
-	case V4L2_CID_BRIGHTNESS:
-		return PVR2_CID_BRIGHTNESS;
-	case V4L2_CID_SATURATION:
-		return PVR2_CID_SATURATION;
-	case V4L2_CID_CONTRAST:
-		return PVR2_CID_CONTRAST;
-	case V4L2_CID_HUE:
-		return PVR2_CID_HUE;
-	case V4L2_CID_AUDIO_VOLUME:
-		return PVR2_CID_VOLUME;
-	case V4L2_CID_AUDIO_BALANCE:
-		return PVR2_CID_BALANCE;
-	case V4L2_CID_AUDIO_BASS:
-		return PVR2_CID_BASS;
-	case V4L2_CID_AUDIO_TREBLE:
-		return PVR2_CID_TREBLE;
-	case V4L2_CID_AUDIO_MUTE:
-		return PVR2_CID_MUTE;
-	case V4L2_CID_PVR_SRATE:
-		return PVR2_CID_SRATE;
-	case V4L2_CID_PVR_AUDIOBITRATE:
-		return PVR2_CID_AUDIOBITRATE;
-	case V4L2_CID_PVR_AUDIOCRC:
-		return PVR2_CID_AUDIOCRC;
-	case V4L2_CID_PVR_AUDIOEMPHASIS:
-		return PVR2_CID_AUDIOEMPHASIS;
-	case V4L2_CID_PVR_VBR:
-		return PVR2_CID_VBR;
-	case V4L2_CID_PVR_VIDEOBITRATE:
-		return PVR2_CID_AVERAGEVIDEOBITRATE;
-	case V4L2_CID_PVR_VIDEOPEAK:
-		return PVR2_CID_PEAKVIDEOBITRATE;
-	case V4L2_CID_PVR_INPUT:
-		return PVR2_CID_INPUT;
-	case V4L2_CID_PVR_AUDIOMODE:
-		return PVR2_CID_AUDIOMODE;
-	case V4L2_CID_PVR_FREQUENCY:
-		return PVR2_CID_FREQUENCY;
-	case V4L2_CID_PVR_HRES:
-		return PVR2_CID_HRES;
-	case V4L2_CID_PVR_VRES:
-		return PVR2_CID_VRES;
-	}
-	return -1;
-}
-
-#if 0
-static int cnv_cid_pvr2_v4l2(int id)
-{
-	switch (id) {
-	case PVR2_CID_BRIGHTNESS:
-		return V4L2_CID_BRIGHTNESS;
-	case PVR2_CID_SATURATION:
-		return V4L2_CID_SATURATION;
-	case PVR2_CID_CONTRAST:
-		return V4L2_CID_CONTRAST;
-	case PVR2_CID_HUE:
-		return V4L2_CID_HUE;
-	case PVR2_CID_VOLUME:
-		return V4L2_CID_AUDIO_VOLUME;
-	case PVR2_CID_BALANCE:
-		return V4L2_CID_AUDIO_BALANCE;
-	case PVR2_CID_BASS:
-		return V4L2_CID_AUDIO_BASS;
-	case PVR2_CID_TREBLE:
-		return V4L2_CID_AUDIO_TREBLE;
-	case PVR2_CID_MUTE:
-		return V4L2_CID_AUDIO_MUTE;
-
-		return id + V4L2_CID_PRIVATE_BASE;
-	}
-	return -1;
-}
-#endif
-
 /*
  * pvr_ioctl()
  *
@@ -402,22 +245,15 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_ENUMSTD:
 	{
-
 		struct v4l2_standard *vs = (struct v4l2_standard *)arg;
+		const struct v4l2_standard *src;
 		int idx = vs->index;
 
-		if ((vs->index < PVR2_CVAL_VIDEOSTANDARD_MIN) ||
-		    (vs->index > PVR2_CVAL_VIDEOSTANDARD_MAX)) {
-			break;
-		}
+		src = pvr2_hdw_get_stdenum_value(hdw,idx);
+		if (!src) break;
 
-		memcpy(vs, &pvr_standards[idx], sizeof(struct v4l2_standard));
+		memcpy(vs, src, sizeof(struct v4l2_standard));
 		vs->index = idx;
-		strlcpy(vs->name,
-			pvr2_hdw_get_ctl_value_name(hdw,
-						    PVR2_CID_VIDEOSTANDARD,
-						    idx),
-			sizeof(vs->name));
 
 		ret = 0;
 		break;
@@ -425,59 +261,37 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_G_STD:
 	{
+		struct pvr2_ctrl *cptr;
 		v4l2_std_id *vs = (v4l2_std_id *)arg;
-
-		switch (pvr2_hdw_get_ctl_value(hdw,PVR2_CID_VIDEOSTANDARD)) {
-		default:
-		case PVR2_CVAL_VIDEOSTANDARD_NTSC_M:
-			*vs = V4L2_STD_NTSC_M;
-			break;
-		case PVR2_CVAL_VIDEOSTANDARD_PAL_M:
-			*vs = V4L2_STD_PAL_M;
-			break;
-		case PVR2_CVAL_VIDEOSTANDARD_SECAM_L:
-			*vs = V4L2_STD_SECAM;
-			break;
-		case PVR2_CVAL_VIDEOSTANDARD_PAL_BG:
-			*vs = V4L2_STD_PAL_BG;
-			break;
-		case PVR2_CVAL_VIDEOSTANDARD_PAL_I:
-			*vs = V4L2_STD_PAL_I;
-			break;
-		case PVR2_CVAL_VIDEOSTANDARD_PAL_DK:
-			*vs = V4L2_STD_PAL_DK;
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_STDCUR);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
 			break;
 		}
+
+		*vs = pvr2_ctrl_get_value(cptr);
 		ret = 0;
 		break;
 	}
 
 	case VIDIOC_S_STD:
 	{
+		struct pvr2_ctrl *cptr;
 		v4l2_std_id *vs = (v4l2_std_id *)arg;
-		int val = PVR2_CVAL_VIDEOSTANDARD_NTSC_M;
-
-		if (*vs & V4L2_STD_NTSC_M){
-			val = PVR2_CVAL_VIDEOSTANDARD_NTSC_M;
-		} else if (*vs & V4L2_STD_PAL_BG){
-			val = PVR2_CVAL_VIDEOSTANDARD_PAL_BG;
-		} else if (*vs & V4L2_STD_PAL_I){
-			val = PVR2_CVAL_VIDEOSTANDARD_PAL_I;
-		} else if (*vs & V4L2_STD_PAL_DK){
-			val = PVR2_CVAL_VIDEOSTANDARD_PAL_DK;
-		} else if (*vs & V4L2_STD_SECAM){
-			val = PVR2_CVAL_VIDEOSTANDARD_SECAM_L;
-		} else if (*vs & V4L2_STD_PAL_M){
-			val = PVR2_CVAL_VIDEOSTANDARD_PAL_M;
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_STDCUR);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
+			break;
 		}
 
-		pvr2_hdw_set_ctl_value(hdw,PVR2_CID_VIDEOSTANDARD,val);
-
+		pvr2_ctrl_set_value(cptr,*vs);
+		ret = 0;
 		break;
 	}
 
 	case VIDIOC_ENUMINPUT:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_input *vi = (struct v4l2_input *)arg;
 		struct v4l2_input tmp;
 
@@ -486,6 +300,8 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		}
 
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_INPUT);
+
 		memset(&tmp,0,sizeof(tmp));
 		tmp.index = vi->index;
 		switch (vi->index) {
@@ -500,8 +316,7 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 		}
 
 		strlcpy(tmp.name,
-			pvr2_hdw_get_ctl_value_name(hdw,PVR2_CID_INPUT,
-						    vi->index),
+			pvr2_ctrl_get_value_name(cptr,vi->index),
 			sizeof(tmp.name));
 
 		/* Don't bother with audioset, since this driver currently
@@ -522,17 +337,31 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_G_INPUT:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_input *vi = (struct v4l2_input *)arg;
-		vi->index = pvr2_hdw_get_ctl_value(hdw,PVR2_CID_INPUT);
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_INPUT);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
+			break;
+		}
+
+		vi->index = pvr2_ctrl_get_value(cptr);
 		ret = 0;
 		break;
 	}
 
 	case VIDIOC_S_INPUT:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_input *vi = (struct v4l2_input *)arg;
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_INPUT);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
+			break;
+		}
+
 		ret = 0;
-		if (pvr2_hdw_set_ctl_value(hdw,PVR2_CID_INPUT,vi->index)) {
+		if (pvr2_ctrl_set_value(cptr,vi->index)) {
 			ret = -EINVAL;
 		}
 		break;
@@ -557,6 +386,7 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 	}
 	case VIDIOC_G_TUNER:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
 		unsigned int status_mask;
 		if (vt->index !=0) break;
@@ -580,26 +410,8 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 			vt->signal = 65535;
 		}
 
-		switch (pvr2_hdw_get_ctl_value(hdw,PVR2_CID_AUDIOMODE)) {
-		case PVR2_CVAL_AUDIOMODE_MONO:
-			vt->audmode = V4L2_TUNER_MODE_MONO;
-			break;
-		case PVR2_CVAL_AUDIOMODE_STEREO:
-			vt->audmode = V4L2_TUNER_MODE_STEREO;
-			break;
-		case PVR2_CVAL_AUDIOMODE_LANG1:
-			vt->audmode = V4L2_TUNER_MODE_LANG1;
-			break;
-		case PVR2_CVAL_AUDIOMODE_LANG2:
-			vt->audmode = V4L2_TUNER_MODE_LANG2;
-			break;
-		case PVR2_CVAL_AUDIOMODE_LANG1_LANG2:
-			vt->audmode = V4L2_TUNER_MODE_LANG1_LANG2;
-			break;
-		case PVR2_CVAL_AUDIOMODE_SAP:
-			vt->audmode = V4L2_TUNER_MODE_SAP;
-			break;
-		}
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_AUDIOMODE);
+		vt->audmode = pvr2_ctrl_get_value(cptr);
 
 		ret = 0;
 		break;
@@ -607,40 +419,34 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_S_TUNER:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
-		int val = PVR2_CVAL_AUDIOMODE_STEREO;
 
 		if (vt->index != 0)
 			break;
 
-		switch (vt->audmode) {
-		case V4L2_TUNER_MODE_MONO:
-			val = PVR2_CVAL_AUDIOMODE_MONO;
-			break;
-		case V4L2_TUNER_MODE_STEREO:
-			val = PVR2_CVAL_AUDIOMODE_STEREO;
-			break;
-		case V4L2_TUNER_MODE_LANG1:
-			val = PVR2_CVAL_AUDIOMODE_LANG1;
-			break;
-		case V4L2_TUNER_MODE_LANG1_LANG2:
-			val = PVR2_CVAL_AUDIOMODE_LANG1_LANG2;
-			break;
-		case V4L2_TUNER_MODE_SAP: // Also LANG2
-			val = PVR2_CVAL_AUDIOMODE_SAP;
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_AUDIOMODE);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
 			break;
 		}
 
-		pvr2_hdw_set_ctl_value(hdw,PVR2_CID_AUDIOMODE,val);
+		pvr2_ctrl_set_value(cptr,vt->audmode);
 		ret = 0;
 	}
 
 	case VIDIOC_S_FREQUENCY:
 	{
+		struct pvr2_ctrl *cptr;
 		const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 
-		pvr2_hdw_set_ctl_value(hdw,PVR2_CID_FREQUENCY,
-				       vf->frequency * 62500);
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_FREQUENCY);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
+			break;
+		}
+
+		pvr2_ctrl_set_value(cptr,vf->frequency * 62500);
 
 		ret = 0;
 		break;
@@ -648,10 +454,17 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_G_FREQUENCY:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 		int val;
 
-		val = pvr2_hdw_get_ctl_value(hdw,PVR2_CID_FREQUENCY);
+		cptr = pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_FREQUENCY);
+		if (!pvr2_ctrl_is_valid(cptr)) {
+			ret = -EINVAL;
+			break;
+		}
+
+		val = pvr2_ctrl_get_value(cptr);
 
 		val /= 62500;
 		vf->frequency = val;
@@ -682,12 +495,18 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 			memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
 			       sizeof(struct v4l2_format));
 			vf->fmt.pix.width =
-				pvr2_hdw_get_ctl_value(hdw,PVR2_CID_HRES);
-			if (pvr2_hdw_get_ctl_value(hdw,PVR2_CID_INTERLACE)) {
+				pvr2_ctrl_get_value(
+					pvr2_hdw_get_ctrl(hdw,
+							  V4L2_CID_PVR_HRES));
+			if (pvr2_ctrl_get_value(
+				    pvr2_hdw_get_ctrl(
+					    hdw,V4L2_CID_PVR_INTERLACE))) {
 				vf->fmt.pix.width /= 2;
 			}
 			vf->fmt.pix.height =
-				pvr2_hdw_get_ctl_value(hdw,PVR2_CID_VRES);
+				pvr2_ctrl_get_value(
+					pvr2_hdw_get_ctrl(hdw,
+							  V4L2_CID_PVR_VRES));
 			ret = 0;
 			break;
 		case V4L2_BUF_TYPE_VBI_CAPTURE:
@@ -713,16 +532,12 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 			int w = vf->fmt.pix.width;
 			int vd_std, hf, hh;
 
-			vd_std  = pvr2_hdw_get_ctl_value(hdw,
-						PVR2_CID_VIDEOSTANDARD);
-			switch (vd_std) {
-			case PVR2_CVAL_VIDEOSTANDARD_NTSC_M:
-			case PVR2_CVAL_VIDEOSTANDARD_PAL_M:
+			vd_std = pvr2_ctrl_get_value(
+				pvr2_hdw_get_ctrl(hdw,V4L2_CID_PVR_STDCUR));
+			if (vd_std & V4L2_STD_525_60) {
 				hf=480;
-				break;
-			default:
+			} else {
 				hf=576;
-				break;
 			}
 			hh = (int) (hf / 2);
 
@@ -734,15 +549,18 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 			vf->fmt.pix.height = (h > hh) ? hf : hh;
 
 			if (cmd == VIDIOC_S_FMT){
-				pvr2_hdw_set_ctl_value(
-					hdw,PVR2_CID_HRES,
+				pvr2_ctrl_set_value(
+					pvr2_hdw_get_ctrl(hdw,
+							  V4L2_CID_PVR_HRES),
 					vf->fmt.pix.width);
-				pvr2_hdw_set_ctl_value(
-					hdw,PVR2_CID_VRES,
+				pvr2_ctrl_set_value(
+					pvr2_hdw_get_ctrl(hdw,
+							  V4L2_CID_PVR_VRES),
 					vf->fmt.pix.height);
-				pvr2_hdw_set_ctl_value(
-					hdw,PVR2_CID_INTERLACE,
-					(vf->fmt.pix.height != hf));
+				pvr2_ctrl_set_value(
+					pvr2_hdw_get_ctrl(
+						hdw,V4L2_CID_PVR_INTERLACE),
+					vf->fmt.pix.height != hf);
 			}
 		} break;
 		case V4L2_BUF_TYPE_VBI_CAPTURE:
@@ -772,24 +590,31 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_QUERYCTRL:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
-		int pvr2_id = cnv_cid_v4l2_pvr2(vc->id);
-		if (pvr2_id < 0) {
+		cptr = pvr2_hdw_get_ctrl(hdw,vc->id);
+
+		if (!pvr2_ctrl_is_valid(cptr)) {
 			ret = -EINVAL;
 			break;
 		}
 
-		if (pvr2_hdw_get_ctl_value_name(hdw,pvr2_id,0)) {
+		switch (pvr2_ctrl_get_type(cptr)) {
+		case PVR2_CTRL_TYPE_ENUM:
 			vc->type = V4L2_CTRL_TYPE_MENU;
-		} else {
+			break;
+		case PVR2_CTRL_TYPE_INT:
 			vc->type = V4L2_CTRL_TYPE_INTEGER;
+			break;
+		default:
+			ret = -EINVAL;
+			break;
 		}
-		strlcpy(vc->name,pvr2_hdw_get_ctl_name(hdw,pvr2_id),
-			sizeof(vc->name));
-		vc->minimum = pvr2_hdw_get_ctl_min_value(hdw,pvr2_id);
-		vc->maximum = pvr2_hdw_get_ctl_max_value(hdw,pvr2_id);
-		vc->default_value =
-			pvr2_hdw_get_ctl_default_value(hdw,pvr2_id);
+
+		strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
+		vc->minimum = pvr2_ctrl_get_min_value(cptr);
+		vc->maximum = pvr2_ctrl_get_max_value(cptr);
+		vc->default_value = pvr2_ctrl_get_default_value(cptr);
 		vc->step = 1;
 		ret = 0;
 		break;
@@ -797,16 +622,15 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_QUERYMENU:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
-		int pvr2_id = cnv_cid_v4l2_pvr2(vm->id);
 		const char *value_name;
-		if (pvr2_id < 0) {
+		cptr = pvr2_hdw_get_ctrl(hdw,vm->id);
+		if (!pvr2_ctrl_is_valid(cptr)) {
 			ret = -EINVAL;
 			break;
 		}
-
-		value_name = pvr2_hdw_get_ctl_value_name(hdw,pvr2_id,
-							 vm->index);
+		value_name = pvr2_ctrl_get_value_name(cptr,vm->index);
 		if (value_name) {
 			strlcpy(vm->name,value_name,sizeof(vm->name));
 			ret = 0;
@@ -819,31 +643,31 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 
 	case VIDIOC_G_CTRL:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_control *vc = (struct v4l2_control *)arg;
-		int pvr2_id;
 
-		pvr2_id = cnv_cid_v4l2_pvr2(vc->id);
-		if (pvr2_id < 0) {
+		cptr = pvr2_hdw_get_ctrl(hdw,vc->id);
+		if (!pvr2_ctrl_is_valid(cptr)) {
 			ret = -EINVAL;
 			break;
 		}
 		ret = 0;
-		vc->value = pvr2_hdw_get_ctl_value(hdw,pvr2_id);
+		vc->value = pvr2_ctrl_get_value(cptr);
 		break;
 	}
 
 	case VIDIOC_S_CTRL:
 	{
+		struct pvr2_ctrl *cptr;
 		struct v4l2_control *vc = (struct v4l2_control *)arg;
-		int pvr2_id;
 
-		pvr2_id = cnv_cid_v4l2_pvr2(vc->id);
-		if (pvr2_id < 0) {
+		cptr = pvr2_hdw_get_ctrl(hdw,vc->id);
+		if (!pvr2_ctrl_is_valid(cptr)) {
 			ret = -EINVAL;
 			break;
 		}
 
-		ret = pvr2_hdw_set_ctl_value(hdw,pvr2_id,vc->value);
+		ret = pvr2_ctrl_set_value(cptr,vc->value);
 		break;
 	}