Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c0bb609f authored by Mike Isely's avatar Mike Isely Committed by Mauro Carvalho Chehab
Browse files

[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: default avatarMike Isely <isely@pobox.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 598e978a

drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h

+0 −3
Original line number Diff line number Diff line
@@ -317,15 +317,12 @@ struct pvr2_hdw { 
	v4l2_std_id std_mask_eeprom; // Hardware supported selections

	v4l2_std_id std_mask_avail;  // Which standards we may select from

	v4l2_std_id std_mask_cur;    // Currently selected standard(s)

	unsigned int std_enum_cnt;   // # of enumerated standards

	int std_enum_cur;            // selected standard enumeration value

	int std_dirty;               // True if std_mask_cur has changed

	struct pvr2_ctl_info std_info_enum;

	struct pvr2_ctl_info std_info_avail;

	struct pvr2_ctl_info std_info_cur;

	struct pvr2_ctl_info std_info_detect;

	struct v4l2_standard *std_defs;

	const char **std_enum_names;



	// Generated string names, one per actual V4L2 standard

	const char *std_mask_ptrs[32];

drivers/media/video/pvrusb2/pvrusb2-hdw.c

+2 −158
Original line number Diff line number Diff line
@@ -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, \
@@ -1298,16 +1260,6 @@ static const struct pvr2_ctl_info control_defs[] = { 
		.val_to_sym = ctrl_std_val_to_sym,

		.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",
@@ -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)

{

drivers/media/video/pvrusb2/pvrusb2-hdw.h

+0 −5
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 


/* Private internal control ids, look these up with

   pvr2_hdw_get_ctrl_by_id() - these are NOT visible in V4L */

#define PVR2_CID_STDENUM 1

#define PVR2_CID_STDCUR 2

#define PVR2_CID_STDAVAIL 3

#define PVR2_CID_INPUT 4
@@ -211,10 +210,6 @@ int pvr2_hdw_set_stream_type(struct pvr2_hdw *, enum pvr2_config); 
/* Get handle to video output stream */

struct pvr2_stream *pvr2_hdw_get_video_stream(struct pvr2_hdw *);



/* Emit a video standard struct */

int pvr2_hdw_get_stdenum_value(struct pvr2_hdw *hdw,struct v4l2_standard *std,

			       unsigned int idx);



/* Enable / disable retrieval of CPU firmware or prom contents.  This must

   be enabled before pvr2_hdw_cpufw_get() will function.  Note that doing

   this may prevent the device from running (and leaving this mode may