[media] pvrusb2: Get rid of obsolete code for video standard enumeration

Get rid of pvrusb2-local implementation for enumeration of video
standards - with video_ioctl2 this happens automatically now in the
v4l core.

Signed-off-by: Mike Isely <isely@pobox.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 2 insertions, 158 deletions

diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index c4bb0d1b5f9f..d882c95c5788 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -334,8 +334,6 @@ static void pvr2_hdw_state_log_state(struct pvr2_hdw *);
 static int pvr2_hdw_cmd_usbstream(struct pvr2_hdw *hdw,int runFl);
 static int pvr2_hdw_commit_setup(struct pvr2_hdw *hdw);
 static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw);
-static void pvr2_hdw_internal_find_stdenum(struct pvr2_hdw *hdw);
-static void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw);
 static void pvr2_hdw_quiescent_timeout(unsigned long);
 static void pvr2_hdw_decoder_stabilization_timeout(unsigned long);
 static void pvr2_hdw_encoder_wait_timeout(unsigned long);
@@ -860,8 +858,7 @@ static int ctrl_stdavail_set(struct pvr2_ctrl *cptr,int m,int v)
         ns = (ns & ~m) | (v & m);
         if (ns == hdw->std_mask_avail) return 0;
         hdw->std_mask_avail = ns;
-        pvr2_hdw_internal_set_std_avail(hdw);
-        pvr2_hdw_internal_find_stdenum(hdw);
+        hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
         return 0;
 }
 
@@ -901,7 +898,6 @@ static int ctrl_stdcur_set(struct pvr2_ctrl *cptr,int m,int v)
         if (ns == hdw->std_mask_cur) return 0;
         hdw->std_mask_cur = ns;
         hdw->std_dirty = !0;
-        pvr2_hdw_internal_find_stdenum(hdw);
         return 0;
 }
 
@@ -947,40 +943,6 @@ static int ctrl_audio_modes_present_get(struct pvr2_ctrl *cptr,int *vp)
 }
 
 
-static int ctrl_stdenumcur_set(struct pvr2_ctrl *cptr,int m,int v)
-{
-        struct pvr2_hdw *hdw = cptr->hdw;
-        if (v < 0) return -EINVAL;
-        if (v > hdw->std_enum_cnt) return -EINVAL;
-        hdw->std_enum_cur = v;
-        if (!v) return 0;
-        v--;
-        if (hdw->std_mask_cur == hdw->std_defs[v].id) return 0;
-        hdw->std_mask_cur = hdw->std_defs[v].id;
-        hdw->std_dirty = !0;
-        return 0;
-}
-
-
-static int ctrl_stdenumcur_get(struct pvr2_ctrl *cptr,int *vp)
-{
-        *vp = cptr->hdw->std_enum_cur;
-        return 0;
-}
-
-
-static int ctrl_stdenumcur_is_dirty(struct pvr2_ctrl *cptr)
-{
-        return cptr->hdw->std_dirty != 0;
-}
-
-
-static void ctrl_stdenumcur_clear_dirty(struct pvr2_ctrl *cptr)
-{
-        cptr->hdw->std_dirty = 0;
-}
-
-
 #define DEFINT(vmin,vmax) \
         .type = pvr2_ctl_int, \
         .def.type_int.min_value = vmin, \
@@ -1299,16 +1261,6 @@ static const struct pvr2_ctl_info control_defs[] = {
                 .sym_to_val = ctrl_std_sym_to_val,
                 .type = pvr2_ctl_bitmask,
         },{
-                .desc = "Video Standard Name",
-                .name = "video_standard",
-                .internal_id = PVR2_CID_STDENUM,
-                .skip_init = !0,
-                .get_value = ctrl_stdenumcur_get,
-                .set_value = ctrl_stdenumcur_set,
-                .is_dirty = ctrl_stdenumcur_is_dirty,
-                .clear_dirty = ctrl_stdenumcur_clear_dirty,
-                .type = pvr2_ctl_enum,
-        },{
                 .desc = "Video Standards Detected Mask",
                 .name = "video_standard_mask_detected",
                 .internal_id = PVR2_CID_STDDETECT,
@@ -1951,7 +1903,7 @@ static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
                 hdw->std_mask_avail |= std2;
         }
 
-        pvr2_hdw_internal_set_std_avail(hdw);
+        hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
 
         if (std1) {
                 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std1);
@@ -1960,7 +1912,6 @@ static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
                            bcnt,buf);
                 hdw->std_mask_cur = std1;
                 hdw->std_dirty = !0;
-                pvr2_hdw_internal_find_stdenum(hdw);
                 return;
         }
         if (std3) {
@@ -1970,7 +1921,6 @@ static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
                            " (determined by device type): %.*s",bcnt,buf);
                 hdw->std_mask_cur = std3;
                 hdw->std_dirty = !0;
-                pvr2_hdw_internal_find_stdenum(hdw);
                 return;
         }
 
@@ -1990,24 +1940,10 @@ static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
                                    bcnt,buf);
                         hdw->std_mask_cur = std_eeprom_maps[idx].std;
                         hdw->std_dirty = !0;
-                        pvr2_hdw_internal_find_stdenum(hdw);
                         return;
                 }
         }
 
-        if (hdw->std_enum_cnt > 1) {
-                // Autoselect the first listed standard
-                hdw->std_enum_cur = 1;
-                hdw->std_mask_cur = hdw->std_defs[hdw->std_enum_cur-1].id;
-                hdw->std_dirty = !0;
-                pvr2_trace(PVR2_TRACE_STD,
-                           "Initial video standard auto-selected to %s",
-                           hdw->std_defs[hdw->std_enum_cur-1].name);
-                return;
-        }
-
-        pvr2_trace(PVR2_TRACE_ERROR_LEGS,
-                   "Unable to select a viable initial video standard");
 }
 
 
@@ -2609,14 +2545,6 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
                 cptr->info = ciptr;
         }
 
-        // Initialize video standard enum dynamic control
-        cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDENUM);
-        if (cptr) {
-                memcpy(&hdw->std_info_enum,cptr->info,
-                       sizeof(hdw->std_info_enum));
-                cptr->info = &hdw->std_info_enum;
-
-        }
         // Initialize control data regarding video standard masks
         valid_std_mask = pvr2_std_get_usable();
         for (idx = 0; idx < 32; idx++) {
@@ -2736,8 +2664,6 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
                 kfree(hdw->ctl_write_buffer);
                 kfree(hdw->controls);
                 kfree(hdw->mpeg_ctrl_info);
-                kfree(hdw->std_defs);
-                kfree(hdw->std_enum_names);
                 kfree(hdw);
         }
         return NULL;
@@ -2813,8 +2739,6 @@ void pvr2_hdw_destroy(struct pvr2_hdw *hdw)
         } while (0); mutex_unlock(&pvr2_unit_mtx);
         kfree(hdw->controls);
         kfree(hdw->mpeg_ctrl_info);
-        kfree(hdw->std_defs);
-        kfree(hdw->std_enum_names);
         kfree(hdw);
 }
 
@@ -2837,86 +2761,6 @@ void pvr2_hdw_disconnect(struct pvr2_hdw *hdw)
 }
 
 
-// Attempt to autoselect an appropriate value for std_enum_cur given
-// whatever is currently in std_mask_cur
-static void pvr2_hdw_internal_find_stdenum(struct pvr2_hdw *hdw)
-{
-        unsigned int idx;
-        for (idx = 1; idx < hdw->std_enum_cnt; idx++) {
-                if (hdw->std_defs[idx-1].id == hdw->std_mask_cur) {
-                        hdw->std_enum_cur = idx;
-                        return;
-                }
-        }
-        hdw->std_enum_cur = 0;
-}
-
-
-// Calculate correct set of enumerated standards based on currently known
-// set of available standards bits.
-static void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw)
-{
-        struct v4l2_standard *newstd;
-        unsigned int std_cnt;
-        unsigned int idx;
-
-        newstd = pvr2_std_create_enum(&std_cnt,hdw->std_mask_avail);
-
-        if (hdw->std_defs) {
-                kfree(hdw->std_defs);
-                hdw->std_defs = NULL;
-        }
-        hdw->std_enum_cnt = 0;
-        if (hdw->std_enum_names) {
-                kfree(hdw->std_enum_names);
-                hdw->std_enum_names = NULL;
-        }
-
-        if (!std_cnt) {
-                pvr2_trace(
-                        PVR2_TRACE_ERROR_LEGS,
-                        "WARNING: Failed to identify any viable standards");
-        }
-
-        /* Set up the dynamic control for this standard */
-        hdw->std_enum_names = kmalloc(sizeof(char *)*(std_cnt+1),GFP_KERNEL);
-        if (hdw->std_enum_names) {
-                hdw->std_enum_names[0] = "none";
-                for (idx = 0; idx < std_cnt; idx++)
-                        hdw->std_enum_names[idx+1] = newstd[idx].name;
-                hdw->std_info_enum.def.type_enum.value_names =
-                                                hdw->std_enum_names;
-                hdw->std_info_enum.def.type_enum.count = std_cnt+1;
-        } else {
-                pvr2_trace(
-                        PVR2_TRACE_ERROR_LEGS,
-                        "WARNING: Failed to alloc memory for names");
-                hdw->std_info_enum.def.type_enum.value_names = NULL;
-                hdw->std_info_enum.def.type_enum.count = 0;
-        }
-        hdw->std_defs = newstd;
-        hdw->std_enum_cnt = std_cnt+1;
-        hdw->std_enum_cur = 0;
-        hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
-}
-
-
-int pvr2_hdw_get_stdenum_value(struct pvr2_hdw *hdw,
-                               struct v4l2_standard *std,
-                               unsigned int idx)
-{
-        int ret = -EINVAL;
-        if (!idx) return ret;
-        LOCK_TAKE(hdw->big_lock); do {
-                if (idx >= hdw->std_enum_cnt) break;
-                idx--;
-                memcpy(std,hdw->std_defs+idx,sizeof(*std));
-                ret = 0;
-        } while (0); LOCK_GIVE(hdw->big_lock);
-        return ret;
-}
-
-
 /* Get the number of defined controls */
 unsigned int pvr2_hdw_get_ctrl_count(struct pvr2_hdw *hdw)
 {