1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *
4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
5  */
6 
7 #include <linux/errno.h>
8 #include <linux/string.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/firmware.h>
12 #include <linux/videodev2.h>
13 #include <media/v4l2-common.h>
14 #include <media/tuner.h>
15 #include "pvrusb2.h"
16 #include "pvrusb2-std.h"
17 #include "pvrusb2-util.h"
18 #include "pvrusb2-hdw.h"
19 #include "pvrusb2-i2c-core.h"
20 #include "pvrusb2-eeprom.h"
21 #include "pvrusb2-hdw-internal.h"
22 #include "pvrusb2-encoder.h"
23 #include "pvrusb2-debug.h"
24 #include "pvrusb2-fx2-cmd.h"
25 #include "pvrusb2-wm8775.h"
26 #include "pvrusb2-video-v4l.h"
27 #include "pvrusb2-cx2584x-v4l.h"
28 #include "pvrusb2-cs53l32a.h"
29 #include "pvrusb2-audio.h"
30 
31 #define TV_MIN_FREQ     55250000L
32 #define TV_MAX_FREQ    850000000L
33 
34 /* This defines a minimum interval that the decoder must remain quiet
35    before we are allowed to start it running. */
36 #define TIME_MSEC_DECODER_WAIT 50
37 
38 /* This defines a minimum interval that the decoder must be allowed to run
39    before we can safely begin using its streaming output. */
40 #define TIME_MSEC_DECODER_STABILIZATION_WAIT 300
41 
42 /* This defines a minimum interval that the encoder must remain quiet
43    before we are allowed to configure it. */
44 #define TIME_MSEC_ENCODER_WAIT 50
45 
46 /* This defines the minimum interval that the encoder must successfully run
47    before we consider that the encoder has run at least once since its
48    firmware has been loaded.  This measurement is in important for cases
49    where we can't do something until we know that the encoder has been run
50    at least once. */
51 #define TIME_MSEC_ENCODER_OK 250
52 
53 static struct pvr2_hdw *unit_pointers[PVR_NUM] = {[ 0 ... PVR_NUM-1 ] = NULL};
54 static DEFINE_MUTEX(pvr2_unit_mtx);
55 
56 static int ctlchg;
57 static int procreload;
58 static int tuner[PVR_NUM] = { [0 ... PVR_NUM-1] = -1 };
59 static int tolerance[PVR_NUM] = { [0 ... PVR_NUM-1] = 0 };
60 static int video_std[PVR_NUM] = { [0 ... PVR_NUM-1] = 0 };
61 static int init_pause_msec;
62 
63 module_param(ctlchg, int, S_IRUGO|S_IWUSR);
64 MODULE_PARM_DESC(ctlchg, "0=optimize ctl change 1=always accept new ctl value");
65 module_param(init_pause_msec, int, S_IRUGO|S_IWUSR);
66 MODULE_PARM_DESC(init_pause_msec, "hardware initialization settling delay");
67 module_param(procreload, int, S_IRUGO|S_IWUSR);
68 MODULE_PARM_DESC(procreload,
69 		 "Attempt init failure recovery with firmware reload");
70 module_param_array(tuner,    int, NULL, 0444);
71 MODULE_PARM_DESC(tuner,"specify installed tuner type");
72 module_param_array(video_std,    int, NULL, 0444);
73 MODULE_PARM_DESC(video_std,"specify initial video standard");
74 module_param_array(tolerance,    int, NULL, 0444);
75 MODULE_PARM_DESC(tolerance,"specify stream error tolerance");
76 
77 /* US Broadcast channel 3 (61.25 MHz), to help with testing */
78 static int default_tv_freq    = 61250000L;
79 /* 104.3 MHz, a usable FM station for my area */
80 static int default_radio_freq = 104300000L;
81 
82 module_param_named(tv_freq, default_tv_freq, int, 0444);
83 MODULE_PARM_DESC(tv_freq, "specify initial television frequency");
84 module_param_named(radio_freq, default_radio_freq, int, 0444);
85 MODULE_PARM_DESC(radio_freq, "specify initial radio frequency");
86 
87 #define PVR2_CTL_WRITE_ENDPOINT  0x01
88 #define PVR2_CTL_READ_ENDPOINT   0x81
89 
90 #define PVR2_GPIO_IN 0x9008
91 #define PVR2_GPIO_OUT 0x900c
92 #define PVR2_GPIO_DIR 0x9020
93 
94 #define trace_firmware(...) pvr2_trace(PVR2_TRACE_FIRMWARE,__VA_ARGS__)
95 
96 #define PVR2_FIRMWARE_ENDPOINT   0x02
97 
98 /* size of a firmware chunk */
99 #define FIRMWARE_CHUNK_SIZE 0x2000
100 
101 typedef void (*pvr2_subdev_update_func)(struct pvr2_hdw *,
102 					struct v4l2_subdev *);
103 
104 static const pvr2_subdev_update_func pvr2_module_update_functions[] = {
105 	[PVR2_CLIENT_ID_WM8775] = pvr2_wm8775_subdev_update,
106 	[PVR2_CLIENT_ID_SAA7115] = pvr2_saa7115_subdev_update,
107 	[PVR2_CLIENT_ID_MSP3400] = pvr2_msp3400_subdev_update,
108 	[PVR2_CLIENT_ID_CX25840] = pvr2_cx25840_subdev_update,
109 	[PVR2_CLIENT_ID_CS53L32A] = pvr2_cs53l32a_subdev_update,
110 };
111 
112 static const char *module_names[] = {
113 	[PVR2_CLIENT_ID_MSP3400] = "msp3400",
114 	[PVR2_CLIENT_ID_CX25840] = "cx25840",
115 	[PVR2_CLIENT_ID_SAA7115] = "saa7115",
116 	[PVR2_CLIENT_ID_TUNER] = "tuner",
117 	[PVR2_CLIENT_ID_DEMOD] = "tuner",
118 	[PVR2_CLIENT_ID_CS53L32A] = "cs53l32a",
119 	[PVR2_CLIENT_ID_WM8775] = "wm8775",
120 };
121 
122 
123 static const unsigned char *module_i2c_addresses[] = {
124 	[PVR2_CLIENT_ID_TUNER] = "\x60\x61\x62\x63",
125 	[PVR2_CLIENT_ID_DEMOD] = "\x43",
126 	[PVR2_CLIENT_ID_MSP3400] = "\x40",
127 	[PVR2_CLIENT_ID_SAA7115] = "\x21",
128 	[PVR2_CLIENT_ID_WM8775] = "\x1b",
129 	[PVR2_CLIENT_ID_CX25840] = "\x44",
130 	[PVR2_CLIENT_ID_CS53L32A] = "\x11",
131 };
132 
133 
134 static const char *ir_scheme_names[] = {
135 	[PVR2_IR_SCHEME_NONE] = "none",
136 	[PVR2_IR_SCHEME_29XXX] = "29xxx",
137 	[PVR2_IR_SCHEME_24XXX] = "24xxx (29xxx emulation)",
138 	[PVR2_IR_SCHEME_24XXX_MCE] = "24xxx (MCE device)",
139 	[PVR2_IR_SCHEME_ZILOG] = "Zilog",
140 };
141 
142 
143 /* Define the list of additional controls we'll dynamically construct based
144    on query of the cx2341x module. */
145 struct pvr2_mpeg_ids {
146 	const char *strid;
147 	int id;
148 };
149 static const struct pvr2_mpeg_ids mpeg_ids[] = {
150 	{
151 		.strid = "audio_layer",
152 		.id = V4L2_CID_MPEG_AUDIO_ENCODING,
153 	},{
154 		.strid = "audio_bitrate",
155 		.id = V4L2_CID_MPEG_AUDIO_L2_BITRATE,
156 	},{
157 		/* Already using audio_mode elsewhere :-( */
158 		.strid = "mpeg_audio_mode",
159 		.id = V4L2_CID_MPEG_AUDIO_MODE,
160 	},{
161 		.strid = "mpeg_audio_mode_extension",
162 		.id = V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
163 	},{
164 		.strid = "audio_emphasis",
165 		.id = V4L2_CID_MPEG_AUDIO_EMPHASIS,
166 	},{
167 		.strid = "audio_crc",
168 		.id = V4L2_CID_MPEG_AUDIO_CRC,
169 	},{
170 		.strid = "video_aspect",
171 		.id = V4L2_CID_MPEG_VIDEO_ASPECT,
172 	},{
173 		.strid = "video_b_frames",
174 		.id = V4L2_CID_MPEG_VIDEO_B_FRAMES,
175 	},{
176 		.strid = "video_gop_size",
177 		.id = V4L2_CID_MPEG_VIDEO_GOP_SIZE,
178 	},{
179 		.strid = "video_gop_closure",
180 		.id = V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
181 	},{
182 		.strid = "video_bitrate_mode",
183 		.id = V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
184 	},{
185 		.strid = "video_bitrate",
186 		.id = V4L2_CID_MPEG_VIDEO_BITRATE,
187 	},{
188 		.strid = "video_bitrate_peak",
189 		.id = V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
190 	},{
191 		.strid = "video_temporal_decimation",
192 		.id = V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
193 	},{
194 		.strid = "stream_type",
195 		.id = V4L2_CID_MPEG_STREAM_TYPE,
196 	},{
197 		.strid = "video_spatial_filter_mode",
198 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
199 	},{
200 		.strid = "video_spatial_filter",
201 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
202 	},{
203 		.strid = "video_luma_spatial_filter_type",
204 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
205 	},{
206 		.strid = "video_chroma_spatial_filter_type",
207 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
208 	},{
209 		.strid = "video_temporal_filter_mode",
210 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
211 	},{
212 		.strid = "video_temporal_filter",
213 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
214 	},{
215 		.strid = "video_median_filter_type",
216 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
217 	},{
218 		.strid = "video_luma_median_filter_top",
219 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
220 	},{
221 		.strid = "video_luma_median_filter_bottom",
222 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
223 	},{
224 		.strid = "video_chroma_median_filter_top",
225 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
226 	},{
227 		.strid = "video_chroma_median_filter_bottom",
228 		.id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
229 	}
230 };
231 #define MPEGDEF_COUNT ARRAY_SIZE(mpeg_ids)
232 
233 
234 static const char *control_values_srate[] = {
235 	[V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100]   = "44.1 kHz",
236 	[V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000]   = "48 kHz",
237 	[V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000]   = "32 kHz",
238 };
239 
240 
241 
242 static const char *control_values_input[] = {
243 	[PVR2_CVAL_INPUT_TV]        = "television",  /*xawtv needs this name*/
244 	[PVR2_CVAL_INPUT_DTV]       = "dtv",
245 	[PVR2_CVAL_INPUT_RADIO]     = "radio",
246 	[PVR2_CVAL_INPUT_SVIDEO]    = "s-video",
247 	[PVR2_CVAL_INPUT_COMPOSITE] = "composite",
248 };
249 
250 
251 static const char *control_values_audiomode[] = {
252 	[V4L2_TUNER_MODE_MONO]   = "Mono",
253 	[V4L2_TUNER_MODE_STEREO] = "Stereo",
254 	[V4L2_TUNER_MODE_LANG1]  = "Lang1",
255 	[V4L2_TUNER_MODE_LANG2]  = "Lang2",
256 	[V4L2_TUNER_MODE_LANG1_LANG2] = "Lang1+Lang2",
257 };
258 
259 
260 static const char *control_values_hsm[] = {
261 	[PVR2_CVAL_HSM_FAIL] = "Fail",
262 	[PVR2_CVAL_HSM_HIGH] = "High",
263 	[PVR2_CVAL_HSM_FULL] = "Full",
264 };
265 
266 
267 static const char *pvr2_state_names[] = {
268 	[PVR2_STATE_NONE] =    "none",
269 	[PVR2_STATE_DEAD] =    "dead",
270 	[PVR2_STATE_COLD] =    "cold",
271 	[PVR2_STATE_WARM] =    "warm",
272 	[PVR2_STATE_ERROR] =   "error",
273 	[PVR2_STATE_READY] =   "ready",
274 	[PVR2_STATE_RUN] =     "run",
275 };
276 
277 
278 struct pvr2_fx2cmd_descdef {
279 	unsigned char id;
280 	unsigned char *desc;
281 };
282 
283 static const struct pvr2_fx2cmd_descdef pvr2_fx2cmd_desc[] = {
284 	{FX2CMD_MEM_WRITE_DWORD, "write encoder dword"},
285 	{FX2CMD_MEM_READ_DWORD, "read encoder dword"},
286 	{FX2CMD_HCW_ZILOG_RESET, "zilog IR reset control"},
287 	{FX2CMD_MEM_READ_64BYTES, "read encoder 64bytes"},
288 	{FX2CMD_REG_WRITE, "write encoder register"},
289 	{FX2CMD_REG_READ, "read encoder register"},
290 	{FX2CMD_MEMSEL, "encoder memsel"},
291 	{FX2CMD_I2C_WRITE, "i2c write"},
292 	{FX2CMD_I2C_READ, "i2c read"},
293 	{FX2CMD_GET_USB_SPEED, "get USB speed"},
294 	{FX2CMD_STREAMING_ON, "stream on"},
295 	{FX2CMD_STREAMING_OFF, "stream off"},
296 	{FX2CMD_FWPOST1, "fwpost1"},
297 	{FX2CMD_POWER_OFF, "power off"},
298 	{FX2CMD_POWER_ON, "power on"},
299 	{FX2CMD_DEEP_RESET, "deep reset"},
300 	{FX2CMD_GET_EEPROM_ADDR, "get rom addr"},
301 	{FX2CMD_GET_IR_CODE, "get IR code"},
302 	{FX2CMD_HCW_DEMOD_RESETIN, "hcw demod resetin"},
303 	{FX2CMD_HCW_DTV_STREAMING_ON, "hcw dtv stream on"},
304 	{FX2CMD_HCW_DTV_STREAMING_OFF, "hcw dtv stream off"},
305 	{FX2CMD_ONAIR_DTV_STREAMING_ON, "onair dtv stream on"},
306 	{FX2CMD_ONAIR_DTV_STREAMING_OFF, "onair dtv stream off"},
307 	{FX2CMD_ONAIR_DTV_POWER_ON, "onair dtv power on"},
308 	{FX2CMD_ONAIR_DTV_POWER_OFF, "onair dtv power off"},
309 	{FX2CMD_HCW_DEMOD_RESET_PIN, "hcw demod reset pin"},
310 	{FX2CMD_HCW_MAKO_SLEEP_PIN, "hcw mako sleep pin"},
311 };
312 
313 
314 static int pvr2_hdw_set_input(struct pvr2_hdw *hdw,int v);
315 static void pvr2_hdw_state_sched(struct pvr2_hdw *);
316 static int pvr2_hdw_state_eval(struct pvr2_hdw *);
317 static void pvr2_hdw_set_cur_freq(struct pvr2_hdw *,unsigned long);
318 static void pvr2_hdw_worker_poll(struct work_struct *work);
319 static int pvr2_hdw_wait(struct pvr2_hdw *,int state);
320 static int pvr2_hdw_untrip_unlocked(struct pvr2_hdw *);
321 static void pvr2_hdw_state_log_state(struct pvr2_hdw *);
322 static int pvr2_hdw_cmd_usbstream(struct pvr2_hdw *hdw,int runFl);
323 static int pvr2_hdw_commit_setup(struct pvr2_hdw *hdw);
324 static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw);
325 static void pvr2_hdw_quiescent_timeout(struct timer_list *);
326 static void pvr2_hdw_decoder_stabilization_timeout(struct timer_list *);
327 static void pvr2_hdw_encoder_wait_timeout(struct timer_list *);
328 static void pvr2_hdw_encoder_run_timeout(struct timer_list *);
329 static int pvr2_issue_simple_cmd(struct pvr2_hdw *,u32);
330 static int pvr2_send_request_ex(struct pvr2_hdw *hdw,
331 				unsigned int timeout,int probe_fl,
332 				void *write_data,unsigned int write_len,
333 				void *read_data,unsigned int read_len);
334 static int pvr2_hdw_check_cropcap(struct pvr2_hdw *hdw);
335 static v4l2_std_id pvr2_hdw_get_detected_std(struct pvr2_hdw *hdw);
336 
337 static void trace_stbit(const char *name,int val)
338 {
339 	pvr2_trace(PVR2_TRACE_STBITS,
340 		   "State bit %s <-- %s",
341 		   name,(val ? "true" : "false"));
342 }
343 
344 static int ctrl_channelfreq_get(struct pvr2_ctrl *cptr,int *vp)
345 {
346 	struct pvr2_hdw *hdw = cptr->hdw;
347 	if ((hdw->freqProgSlot > 0) && (hdw->freqProgSlot <= FREQTABLE_SIZE)) {
348 		*vp = hdw->freqTable[hdw->freqProgSlot-1];
349 	} else {
350 		*vp = 0;
351 	}
352 	return 0;
353 }
354 
355 static int ctrl_channelfreq_set(struct pvr2_ctrl *cptr,int m,int v)
356 {
357 	struct pvr2_hdw *hdw = cptr->hdw;
358 	unsigned int slotId = hdw->freqProgSlot;
359 	if ((slotId > 0) && (slotId <= FREQTABLE_SIZE)) {
360 		hdw->freqTable[slotId-1] = v;
361 		/* Handle side effects correctly - if we're tuned to this
362 		   slot, then forgot the slot id relation since the stored
363 		   frequency has been changed. */
364 		if (hdw->freqSelector) {
365 			if (hdw->freqSlotRadio == slotId) {
366 				hdw->freqSlotRadio = 0;
367 			}
368 		} else {
369 			if (hdw->freqSlotTelevision == slotId) {
370 				hdw->freqSlotTelevision = 0;
371 			}
372 		}
373 	}
374 	return 0;
375 }
376 
377 static int ctrl_channelprog_get(struct pvr2_ctrl *cptr,int *vp)
378 {
379 	*vp = cptr->hdw->freqProgSlot;
380 	return 0;
381 }
382 
383 static int ctrl_channelprog_set(struct pvr2_ctrl *cptr,int m,int v)
384 {
385 	struct pvr2_hdw *hdw = cptr->hdw;
386 	if ((v >= 0) && (v <= FREQTABLE_SIZE)) {
387 		hdw->freqProgSlot = v;
388 	}
389 	return 0;
390 }
391 
392 static int ctrl_channel_get(struct pvr2_ctrl *cptr,int *vp)
393 {
394 	struct pvr2_hdw *hdw = cptr->hdw;
395 	*vp = hdw->freqSelector ? hdw->freqSlotRadio : hdw->freqSlotTelevision;
396 	return 0;
397 }
398 
399 static int ctrl_channel_set(struct pvr2_ctrl *cptr,int m,int slotId)
400 {
401 	unsigned freq = 0;
402 	struct pvr2_hdw *hdw = cptr->hdw;
403 	if ((slotId < 0) || (slotId > FREQTABLE_SIZE)) return 0;
404 	if (slotId > 0) {
405 		freq = hdw->freqTable[slotId-1];
406 		if (!freq) return 0;
407 		pvr2_hdw_set_cur_freq(hdw,freq);
408 	}
409 	if (hdw->freqSelector) {
410 		hdw->freqSlotRadio = slotId;
411 	} else {
412 		hdw->freqSlotTelevision = slotId;
413 	}
414 	return 0;
415 }
416 
417 static int ctrl_freq_get(struct pvr2_ctrl *cptr,int *vp)
418 {
419 	*vp = pvr2_hdw_get_cur_freq(cptr->hdw);
420 	return 0;
421 }
422 
423 static int ctrl_freq_is_dirty(struct pvr2_ctrl *cptr)
424 {
425 	return cptr->hdw->freqDirty != 0;
426 }
427 
428 static void ctrl_freq_clear_dirty(struct pvr2_ctrl *cptr)
429 {
430 	cptr->hdw->freqDirty = 0;
431 }
432 
433 static int ctrl_freq_set(struct pvr2_ctrl *cptr,int m,int v)
434 {
435 	pvr2_hdw_set_cur_freq(cptr->hdw,v);
436 	return 0;
437 }
438 
439 static int ctrl_cropl_min_get(struct pvr2_ctrl *cptr, int *left)
440 {
441 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
442 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
443 	if (stat != 0) {
444 		return stat;
445 	}
446 	*left = cap->bounds.left;
447 	return 0;
448 }
449 
450 static int ctrl_cropl_max_get(struct pvr2_ctrl *cptr, int *left)
451 {
452 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
453 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
454 	if (stat != 0) {
455 		return stat;
456 	}
457 	*left = cap->bounds.left;
458 	if (cap->bounds.width > cptr->hdw->cropw_val) {
459 		*left += cap->bounds.width - cptr->hdw->cropw_val;
460 	}
461 	return 0;
462 }
463 
464 static int ctrl_cropt_min_get(struct pvr2_ctrl *cptr, int *top)
465 {
466 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
467 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
468 	if (stat != 0) {
469 		return stat;
470 	}
471 	*top = cap->bounds.top;
472 	return 0;
473 }
474 
475 static int ctrl_cropt_max_get(struct pvr2_ctrl *cptr, int *top)
476 {
477 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
478 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
479 	if (stat != 0) {
480 		return stat;
481 	}
482 	*top = cap->bounds.top;
483 	if (cap->bounds.height > cptr->hdw->croph_val) {
484 		*top += cap->bounds.height - cptr->hdw->croph_val;
485 	}
486 	return 0;
487 }
488 
489 static int ctrl_cropw_max_get(struct pvr2_ctrl *cptr, int *width)
490 {
491 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
492 	int stat, bleftend, cleft;
493 
494 	stat = pvr2_hdw_check_cropcap(cptr->hdw);
495 	if (stat != 0) {
496 		return stat;
497 	}
498 	bleftend = cap->bounds.left+cap->bounds.width;
499 	cleft = cptr->hdw->cropl_val;
500 
501 	*width = cleft < bleftend ? bleftend-cleft : 0;
502 	return 0;
503 }
504 
505 static int ctrl_croph_max_get(struct pvr2_ctrl *cptr, int *height)
506 {
507 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
508 	int stat, btopend, ctop;
509 
510 	stat = pvr2_hdw_check_cropcap(cptr->hdw);
511 	if (stat != 0) {
512 		return stat;
513 	}
514 	btopend = cap->bounds.top+cap->bounds.height;
515 	ctop = cptr->hdw->cropt_val;
516 
517 	*height = ctop < btopend ? btopend-ctop : 0;
518 	return 0;
519 }
520 
521 static int ctrl_get_cropcapbl(struct pvr2_ctrl *cptr, int *val)
522 {
523 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
524 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
525 	if (stat != 0) {
526 		return stat;
527 	}
528 	*val = cap->bounds.left;
529 	return 0;
530 }
531 
532 static int ctrl_get_cropcapbt(struct pvr2_ctrl *cptr, int *val)
533 {
534 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
535 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
536 	if (stat != 0) {
537 		return stat;
538 	}
539 	*val = cap->bounds.top;
540 	return 0;
541 }
542 
543 static int ctrl_get_cropcapbw(struct pvr2_ctrl *cptr, int *val)
544 {
545 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
546 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
547 	if (stat != 0) {
548 		return stat;
549 	}
550 	*val = cap->bounds.width;
551 	return 0;
552 }
553 
554 static int ctrl_get_cropcapbh(struct pvr2_ctrl *cptr, int *val)
555 {
556 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
557 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
558 	if (stat != 0) {
559 		return stat;
560 	}
561 	*val = cap->bounds.height;
562 	return 0;
563 }
564 
565 static int ctrl_get_cropcapdl(struct pvr2_ctrl *cptr, int *val)
566 {
567 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
568 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
569 	if (stat != 0) {
570 		return stat;
571 	}
572 	*val = cap->defrect.left;
573 	return 0;
574 }
575 
576 static int ctrl_get_cropcapdt(struct pvr2_ctrl *cptr, int *val)
577 {
578 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
579 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
580 	if (stat != 0) {
581 		return stat;
582 	}
583 	*val = cap->defrect.top;
584 	return 0;
585 }
586 
587 static int ctrl_get_cropcapdw(struct pvr2_ctrl *cptr, int *val)
588 {
589 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
590 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
591 	if (stat != 0) {
592 		return stat;
593 	}
594 	*val = cap->defrect.width;
595 	return 0;
596 }
597 
598 static int ctrl_get_cropcapdh(struct pvr2_ctrl *cptr, int *val)
599 {
600 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
601 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
602 	if (stat != 0) {
603 		return stat;
604 	}
605 	*val = cap->defrect.height;
606 	return 0;
607 }
608 
609 static int ctrl_get_cropcappan(struct pvr2_ctrl *cptr, int *val)
610 {
611 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
612 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
613 	if (stat != 0) {
614 		return stat;
615 	}
616 	*val = cap->pixelaspect.numerator;
617 	return 0;
618 }
619 
620 static int ctrl_get_cropcappad(struct pvr2_ctrl *cptr, int *val)
621 {
622 	struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
623 	int stat = pvr2_hdw_check_cropcap(cptr->hdw);
624 	if (stat != 0) {
625 		return stat;
626 	}
627 	*val = cap->pixelaspect.denominator;
628 	return 0;
629 }
630 
631 static int ctrl_vres_max_get(struct pvr2_ctrl *cptr,int *vp)
632 {
633 	/* Actual maximum depends on the video standard in effect. */
634 	if (cptr->hdw->std_mask_cur & V4L2_STD_525_60) {
635 		*vp = 480;
636 	} else {
637 		*vp = 576;
638 	}
639 	return 0;
640 }
641 
642 static int ctrl_vres_min_get(struct pvr2_ctrl *cptr,int *vp)
643 {
644 	/* Actual minimum depends on device digitizer type. */
645 	if (cptr->hdw->hdw_desc->flag_has_cx25840) {
646 		*vp = 75;
647 	} else {
648 		*vp = 17;
649 	}
650 	return 0;
651 }
652 
653 static int ctrl_get_input(struct pvr2_ctrl *cptr,int *vp)
654 {
655 	*vp = cptr->hdw->input_val;
656 	return 0;
657 }
658 
659 static int ctrl_check_input(struct pvr2_ctrl *cptr,int v)
660 {
661 	if (v < 0 || v > PVR2_CVAL_INPUT_MAX)
662 		return 0;
663 	return ((1UL << v) & cptr->hdw->input_allowed_mask) != 0;
664 }
665 
666 static int ctrl_set_input(struct pvr2_ctrl *cptr,int m,int v)
667 {
668 	return pvr2_hdw_set_input(cptr->hdw,v);
669 }
670 
671 static int ctrl_isdirty_input(struct pvr2_ctrl *cptr)
672 {
673 	return cptr->hdw->input_dirty != 0;
674 }
675 
676 static void ctrl_cleardirty_input(struct pvr2_ctrl *cptr)
677 {
678 	cptr->hdw->input_dirty = 0;
679 }
680 
681 
682 static int ctrl_freq_max_get(struct pvr2_ctrl *cptr, int *vp)
683 {
684 	unsigned long fv;
685 	struct pvr2_hdw *hdw = cptr->hdw;
686 	if (hdw->tuner_signal_stale) {
687 		pvr2_hdw_status_poll(hdw);
688 	}
689 	fv = hdw->tuner_signal_info.rangehigh;
690 	if (!fv) {
691 		/* Safety fallback */
692 		*vp = TV_MAX_FREQ;
693 		return 0;
694 	}
695 	if (hdw->tuner_signal_info.capability & V4L2_TUNER_CAP_LOW) {
696 		fv = (fv * 125) / 2;
697 	} else {
698 		fv = fv * 62500;
699 	}
700 	*vp = fv;
701 	return 0;
702 }
703 
704 static int ctrl_freq_min_get(struct pvr2_ctrl *cptr, int *vp)
705 {
706 	unsigned long fv;
707 	struct pvr2_hdw *hdw = cptr->hdw;
708 	if (hdw->tuner_signal_stale) {
709 		pvr2_hdw_status_poll(hdw);
710 	}
711 	fv = hdw->tuner_signal_info.rangelow;
712 	if (!fv) {
713 		/* Safety fallback */
714 		*vp = TV_MIN_FREQ;
715 		return 0;
716 	}
717 	if (hdw->tuner_signal_info.capability & V4L2_TUNER_CAP_LOW) {
718 		fv = (fv * 125) / 2;
719 	} else {
720 		fv = fv * 62500;
721 	}
722 	*vp = fv;
723 	return 0;
724 }
725 
726 static int ctrl_cx2341x_is_dirty(struct pvr2_ctrl *cptr)
727 {
728 	return cptr->hdw->enc_stale != 0;
729 }
730 
731 static void ctrl_cx2341x_clear_dirty(struct pvr2_ctrl *cptr)
732 {
733 	cptr->hdw->enc_stale = 0;
734 	cptr->hdw->enc_unsafe_stale = 0;
735 }
736 
737 static int ctrl_cx2341x_get(struct pvr2_ctrl *cptr,int *vp)
738 {
739 	int ret;
740 	struct v4l2_ext_controls cs;
741 	struct v4l2_ext_control c1;
742 	memset(&cs,0,sizeof(cs));
743 	memset(&c1,0,sizeof(c1));
744 	cs.controls = &c1;
745 	cs.count = 1;
746 	c1.id = cptr->info->v4l_id;
747 	ret = cx2341x_ext_ctrls(&cptr->hdw->enc_ctl_state, 0, &cs,
748 				VIDIOC_G_EXT_CTRLS);
749 	if (ret) return ret;
750 	*vp = c1.value;
751 	return 0;
752 }
753 
754 static int ctrl_cx2341x_set(struct pvr2_ctrl *cptr,int m,int v)
755 {
756 	int ret;
757 	struct pvr2_hdw *hdw = cptr->hdw;
758 	struct v4l2_ext_controls cs;
759 	struct v4l2_ext_control c1;
760 	memset(&cs,0,sizeof(cs));
761 	memset(&c1,0,sizeof(c1));
762 	cs.controls = &c1;
763 	cs.count = 1;
764 	c1.id = cptr->info->v4l_id;
765 	c1.value = v;
766 	ret = cx2341x_ext_ctrls(&hdw->enc_ctl_state,
767 				hdw->state_encoder_run, &cs,
768 				VIDIOC_S_EXT_CTRLS);
769 	if (ret == -EBUSY) {
770 		/* Oops.  cx2341x is telling us it's not safe to change
771 		   this control while we're capturing.  Make a note of this
772 		   fact so that the pipeline will be stopped the next time
773 		   controls are committed.  Then go on ahead and store this
774 		   change anyway. */
775 		ret = cx2341x_ext_ctrls(&hdw->enc_ctl_state,
776 					0, &cs,
777 					VIDIOC_S_EXT_CTRLS);
778 		if (!ret) hdw->enc_unsafe_stale = !0;
779 	}
780 	if (ret) return ret;
781 	hdw->enc_stale = !0;
782 	return 0;
783 }
784 
785 static unsigned int ctrl_cx2341x_getv4lflags(struct pvr2_ctrl *cptr)
786 {
787 	struct v4l2_queryctrl qctrl = {};
788 	struct pvr2_ctl_info *info;
789 	qctrl.id = cptr->info->v4l_id;
790 	cx2341x_ctrl_query(&cptr->hdw->enc_ctl_state,&qctrl);
791 	/* Strip out the const so we can adjust a function pointer.  It's
792 	   OK to do this here because we know this is a dynamically created
793 	   control, so the underlying storage for the info pointer is (a)
794 	   private to us, and (b) not in read-only storage.  Either we do
795 	   this or we significantly complicate the underlying control
796 	   implementation. */
797 	info = (struct pvr2_ctl_info *)(cptr->info);
798 	if (qctrl.flags & V4L2_CTRL_FLAG_READ_ONLY) {
799 		if (info->set_value) {
800 			info->set_value = NULL;
801 		}
802 	} else {
803 		if (!(info->set_value)) {
804 			info->set_value = ctrl_cx2341x_set;
805 		}
806 	}
807 	return qctrl.flags;
808 }
809 
810 static int ctrl_streamingenabled_get(struct pvr2_ctrl *cptr,int *vp)
811 {
812 	*vp = cptr->hdw->state_pipeline_req;
813 	return 0;
814 }
815 
816 static int ctrl_masterstate_get(struct pvr2_ctrl *cptr,int *vp)
817 {
818 	*vp = cptr->hdw->master_state;
819 	return 0;
820 }
821 
822 static int ctrl_hsm_get(struct pvr2_ctrl *cptr,int *vp)
823 {
824 	int result = pvr2_hdw_is_hsm(cptr->hdw);
825 	*vp = PVR2_CVAL_HSM_FULL;
826 	if (result < 0) *vp = PVR2_CVAL_HSM_FAIL;
827 	if (result) *vp = PVR2_CVAL_HSM_HIGH;
828 	return 0;
829 }
830 
831 static int ctrl_stddetect_get(struct pvr2_ctrl *cptr, int *vp)
832 {
833 	*vp = pvr2_hdw_get_detected_std(cptr->hdw);
834 	return 0;
835 }
836 
837 static int ctrl_stdavail_get(struct pvr2_ctrl *cptr,int *vp)
838 {
839 	*vp = cptr->hdw->std_mask_avail;
840 	return 0;
841 }
842 
843 static int ctrl_stdavail_set(struct pvr2_ctrl *cptr,int m,int v)
844 {
845 	struct pvr2_hdw *hdw = cptr->hdw;
846 	v4l2_std_id ns;
847 	ns = hdw->std_mask_avail;
848 	ns = (ns & ~m) | (v & m);
849 	if (ns == hdw->std_mask_avail) return 0;
850 	hdw->std_mask_avail = ns;
851 	hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
852 	return 0;
853 }
854 
855 static int ctrl_std_val_to_sym(struct pvr2_ctrl *cptr,int msk,int val,
856 			       char *bufPtr,unsigned int bufSize,
857 			       unsigned int *len)
858 {
859 	*len = pvr2_std_id_to_str(bufPtr,bufSize,msk & val);
860 	return 0;
861 }
862 
863 static int ctrl_std_sym_to_val(struct pvr2_ctrl *cptr,
864 			       const char *bufPtr,unsigned int bufSize,
865 			       int *mskp,int *valp)
866 {
867 	v4l2_std_id id;
868 	if (!pvr2_std_str_to_id(&id, bufPtr, bufSize))
869 		return -EINVAL;
870 	if (mskp) *mskp = id;
871 	if (valp) *valp = id;
872 	return 0;
873 }
874 
875 static int ctrl_stdcur_get(struct pvr2_ctrl *cptr,int *vp)
876 {
877 	*vp = cptr->hdw->std_mask_cur;
878 	return 0;
879 }
880 
881 static int ctrl_stdcur_set(struct pvr2_ctrl *cptr,int m,int v)
882 {
883 	struct pvr2_hdw *hdw = cptr->hdw;
884 	v4l2_std_id ns;
885 	ns = hdw->std_mask_cur;
886 	ns = (ns & ~m) | (v & m);
887 	if (ns == hdw->std_mask_cur) return 0;
888 	hdw->std_mask_cur = ns;
889 	hdw->std_dirty = !0;
890 	return 0;
891 }
892 
893 static int ctrl_stdcur_is_dirty(struct pvr2_ctrl *cptr)
894 {
895 	return cptr->hdw->std_dirty != 0;
896 }
897 
898 static void ctrl_stdcur_clear_dirty(struct pvr2_ctrl *cptr)
899 {
900 	cptr->hdw->std_dirty = 0;
901 }
902 
903 static int ctrl_signal_get(struct pvr2_ctrl *cptr,int *vp)
904 {
905 	struct pvr2_hdw *hdw = cptr->hdw;
906 	pvr2_hdw_status_poll(hdw);
907 	*vp = hdw->tuner_signal_info.signal;
908 	return 0;
909 }
910 
911 static int ctrl_audio_modes_present_get(struct pvr2_ctrl *cptr,int *vp)
912 {
913 	int val = 0;
914 	unsigned int subchan;
915 	struct pvr2_hdw *hdw = cptr->hdw;
916 	pvr2_hdw_status_poll(hdw);
917 	subchan = hdw->tuner_signal_info.rxsubchans;
918 	if (subchan & V4L2_TUNER_SUB_MONO) {
919 		val |= (1 << V4L2_TUNER_MODE_MONO);
920 	}
921 	if (subchan & V4L2_TUNER_SUB_STEREO) {
922 		val |= (1 << V4L2_TUNER_MODE_STEREO);
923 	}
924 	if (subchan & V4L2_TUNER_SUB_LANG1) {
925 		val |= (1 << V4L2_TUNER_MODE_LANG1);
926 	}
927 	if (subchan & V4L2_TUNER_SUB_LANG2) {
928 		val |= (1 << V4L2_TUNER_MODE_LANG2);
929 	}
930 	*vp = val;
931 	return 0;
932 }
933 
934 
935 #define DEFINT(vmin,vmax) \
936 	.type = pvr2_ctl_int, \
937 	.def.type_int.min_value = vmin, \
938 	.def.type_int.max_value = vmax
939 
940 #define DEFENUM(tab) \
941 	.type = pvr2_ctl_enum, \
942 	.def.type_enum.count = ARRAY_SIZE(tab), \
943 	.def.type_enum.value_names = tab
944 
945 #define DEFBOOL \
946 	.type = pvr2_ctl_bool
947 
948 #define DEFMASK(msk,tab) \
949 	.type = pvr2_ctl_bitmask, \
950 	.def.type_bitmask.valid_bits = msk, \
951 	.def.type_bitmask.bit_names = tab
952 
953 #define DEFREF(vname) \
954 	.set_value = ctrl_set_##vname, \
955 	.get_value = ctrl_get_##vname, \
956 	.is_dirty = ctrl_isdirty_##vname, \
957 	.clear_dirty = ctrl_cleardirty_##vname
958 
959 
960 #define VCREATE_FUNCS(vname) \
961 static int ctrl_get_##vname(struct pvr2_ctrl *cptr,int *vp) \
962 {*vp = cptr->hdw->vname##_val; return 0;} \
963 static int ctrl_set_##vname(struct pvr2_ctrl *cptr,int m,int v) \
964 {cptr->hdw->vname##_val = v; cptr->hdw->vname##_dirty = !0; return 0;} \
965 static int ctrl_isdirty_##vname(struct pvr2_ctrl *cptr) \
966 {return cptr->hdw->vname##_dirty != 0;} \
967 static void ctrl_cleardirty_##vname(struct pvr2_ctrl *cptr) \
968 {cptr->hdw->vname##_dirty = 0;}
969 
970 VCREATE_FUNCS(brightness)
971 VCREATE_FUNCS(contrast)
972 VCREATE_FUNCS(saturation)
973 VCREATE_FUNCS(hue)
974 VCREATE_FUNCS(volume)
975 VCREATE_FUNCS(balance)
976 VCREATE_FUNCS(bass)
977 VCREATE_FUNCS(treble)
978 VCREATE_FUNCS(mute)
979 VCREATE_FUNCS(cropl)
980 VCREATE_FUNCS(cropt)
981 VCREATE_FUNCS(cropw)
982 VCREATE_FUNCS(croph)
983 VCREATE_FUNCS(audiomode)
984 VCREATE_FUNCS(res_hor)
985 VCREATE_FUNCS(res_ver)
986 VCREATE_FUNCS(srate)
987 
988 /* Table definition of all controls which can be manipulated */
989 static const struct pvr2_ctl_info control_defs[] = {
990 	{
991 		.v4l_id = V4L2_CID_BRIGHTNESS,
992 		.desc = "Brightness",
993 		.name = "brightness",
994 		.default_value = 128,
995 		DEFREF(brightness),
996 		DEFINT(0,255),
997 	},{
998 		.v4l_id = V4L2_CID_CONTRAST,
999 		.desc = "Contrast",
1000 		.name = "contrast",
1001 		.default_value = 68,
1002 		DEFREF(contrast),
1003 		DEFINT(0,127),
1004 	},{
1005 		.v4l_id = V4L2_CID_SATURATION,
1006 		.desc = "Saturation",
1007 		.name = "saturation",
1008 		.default_value = 64,
1009 		DEFREF(saturation),
1010 		DEFINT(0,127),
1011 	},{
1012 		.v4l_id = V4L2_CID_HUE,
1013 		.desc = "Hue",
1014 		.name = "hue",
1015 		.default_value = 0,
1016 		DEFREF(hue),
1017 		DEFINT(-128,127),
1018 	},{
1019 		.v4l_id = V4L2_CID_AUDIO_VOLUME,
1020 		.desc = "Volume",
1021 		.name = "volume",
1022 		.default_value = 62000,
1023 		DEFREF(volume),
1024 		DEFINT(0,65535),
1025 	},{
1026 		.v4l_id = V4L2_CID_AUDIO_BALANCE,
1027 		.desc = "Balance",
1028 		.name = "balance",
1029 		.default_value = 0,
1030 		DEFREF(balance),
1031 		DEFINT(-32768,32767),
1032 	},{
1033 		.v4l_id = V4L2_CID_AUDIO_BASS,
1034 		.desc = "Bass",
1035 		.name = "bass",
1036 		.default_value = 0,
1037 		DEFREF(bass),
1038 		DEFINT(-32768,32767),
1039 	},{
1040 		.v4l_id = V4L2_CID_AUDIO_TREBLE,
1041 		.desc = "Treble",
1042 		.name = "treble",
1043 		.default_value = 0,
1044 		DEFREF(treble),
1045 		DEFINT(-32768,32767),
1046 	},{
1047 		.v4l_id = V4L2_CID_AUDIO_MUTE,
1048 		.desc = "Mute",
1049 		.name = "mute",
1050 		.default_value = 0,
1051 		DEFREF(mute),
1052 		DEFBOOL,
1053 	}, {
1054 		.desc = "Capture crop left margin",
1055 		.name = "crop_left",
1056 		.internal_id = PVR2_CID_CROPL,
1057 		.default_value = 0,
1058 		DEFREF(cropl),
1059 		DEFINT(-129, 340),
1060 		.get_min_value = ctrl_cropl_min_get,
1061 		.get_max_value = ctrl_cropl_max_get,
1062 		.get_def_value = ctrl_get_cropcapdl,
1063 	}, {
1064 		.desc = "Capture crop top margin",
1065 		.name = "crop_top",
1066 		.internal_id = PVR2_CID_CROPT,
1067 		.default_value = 0,
1068 		DEFREF(cropt),
1069 		DEFINT(-35, 544),
1070 		.get_min_value = ctrl_cropt_min_get,
1071 		.get_max_value = ctrl_cropt_max_get,
1072 		.get_def_value = ctrl_get_cropcapdt,
1073 	}, {
1074 		.desc = "Capture crop width",
1075 		.name = "crop_width",
1076 		.internal_id = PVR2_CID_CROPW,
1077 		.default_value = 720,
1078 		DEFREF(cropw),
1079 		DEFINT(0, 864),
1080 		.get_max_value = ctrl_cropw_max_get,
1081 		.get_def_value = ctrl_get_cropcapdw,
1082 	}, {
1083 		.desc = "Capture crop height",
1084 		.name = "crop_height",
1085 		.internal_id = PVR2_CID_CROPH,
1086 		.default_value = 480,
1087 		DEFREF(croph),
1088 		DEFINT(0, 576),
1089 		.get_max_value = ctrl_croph_max_get,
1090 		.get_def_value = ctrl_get_cropcapdh,
1091 	}, {
1092 		.desc = "Capture capability pixel aspect numerator",
1093 		.name = "cropcap_pixel_numerator",
1094 		.internal_id = PVR2_CID_CROPCAPPAN,
1095 		.get_value = ctrl_get_cropcappan,
1096 	}, {
1097 		.desc = "Capture capability pixel aspect denominator",
1098 		.name = "cropcap_pixel_denominator",
1099 		.internal_id = PVR2_CID_CROPCAPPAD,
1100 		.get_value = ctrl_get_cropcappad,
1101 	}, {
1102 		.desc = "Capture capability bounds top",
1103 		.name = "cropcap_bounds_top",
1104 		.internal_id = PVR2_CID_CROPCAPBT,
1105 		.get_value = ctrl_get_cropcapbt,
1106 	}, {
1107 		.desc = "Capture capability bounds left",
1108 		.name = "cropcap_bounds_left",
1109 		.internal_id = PVR2_CID_CROPCAPBL,
1110 		.get_value = ctrl_get_cropcapbl,
1111 	}, {
1112 		.desc = "Capture capability bounds width",
1113 		.name = "cropcap_bounds_width",
1114 		.internal_id = PVR2_CID_CROPCAPBW,
1115 		.get_value = ctrl_get_cropcapbw,
1116 	}, {
1117 		.desc = "Capture capability bounds height",
1118 		.name = "cropcap_bounds_height",
1119 		.internal_id = PVR2_CID_CROPCAPBH,
1120 		.get_value = ctrl_get_cropcapbh,
1121 	},{
1122 		.desc = "Video Source",
1123 		.name = "input",
1124 		.internal_id = PVR2_CID_INPUT,
1125 		.default_value = PVR2_CVAL_INPUT_TV,
1126 		.check_value = ctrl_check_input,
1127 		DEFREF(input),
1128 		DEFENUM(control_values_input),
1129 	},{
1130 		.desc = "Audio Mode",
1131 		.name = "audio_mode",
1132 		.internal_id = PVR2_CID_AUDIOMODE,
1133 		.default_value = V4L2_TUNER_MODE_STEREO,
1134 		DEFREF(audiomode),
1135 		DEFENUM(control_values_audiomode),
1136 	},{
1137 		.desc = "Horizontal capture resolution",
1138 		.name = "resolution_hor",
1139 		.internal_id = PVR2_CID_HRES,
1140 		.default_value = 720,
1141 		DEFREF(res_hor),
1142 		DEFINT(19,720),
1143 	},{
1144 		.desc = "Vertical capture resolution",
1145 		.name = "resolution_ver",
1146 		.internal_id = PVR2_CID_VRES,
1147 		.default_value = 480,
1148 		DEFREF(res_ver),
1149 		DEFINT(17,576),
1150 		/* Hook in check for video standard and adjust maximum
1151 		   depending on the standard. */
1152 		.get_max_value = ctrl_vres_max_get,
1153 		.get_min_value = ctrl_vres_min_get,
1154 	},{
1155 		.v4l_id = V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
1156 		.default_value = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
1157 		.desc = "Audio Sampling Frequency",
1158 		.name = "srate",
1159 		DEFREF(srate),
1160 		DEFENUM(control_values_srate),
1161 	},{
1162 		.desc = "Tuner Frequency (Hz)",
1163 		.name = "frequency",
1164 		.internal_id = PVR2_CID_FREQUENCY,
1165 		.default_value = 0,
1166 		.set_value = ctrl_freq_set,
1167 		.get_value = ctrl_freq_get,
1168 		.is_dirty = ctrl_freq_is_dirty,
1169 		.clear_dirty = ctrl_freq_clear_dirty,
1170 		DEFINT(0,0),
1171 		/* Hook in check for input value (tv/radio) and adjust
1172 		   max/min values accordingly */
1173 		.get_max_value = ctrl_freq_max_get,
1174 		.get_min_value = ctrl_freq_min_get,
1175 	},{
1176 		.desc = "Channel",
1177 		.name = "channel",
1178 		.set_value = ctrl_channel_set,
1179 		.get_value = ctrl_channel_get,
1180 		DEFINT(0,FREQTABLE_SIZE),
1181 	},{
1182 		.desc = "Channel Program Frequency",
1183 		.name = "freq_table_value",
1184 		.set_value = ctrl_channelfreq_set,
1185 		.get_value = ctrl_channelfreq_get,
1186 		DEFINT(0,0),
1187 		/* Hook in check for input value (tv/radio) and adjust
1188 		   max/min values accordingly */
1189 		.get_max_value = ctrl_freq_max_get,
1190 		.get_min_value = ctrl_freq_min_get,
1191 	},{
1192 		.desc = "Channel Program ID",
1193 		.name = "freq_table_channel",
1194 		.set_value = ctrl_channelprog_set,
1195 		.get_value = ctrl_channelprog_get,
1196 		DEFINT(0,FREQTABLE_SIZE),
1197 	},{
1198 		.desc = "Streaming Enabled",
1199 		.name = "streaming_enabled",
1200 		.get_value = ctrl_streamingenabled_get,
1201 		DEFBOOL,
1202 	},{
1203 		.desc = "USB Speed",
1204 		.name = "usb_speed",
1205 		.get_value = ctrl_hsm_get,
1206 		DEFENUM(control_values_hsm),
1207 	},{
1208 		.desc = "Master State",
1209 		.name = "master_state",
1210 		.get_value = ctrl_masterstate_get,
1211 		DEFENUM(pvr2_state_names),
1212 	},{
1213 		.desc = "Signal Present",
1214 		.name = "signal_present",
1215 		.get_value = ctrl_signal_get,
1216 		DEFINT(0,65535),
1217 	},{
1218 		.desc = "Audio Modes Present",
1219 		.name = "audio_modes_present",
1220 		.get_value = ctrl_audio_modes_present_get,
1221 		/* For this type we "borrow" the V4L2_TUNER_MODE enum from
1222 		   v4l.  Nothing outside of this module cares about this,
1223 		   but I reuse it in order to also reuse the
1224 		   control_values_audiomode string table. */
1225 		DEFMASK(((1 << V4L2_TUNER_MODE_MONO)|
1226 			 (1 << V4L2_TUNER_MODE_STEREO)|
1227 			 (1 << V4L2_TUNER_MODE_LANG1)|
1228 			 (1 << V4L2_TUNER_MODE_LANG2)),
1229 			control_values_audiomode),
1230 	},{
1231 		.desc = "Video Standards Available Mask",
1232 		.name = "video_standard_mask_available",
1233 		.internal_id = PVR2_CID_STDAVAIL,
1234 		.skip_init = !0,
1235 		.get_value = ctrl_stdavail_get,
1236 		.set_value = ctrl_stdavail_set,
1237 		.val_to_sym = ctrl_std_val_to_sym,
1238 		.sym_to_val = ctrl_std_sym_to_val,
1239 		.type = pvr2_ctl_bitmask,
1240 	},{
1241 		.desc = "Video Standards In Use Mask",
1242 		.name = "video_standard_mask_active",
1243 		.internal_id = PVR2_CID_STDCUR,
1244 		.skip_init = !0,
1245 		.get_value = ctrl_stdcur_get,
1246 		.set_value = ctrl_stdcur_set,
1247 		.is_dirty = ctrl_stdcur_is_dirty,
1248 		.clear_dirty = ctrl_stdcur_clear_dirty,
1249 		.val_to_sym = ctrl_std_val_to_sym,
1250 		.sym_to_val = ctrl_std_sym_to_val,
1251 		.type = pvr2_ctl_bitmask,
1252 	},{
1253 		.desc = "Video Standards Detected Mask",
1254 		.name = "video_standard_mask_detected",
1255 		.internal_id = PVR2_CID_STDDETECT,
1256 		.skip_init = !0,
1257 		.get_value = ctrl_stddetect_get,
1258 		.val_to_sym = ctrl_std_val_to_sym,
1259 		.sym_to_val = ctrl_std_sym_to_val,
1260 		.type = pvr2_ctl_bitmask,
1261 	}
1262 };
1263 
1264 #define CTRLDEF_COUNT ARRAY_SIZE(control_defs)
1265 
1266 
1267 const char *pvr2_config_get_name(enum pvr2_config cfg)
1268 {
1269 	switch (cfg) {
1270 	case pvr2_config_empty: return "empty";
1271 	case pvr2_config_mpeg: return "mpeg";
1272 	case pvr2_config_vbi: return "vbi";
1273 	case pvr2_config_pcm: return "pcm";
1274 	case pvr2_config_rawvideo: return "raw video";
1275 	}
1276 	return "<unknown>";
1277 }
1278 
1279 
1280 struct usb_device *pvr2_hdw_get_dev(struct pvr2_hdw *hdw)
1281 {
1282 	return hdw->usb_dev;
1283 }
1284 
1285 
1286 unsigned long pvr2_hdw_get_sn(struct pvr2_hdw *hdw)
1287 {
1288 	return hdw->serial_number;
1289 }
1290 
1291 
1292 const char *pvr2_hdw_get_bus_info(struct pvr2_hdw *hdw)
1293 {
1294 	return hdw->bus_info;
1295 }
1296 
1297 
1298 const char *pvr2_hdw_get_device_identifier(struct pvr2_hdw *hdw)
1299 {
1300 	return hdw->identifier;
1301 }
1302 
1303 
1304 unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *hdw)
1305 {
1306 	return hdw->freqSelector ? hdw->freqValTelevision : hdw->freqValRadio;
1307 }
1308 
1309 /* Set the currently tuned frequency and account for all possible
1310    driver-core side effects of this action. */
1311 static void pvr2_hdw_set_cur_freq(struct pvr2_hdw *hdw,unsigned long val)
1312 {
1313 	if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
1314 		if (hdw->freqSelector) {
1315 			/* Swing over to radio frequency selection */
1316 			hdw->freqSelector = 0;
1317 			hdw->freqDirty = !0;
1318 		}
1319 		if (hdw->freqValRadio != val) {
1320 			hdw->freqValRadio = val;
1321 			hdw->freqSlotRadio = 0;
1322 			hdw->freqDirty = !0;
1323 		}
1324 	} else {
1325 		if (!(hdw->freqSelector)) {
1326 			/* Swing over to television frequency selection */
1327 			hdw->freqSelector = 1;
1328 			hdw->freqDirty = !0;
1329 		}
1330 		if (hdw->freqValTelevision != val) {
1331 			hdw->freqValTelevision = val;
1332 			hdw->freqSlotTelevision = 0;
1333 			hdw->freqDirty = !0;
1334 		}
1335 	}
1336 }
1337 
1338 int pvr2_hdw_get_unit_number(struct pvr2_hdw *hdw)
1339 {
1340 	return hdw->unit_number;
1341 }
1342 
1343 
1344 /* Attempt to locate one of the given set of files.  Messages are logged
1345    appropriate to what has been found.  The return value will be 0 or
1346    greater on success (it will be the index of the file name found) and
1347    fw_entry will be filled in.  Otherwise a negative error is returned on
1348    failure.  If the return value is -ENOENT then no viable firmware file
1349    could be located. */
1350 static int pvr2_locate_firmware(struct pvr2_hdw *hdw,
1351 				const struct firmware **fw_entry,
1352 				const char *fwtypename,
1353 				unsigned int fwcount,
1354 				const char *fwnames[])
1355 {
1356 	unsigned int idx;
1357 	int ret = -EINVAL;
1358 	for (idx = 0; idx < fwcount; idx++) {
1359 		ret = request_firmware(fw_entry,
1360 				       fwnames[idx],
1361 				       &hdw->usb_dev->dev);
1362 		if (!ret) {
1363 			trace_firmware("Located %s firmware: %s; uploading...",
1364 				       fwtypename,
1365 				       fwnames[idx]);
1366 			return idx;
1367 		}
1368 		if (ret == -ENOENT) continue;
1369 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1370 			   "request_firmware fatal error with code=%d",ret);
1371 		return ret;
1372 	}
1373 	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1374 		   "***WARNING*** Device %s firmware seems to be missing.",
1375 		   fwtypename);
1376 	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1377 		   "Did you install the pvrusb2 firmware files in their proper location?");
1378 	if (fwcount == 1) {
1379 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1380 			   "request_firmware unable to locate %s file %s",
1381 			   fwtypename,fwnames[0]);
1382 	} else {
1383 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1384 			   "request_firmware unable to locate one of the following %s files:",
1385 			   fwtypename);
1386 		for (idx = 0; idx < fwcount; idx++) {
1387 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1388 				   "request_firmware: Failed to find %s",
1389 				   fwnames[idx]);
1390 		}
1391 	}
1392 	return ret;
1393 }
1394 
1395 
1396 /*
1397  * pvr2_upload_firmware1().
1398  *
1399  * Send the 8051 firmware to the device.  After the upload, arrange for
1400  * device to re-enumerate.
1401  *
1402  * NOTE : the pointer to the firmware data given by request_firmware()
1403  * is not suitable for an usb transaction.
1404  *
1405  */
1406 static int pvr2_upload_firmware1(struct pvr2_hdw *hdw)
1407 {
1408 	const struct firmware *fw_entry = NULL;
1409 	void  *fw_ptr;
1410 	unsigned int pipe;
1411 	unsigned int fwsize;
1412 	int ret;
1413 	u16 address;
1414 
1415 	if (!hdw->hdw_desc->fx2_firmware.cnt) {
1416 		hdw->fw1_state = FW1_STATE_OK;
1417 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1418 			   "Connected device type defines no firmware to upload; ignoring firmware");
1419 		return -ENOTTY;
1420 	}
1421 
1422 	hdw->fw1_state = FW1_STATE_FAILED; // default result
1423 
1424 	trace_firmware("pvr2_upload_firmware1");
1425 
1426 	ret = pvr2_locate_firmware(hdw,&fw_entry,"fx2 controller",
1427 				   hdw->hdw_desc->fx2_firmware.cnt,
1428 				   hdw->hdw_desc->fx2_firmware.lst);
1429 	if (ret < 0) {
1430 		if (ret == -ENOENT) hdw->fw1_state = FW1_STATE_MISSING;
1431 		return ret;
1432 	}
1433 
1434 	usb_clear_halt(hdw->usb_dev, usb_sndbulkpipe(hdw->usb_dev, 0 & 0x7f));
1435 
1436 	pipe = usb_sndctrlpipe(hdw->usb_dev, 0);
1437 	fwsize = fw_entry->size;
1438 
1439 	if ((fwsize != 0x2000) &&
1440 	    (!(hdw->hdw_desc->flag_fx2_16kb && (fwsize == 0x4000)))) {
1441 		if (hdw->hdw_desc->flag_fx2_16kb) {
1442 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1443 				   "Wrong fx2 firmware size (expected 8192 or 16384, got %u)",
1444 				   fwsize);
1445 		} else {
1446 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1447 				   "Wrong fx2 firmware size (expected 8192, got %u)",
1448 				   fwsize);
1449 		}
1450 		release_firmware(fw_entry);
1451 		return -ENOMEM;
1452 	}
1453 
1454 	fw_ptr = kmalloc(0x800, GFP_KERNEL);
1455 	if (fw_ptr == NULL){
1456 		release_firmware(fw_entry);
1457 		return -ENOMEM;
1458 	}
1459 
1460 	/* We have to hold the CPU during firmware upload. */
1461 	pvr2_hdw_cpureset_assert(hdw,1);
1462 
1463 	/* upload the firmware to address 0000-1fff in 2048 (=0x800) bytes
1464 	   chunk. */
1465 
1466 	ret = 0;
1467 	for (address = 0; address < fwsize; address += 0x800) {
1468 		memcpy(fw_ptr, fw_entry->data + address, 0x800);
1469 		ret += usb_control_msg(hdw->usb_dev, pipe, 0xa0, 0x40, address,
1470 				       0, fw_ptr, 0x800, 1000);
1471 	}
1472 
1473 	trace_firmware("Upload done, releasing device's CPU");
1474 
1475 	/* Now release the CPU.  It will disconnect and reconnect later. */
1476 	pvr2_hdw_cpureset_assert(hdw,0);
1477 
1478 	kfree(fw_ptr);
1479 	release_firmware(fw_entry);
1480 
1481 	trace_firmware("Upload done (%d bytes sent)",ret);
1482 
1483 	/* We should have written fwsize bytes */
1484 	if (ret == fwsize) {
1485 		hdw->fw1_state = FW1_STATE_RELOAD;
1486 		return 0;
1487 	}
1488 
1489 	return -EIO;
1490 }
1491 
1492 
1493 /*
1494  * pvr2_upload_firmware2()
1495  *
1496  * This uploads encoder firmware on endpoint 2.
1497  *
1498  */
1499 
1500 int pvr2_upload_firmware2(struct pvr2_hdw *hdw)
1501 {
1502 	const struct firmware *fw_entry = NULL;
1503 	void  *fw_ptr;
1504 	unsigned int pipe, fw_len, fw_done, bcnt, icnt;
1505 	int actual_length;
1506 	int ret = 0;
1507 	int fwidx;
1508 	static const char *fw_files[] = {
1509 		CX2341X_FIRM_ENC_FILENAME,
1510 	};
1511 
1512 	if (hdw->hdw_desc->flag_skip_cx23416_firmware) {
1513 		return 0;
1514 	}
1515 
1516 	trace_firmware("pvr2_upload_firmware2");
1517 
1518 	ret = pvr2_locate_firmware(hdw,&fw_entry,"encoder",
1519 				   ARRAY_SIZE(fw_files), fw_files);
1520 	if (ret < 0) return ret;
1521 	fwidx = ret;
1522 	ret = 0;
1523 	/* Since we're about to completely reinitialize the encoder,
1524 	   invalidate our cached copy of its configuration state.  Next
1525 	   time we configure the encoder, then we'll fully configure it. */
1526 	hdw->enc_cur_valid = 0;
1527 
1528 	/* Encoder is about to be reset so note that as far as we're
1529 	   concerned now, the encoder has never been run. */
1530 	del_timer_sync(&hdw->encoder_run_timer);
1531 	if (hdw->state_encoder_runok) {
1532 		hdw->state_encoder_runok = 0;
1533 		trace_stbit("state_encoder_runok",hdw->state_encoder_runok);
1534 	}
1535 
1536 	/* First prepare firmware loading */
1537 	ret |= pvr2_write_register(hdw, 0x0048, 0xffffffff); /*interrupt mask*/
1538 	ret |= pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000088); /*gpio dir*/
1539 	ret |= pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000008); /*gpio output state*/
1540 	ret |= pvr2_hdw_cmd_deep_reset(hdw);
1541 	ret |= pvr2_write_register(hdw, 0xa064, 0x00000000); /*APU command*/
1542 	ret |= pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000408); /*gpio dir*/
1543 	ret |= pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000008); /*gpio output state*/
1544 	ret |= pvr2_write_register(hdw, 0x9058, 0xffffffed); /*VPU ctrl*/
1545 	ret |= pvr2_write_register(hdw, 0x9054, 0xfffffffd); /*reset hw blocks*/
1546 	ret |= pvr2_write_register(hdw, 0x07f8, 0x80000800); /*encoder SDRAM refresh*/
1547 	ret |= pvr2_write_register(hdw, 0x07fc, 0x0000001a); /*encoder SDRAM pre-charge*/
1548 	ret |= pvr2_write_register(hdw, 0x0700, 0x00000000); /*I2C clock*/
1549 	ret |= pvr2_write_register(hdw, 0xaa00, 0x00000000); /*unknown*/
1550 	ret |= pvr2_write_register(hdw, 0xaa04, 0x00057810); /*unknown*/
1551 	ret |= pvr2_write_register(hdw, 0xaa10, 0x00148500); /*unknown*/
1552 	ret |= pvr2_write_register(hdw, 0xaa18, 0x00840000); /*unknown*/
1553 	ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_FWPOST1);
1554 	ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_MEMSEL | (1 << 8) | (0 << 16));
1555 
1556 	if (ret) {
1557 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1558 			   "firmware2 upload prep failed, ret=%d",ret);
1559 		release_firmware(fw_entry);
1560 		goto done;
1561 	}
1562 
1563 	/* Now send firmware */
1564 
1565 	fw_len = fw_entry->size;
1566 
1567 	if (fw_len % sizeof(u32)) {
1568 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1569 			   "size of %s firmware must be a multiple of %zu bytes",
1570 			   fw_files[fwidx],sizeof(u32));
1571 		release_firmware(fw_entry);
1572 		ret = -EINVAL;
1573 		goto done;
1574 	}
1575 
1576 	fw_ptr = kmalloc(FIRMWARE_CHUNK_SIZE, GFP_KERNEL);
1577 	if (fw_ptr == NULL){
1578 		release_firmware(fw_entry);
1579 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1580 			   "failed to allocate memory for firmware2 upload");
1581 		ret = -ENOMEM;
1582 		goto done;
1583 	}
1584 
1585 	pipe = usb_sndbulkpipe(hdw->usb_dev, PVR2_FIRMWARE_ENDPOINT);
1586 
1587 	fw_done = 0;
1588 	for (fw_done = 0; fw_done < fw_len;) {
1589 		bcnt = fw_len - fw_done;
1590 		if (bcnt > FIRMWARE_CHUNK_SIZE) bcnt = FIRMWARE_CHUNK_SIZE;
1591 		memcpy(fw_ptr, fw_entry->data + fw_done, bcnt);
1592 		/* Usbsnoop log shows that we must swap bytes... */
1593 		/* Some background info: The data being swapped here is a
1594 		   firmware image destined for the mpeg encoder chip that
1595 		   lives at the other end of a USB endpoint.  The encoder
1596 		   chip always talks in 32 bit chunks and its storage is
1597 		   organized into 32 bit words.  However from the file
1598 		   system to the encoder chip everything is purely a byte
1599 		   stream.  The firmware file's contents are always 32 bit
1600 		   swapped from what the encoder expects.  Thus the need
1601 		   always exists to swap the bytes regardless of the endian
1602 		   type of the host processor and therefore swab32() makes
1603 		   the most sense. */
1604 		for (icnt = 0; icnt < bcnt/4 ; icnt++)
1605 			((u32 *)fw_ptr)[icnt] = swab32(((u32 *)fw_ptr)[icnt]);
1606 
1607 		ret |= usb_bulk_msg(hdw->usb_dev, pipe, fw_ptr,bcnt,
1608 				    &actual_length, 1000);
1609 		ret |= (actual_length != bcnt);
1610 		if (ret) break;
1611 		fw_done += bcnt;
1612 	}
1613 
1614 	trace_firmware("upload of %s : %i / %i ",
1615 		       fw_files[fwidx],fw_done,fw_len);
1616 
1617 	kfree(fw_ptr);
1618 	release_firmware(fw_entry);
1619 
1620 	if (ret) {
1621 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1622 			   "firmware2 upload transfer failure");
1623 		goto done;
1624 	}
1625 
1626 	/* Finish upload */
1627 
1628 	ret |= pvr2_write_register(hdw, 0x9054, 0xffffffff); /*reset hw blocks*/
1629 	ret |= pvr2_write_register(hdw, 0x9058, 0xffffffe8); /*VPU ctrl*/
1630 	ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_MEMSEL | (1 << 8) | (0 << 16));
1631 
1632 	if (ret) {
1633 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1634 			   "firmware2 upload post-proc failure");
1635 	}
1636 
1637  done:
1638 	if (hdw->hdw_desc->signal_routing_scheme ==
1639 	    PVR2_ROUTING_SCHEME_GOTVIEW) {
1640 		/* Ensure that GPIO 11 is set to output for GOTVIEW
1641 		   hardware. */
1642 		pvr2_hdw_gpio_chg_dir(hdw,(1 << 11),~0);
1643 	}
1644 	return ret;
1645 }
1646 
1647 
1648 static const char *pvr2_get_state_name(unsigned int st)
1649 {
1650 	if (st < ARRAY_SIZE(pvr2_state_names)) {
1651 		return pvr2_state_names[st];
1652 	}
1653 	return "???";
1654 }
1655 
1656 static int pvr2_decoder_enable(struct pvr2_hdw *hdw,int enablefl)
1657 {
1658 	/* Even though we really only care about the video decoder chip at
1659 	   this point, we'll broadcast stream on/off to all sub-devices
1660 	   anyway, just in case somebody else wants to hear the
1661 	   command... */
1662 	pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 stream=%s",
1663 		   (enablefl ? "on" : "off"));
1664 	v4l2_device_call_all(&hdw->v4l2_dev, 0, video, s_stream, enablefl);
1665 	v4l2_device_call_all(&hdw->v4l2_dev, 0, audio, s_stream, enablefl);
1666 	if (hdw->decoder_client_id) {
1667 		/* We get here if the encoder has been noticed.  Otherwise
1668 		   we'll issue a warning to the user (which should
1669 		   normally never happen). */
1670 		return 0;
1671 	}
1672 	if (!hdw->flag_decoder_missed) {
1673 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1674 			   "***WARNING*** No decoder present");
1675 		hdw->flag_decoder_missed = !0;
1676 		trace_stbit("flag_decoder_missed",
1677 			    hdw->flag_decoder_missed);
1678 	}
1679 	return -EIO;
1680 }
1681 
1682 
1683 int pvr2_hdw_get_state(struct pvr2_hdw *hdw)
1684 {
1685 	return hdw->master_state;
1686 }
1687 
1688 
1689 static int pvr2_hdw_untrip_unlocked(struct pvr2_hdw *hdw)
1690 {
1691 	if (!hdw->flag_tripped) return 0;
1692 	hdw->flag_tripped = 0;
1693 	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1694 		   "Clearing driver error status");
1695 	return !0;
1696 }
1697 
1698 
1699 int pvr2_hdw_untrip(struct pvr2_hdw *hdw)
1700 {
1701 	int fl;
1702 	LOCK_TAKE(hdw->big_lock); do {
1703 		fl = pvr2_hdw_untrip_unlocked(hdw);
1704 	} while (0); LOCK_GIVE(hdw->big_lock);
1705 	if (fl) pvr2_hdw_state_sched(hdw);
1706 	return 0;
1707 }
1708 
1709 
1710 
1711 
1712 int pvr2_hdw_get_streaming(struct pvr2_hdw *hdw)
1713 {
1714 	return hdw->state_pipeline_req != 0;
1715 }
1716 
1717 
1718 int pvr2_hdw_set_streaming(struct pvr2_hdw *hdw,int enable_flag)
1719 {
1720 	int ret,st;
1721 	LOCK_TAKE(hdw->big_lock);
1722 	pvr2_hdw_untrip_unlocked(hdw);
1723 	if (!enable_flag != !hdw->state_pipeline_req) {
1724 		hdw->state_pipeline_req = enable_flag != 0;
1725 		pvr2_trace(PVR2_TRACE_START_STOP,
1726 			   "/*--TRACE_STREAM--*/ %s",
1727 			   enable_flag ? "enable" : "disable");
1728 	}
1729 	pvr2_hdw_state_sched(hdw);
1730 	LOCK_GIVE(hdw->big_lock);
1731 	if ((ret = pvr2_hdw_wait(hdw,0)) < 0) return ret;
1732 	if (enable_flag) {
1733 		while ((st = hdw->master_state) != PVR2_STATE_RUN) {
1734 			if (st != PVR2_STATE_READY) return -EIO;
1735 			if ((ret = pvr2_hdw_wait(hdw,st)) < 0) return ret;
1736 		}
1737 	}
1738 	return 0;
1739 }
1740 
1741 
1742 int pvr2_hdw_set_stream_type(struct pvr2_hdw *hdw,enum pvr2_config config)
1743 {
1744 	int fl;
1745 	LOCK_TAKE(hdw->big_lock);
1746 	if ((fl = (hdw->desired_stream_type != config)) != 0) {
1747 		hdw->desired_stream_type = config;
1748 		hdw->state_pipeline_config = 0;
1749 		trace_stbit("state_pipeline_config",
1750 			    hdw->state_pipeline_config);
1751 		pvr2_hdw_state_sched(hdw);
1752 	}
1753 	LOCK_GIVE(hdw->big_lock);
1754 	if (fl) return 0;
1755 	return pvr2_hdw_wait(hdw,0);
1756 }
1757 
1758 
1759 static int get_default_tuner_type(struct pvr2_hdw *hdw)
1760 {
1761 	int unit_number = hdw->unit_number;
1762 	int tp = -1;
1763 	if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1764 		tp = tuner[unit_number];
1765 	}
1766 	if (tp < 0) return -EINVAL;
1767 	hdw->tuner_type = tp;
1768 	hdw->tuner_updated = !0;
1769 	return 0;
1770 }
1771 
1772 
1773 static v4l2_std_id get_default_standard(struct pvr2_hdw *hdw)
1774 {
1775 	int unit_number = hdw->unit_number;
1776 	int tp = 0;
1777 	if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1778 		tp = video_std[unit_number];
1779 		if (tp) return tp;
1780 	}
1781 	return 0;
1782 }
1783 
1784 
1785 static unsigned int get_default_error_tolerance(struct pvr2_hdw *hdw)
1786 {
1787 	int unit_number = hdw->unit_number;
1788 	int tp = 0;
1789 	if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1790 		tp = tolerance[unit_number];
1791 	}
1792 	return tp;
1793 }
1794 
1795 
1796 static int pvr2_hdw_check_firmware(struct pvr2_hdw *hdw)
1797 {
1798 	/* Try a harmless request to fetch the eeprom's address over
1799 	   endpoint 1.  See what happens.  Only the full FX2 image can
1800 	   respond to this.  If this probe fails then likely the FX2
1801 	   firmware needs be loaded. */
1802 	int result;
1803 	LOCK_TAKE(hdw->ctl_lock); do {
1804 		hdw->cmd_buffer[0] = FX2CMD_GET_EEPROM_ADDR;
1805 		result = pvr2_send_request_ex(hdw,HZ*1,!0,
1806 					   hdw->cmd_buffer,1,
1807 					   hdw->cmd_buffer,1);
1808 		if (result < 0) break;
1809 	} while(0); LOCK_GIVE(hdw->ctl_lock);
1810 	if (result) {
1811 		pvr2_trace(PVR2_TRACE_INIT,
1812 			   "Probe of device endpoint 1 result status %d",
1813 			   result);
1814 	} else {
1815 		pvr2_trace(PVR2_TRACE_INIT,
1816 			   "Probe of device endpoint 1 succeeded");
1817 	}
1818 	return result == 0;
1819 }
1820 
1821 struct pvr2_std_hack {
1822 	v4l2_std_id pat;  /* Pattern to match */
1823 	v4l2_std_id msk;  /* Which bits we care about */
1824 	v4l2_std_id std;  /* What additional standards or default to set */
1825 };
1826 
1827 /* This data structure labels specific combinations of standards from
1828    tveeprom that we'll try to recognize.  If we recognize one, then assume
1829    a specified default standard to use.  This is here because tveeprom only
1830    tells us about available standards not the intended default standard (if
1831    any) for the device in question.  We guess the default based on what has
1832    been reported as available.  Note that this is only for guessing a
1833    default - which can always be overridden explicitly - and if the user
1834    has otherwise named a default then that default will always be used in
1835    place of this table. */
1836 static const struct pvr2_std_hack std_eeprom_maps[] = {
1837 	{	/* PAL(B/G) */
1838 		.pat = V4L2_STD_B|V4L2_STD_GH,
1839 		.std = V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_PAL_G,
1840 	},
1841 	{	/* NTSC(M) */
1842 		.pat = V4L2_STD_MN,
1843 		.std = V4L2_STD_NTSC_M,
1844 	},
1845 	{	/* PAL(I) */
1846 		.pat = V4L2_STD_PAL_I,
1847 		.std = V4L2_STD_PAL_I,
1848 	},
1849 	{	/* SECAM(L/L') */
1850 		.pat = V4L2_STD_SECAM_L|V4L2_STD_SECAM_LC,
1851 		.std = V4L2_STD_SECAM_L|V4L2_STD_SECAM_LC,
1852 	},
1853 	{	/* PAL(D/D1/K) */
1854 		.pat = V4L2_STD_DK,
1855 		.std = V4L2_STD_PAL_D|V4L2_STD_PAL_D1|V4L2_STD_PAL_K,
1856 	},
1857 };
1858 
1859 static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
1860 {
1861 	char buf[40];
1862 	unsigned int bcnt;
1863 	v4l2_std_id std1,std2,std3;
1864 
1865 	std1 = get_default_standard(hdw);
1866 	std3 = std1 ? 0 : hdw->hdw_desc->default_std_mask;
1867 
1868 	bcnt = pvr2_std_id_to_str(buf,sizeof(buf),hdw->std_mask_eeprom);
1869 	pvr2_trace(PVR2_TRACE_STD,
1870 		   "Supported video standard(s) reported available in hardware: %.*s",
1871 		   bcnt,buf);
1872 
1873 	hdw->std_mask_avail = hdw->std_mask_eeprom;
1874 
1875 	std2 = (std1|std3) & ~hdw->std_mask_avail;
1876 	if (std2) {
1877 		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std2);
1878 		pvr2_trace(PVR2_TRACE_STD,
1879 			   "Expanding supported video standards to include: %.*s",
1880 			   bcnt,buf);
1881 		hdw->std_mask_avail |= std2;
1882 	}
1883 
1884 	hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
1885 
1886 	if (std1) {
1887 		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std1);
1888 		pvr2_trace(PVR2_TRACE_STD,
1889 			   "Initial video standard forced to %.*s",
1890 			   bcnt,buf);
1891 		hdw->std_mask_cur = std1;
1892 		hdw->std_dirty = !0;
1893 		return;
1894 	}
1895 	if (std3) {
1896 		bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std3);
1897 		pvr2_trace(PVR2_TRACE_STD,
1898 			   "Initial video standard (determined by device type): %.*s",
1899 			   bcnt, buf);
1900 		hdw->std_mask_cur = std3;
1901 		hdw->std_dirty = !0;
1902 		return;
1903 	}
1904 
1905 	{
1906 		unsigned int idx;
1907 		for (idx = 0; idx < ARRAY_SIZE(std_eeprom_maps); idx++) {
1908 			if (std_eeprom_maps[idx].msk ?
1909 			    ((std_eeprom_maps[idx].pat ^
1910 			     hdw->std_mask_eeprom) &
1911 			     std_eeprom_maps[idx].msk) :
1912 			    (std_eeprom_maps[idx].pat !=
1913 			     hdw->std_mask_eeprom)) continue;
1914 			bcnt = pvr2_std_id_to_str(buf,sizeof(buf),
1915 						  std_eeprom_maps[idx].std);
1916 			pvr2_trace(PVR2_TRACE_STD,
1917 				   "Initial video standard guessed as %.*s",
1918 				   bcnt,buf);
1919 			hdw->std_mask_cur = std_eeprom_maps[idx].std;
1920 			hdw->std_dirty = !0;
1921 			return;
1922 		}
1923 	}
1924 
1925 }
1926 
1927 
1928 static unsigned int pvr2_copy_i2c_addr_list(
1929 	unsigned short *dst, const unsigned char *src,
1930 	unsigned int dst_max)
1931 {
1932 	unsigned int cnt = 0;
1933 	if (!src) return 0;
1934 	while (src[cnt] && (cnt + 1) < dst_max) {
1935 		dst[cnt] = src[cnt];
1936 		cnt++;
1937 	}
1938 	dst[cnt] = I2C_CLIENT_END;
1939 	return cnt;
1940 }
1941 
1942 
1943 static void pvr2_hdw_cx25840_vbi_hack(struct pvr2_hdw *hdw)
1944 {
1945 	/*
1946 	  Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit of nuttiness
1947 	  for cx25840 causes that module to correctly set up its video
1948 	  scaling.  This is really a problem in the cx25840 module itself,
1949 	  but we work around it here.  The problem has not been seen in
1950 	  ivtv because there VBI is supported and set up.  We don't do VBI
1951 	  here (at least not yet) and thus we never attempted to even set
1952 	  it up.
1953 	*/
1954 	struct v4l2_format fmt;
1955 	if (hdw->decoder_client_id != PVR2_CLIENT_ID_CX25840) {
1956 		/* We're not using a cx25840 so don't enable the hack */
1957 		return;
1958 	}
1959 
1960 	pvr2_trace(PVR2_TRACE_INIT,
1961 		   "Module ID %u: Executing cx25840 VBI hack",
1962 		   hdw->decoder_client_id);
1963 	memset(&fmt, 0, sizeof(fmt));
1964 	fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1965 	fmt.fmt.sliced.service_lines[0][21] = V4L2_SLICED_CAPTION_525;
1966 	fmt.fmt.sliced.service_lines[1][21] = V4L2_SLICED_CAPTION_525;
1967 	v4l2_device_call_all(&hdw->v4l2_dev, hdw->decoder_client_id,
1968 			     vbi, s_sliced_fmt, &fmt.fmt.sliced);
1969 }
1970 
1971 
1972 static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
1973 				const struct pvr2_device_client_desc *cd)
1974 {
1975 	const char *fname;
1976 	unsigned char mid;
1977 	struct v4l2_subdev *sd;
1978 	unsigned int i2ccnt;
1979 	const unsigned char *p;
1980 	/* Arbitrary count - max # i2c addresses we will probe */
1981 	unsigned short i2caddr[25];
1982 
1983 	mid = cd->module_id;
1984 	fname = (mid < ARRAY_SIZE(module_names)) ? module_names[mid] : NULL;
1985 	if (!fname) {
1986 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1987 			   "Module ID %u for device %s has no name?  The driver might have a configuration problem.",
1988 			   mid,
1989 			   hdw->hdw_desc->description);
1990 		return -EINVAL;
1991 	}
1992 	pvr2_trace(PVR2_TRACE_INIT,
1993 		   "Module ID %u (%s) for device %s being loaded...",
1994 		   mid, fname,
1995 		   hdw->hdw_desc->description);
1996 
1997 	i2ccnt = pvr2_copy_i2c_addr_list(i2caddr, cd->i2c_address_list,
1998 					 ARRAY_SIZE(i2caddr));
1999 	if (!i2ccnt && ((p = (mid < ARRAY_SIZE(module_i2c_addresses)) ?
2000 			 module_i2c_addresses[mid] : NULL) != NULL)) {
2001 		/* Second chance: Try default i2c address list */
2002 		i2ccnt = pvr2_copy_i2c_addr_list(i2caddr, p,
2003 						 ARRAY_SIZE(i2caddr));
2004 		if (i2ccnt) {
2005 			pvr2_trace(PVR2_TRACE_INIT,
2006 				   "Module ID %u: Using default i2c address list",
2007 				   mid);
2008 		}
2009 	}
2010 
2011 	if (!i2ccnt) {
2012 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2013 			   "Module ID %u (%s) for device %s: No i2c addresses.	The driver might have a configuration problem.",
2014 			   mid, fname, hdw->hdw_desc->description);
2015 		return -EINVAL;
2016 	}
2017 
2018 	if (i2ccnt == 1) {
2019 		pvr2_trace(PVR2_TRACE_INIT,
2020 			   "Module ID %u: Setting up with specified i2c address 0x%x",
2021 			   mid, i2caddr[0]);
2022 		sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
2023 					 fname, i2caddr[0], NULL);
2024 	} else {
2025 		pvr2_trace(PVR2_TRACE_INIT,
2026 			   "Module ID %u: Setting up with address probe list",
2027 			   mid);
2028 		sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
2029 					 fname, 0, i2caddr);
2030 	}
2031 
2032 	if (!sd) {
2033 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2034 			   "Module ID %u (%s) for device %s failed to load.  Possible missing sub-device kernel module or initialization failure within module.",
2035 			   mid, fname, hdw->hdw_desc->description);
2036 		return -EIO;
2037 	}
2038 
2039 	/* Tag this sub-device instance with the module ID we know about.
2040 	   In other places we'll use that tag to determine if the instance
2041 	   requires special handling. */
2042 	sd->grp_id = mid;
2043 
2044 	pvr2_trace(PVR2_TRACE_INFO, "Attached sub-driver %s", fname);
2045 
2046 
2047 	/* client-specific setup... */
2048 	switch (mid) {
2049 	case PVR2_CLIENT_ID_CX25840:
2050 	case PVR2_CLIENT_ID_SAA7115:
2051 		hdw->decoder_client_id = mid;
2052 		break;
2053 	default: break;
2054 	}
2055 
2056 	return 0;
2057 }
2058 
2059 
2060 static void pvr2_hdw_load_modules(struct pvr2_hdw *hdw)
2061 {
2062 	unsigned int idx;
2063 	const struct pvr2_string_table *cm;
2064 	const struct pvr2_device_client_table *ct;
2065 	int okFl = !0;
2066 
2067 	cm = &hdw->hdw_desc->client_modules;
2068 	for (idx = 0; idx < cm->cnt; idx++) {
2069 		request_module(cm->lst[idx]);
2070 	}
2071 
2072 	ct = &hdw->hdw_desc->client_table;
2073 	for (idx = 0; idx < ct->cnt; idx++) {
2074 		if (pvr2_hdw_load_subdev(hdw, &ct->lst[idx]) < 0) okFl = 0;
2075 	}
2076 	if (!okFl) {
2077 		hdw->flag_modulefail = !0;
2078 		pvr2_hdw_render_useless(hdw);
2079 	}
2080 }
2081 
2082 
2083 static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
2084 {
2085 	int ret;
2086 	unsigned int idx;
2087 	struct pvr2_ctrl *cptr;
2088 	int reloadFl = 0;
2089 	if (hdw->hdw_desc->fx2_firmware.cnt) {
2090 		if (!reloadFl) {
2091 			reloadFl =
2092 				(hdw->usb_intf->cur_altsetting->desc.bNumEndpoints
2093 				 == 0);
2094 			if (reloadFl) {
2095 				pvr2_trace(PVR2_TRACE_INIT,
2096 					   "USB endpoint config looks strange; possibly firmware needs to be loaded");
2097 			}
2098 		}
2099 		if (!reloadFl) {
2100 			reloadFl = !pvr2_hdw_check_firmware(hdw);
2101 			if (reloadFl) {
2102 				pvr2_trace(PVR2_TRACE_INIT,
2103 					   "Check for FX2 firmware failed; possibly firmware needs to be loaded");
2104 			}
2105 		}
2106 		if (reloadFl) {
2107 			if (pvr2_upload_firmware1(hdw) != 0) {
2108 				pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2109 					   "Failure uploading firmware1");
2110 			}
2111 			return;
2112 		}
2113 	}
2114 	hdw->fw1_state = FW1_STATE_OK;
2115 
2116 	if (!pvr2_hdw_dev_ok(hdw)) return;
2117 
2118 	hdw->force_dirty = !0;
2119 
2120 	if (!hdw->hdw_desc->flag_no_powerup) {
2121 		pvr2_hdw_cmd_powerup(hdw);
2122 		if (!pvr2_hdw_dev_ok(hdw)) return;
2123 	}
2124 
2125 	/* Take the IR chip out of reset, if appropriate */
2126 	if (hdw->ir_scheme_active == PVR2_IR_SCHEME_ZILOG) {
2127 		pvr2_issue_simple_cmd(hdw,
2128 				      FX2CMD_HCW_ZILOG_RESET |
2129 				      (1 << 8) |
2130 				      ((0) << 16));
2131 	}
2132 
2133 	/* This step MUST happen after the earlier powerup step */
2134 	pvr2_i2c_core_init(hdw);
2135 	if (!pvr2_hdw_dev_ok(hdw)) return;
2136 
2137 	/* Reset demod only on Hauppauge 160xxx platform */
2138 	if (le16_to_cpu(hdw->usb_dev->descriptor.idVendor) == 0x2040 &&
2139 	    (le16_to_cpu(hdw->usb_dev->descriptor.idProduct) == 0x7502 ||
2140 	     le16_to_cpu(hdw->usb_dev->descriptor.idProduct) == 0x7510)) {
2141 		pr_info("%s(): resetting 160xxx demod\n", __func__);
2142 		/* TODO: not sure this is proper place to reset once only */
2143 		pvr2_issue_simple_cmd(hdw,
2144 				      FX2CMD_HCW_DEMOD_RESET_PIN |
2145 				      (1 << 8) |
2146 				      ((0) << 16));
2147 		usleep_range(10000, 10500);
2148 		pvr2_issue_simple_cmd(hdw,
2149 				      FX2CMD_HCW_DEMOD_RESET_PIN |
2150 				      (1 << 8) |
2151 				      ((1) << 16));
2152 		usleep_range(10000, 10500);
2153 	}
2154 
2155 	pvr2_hdw_load_modules(hdw);
2156 	if (!pvr2_hdw_dev_ok(hdw)) return;
2157 
2158 	v4l2_device_call_all(&hdw->v4l2_dev, 0, core, load_fw);
2159 
2160 	for (idx = 0; idx < CTRLDEF_COUNT; idx++) {
2161 		cptr = hdw->controls + idx;
2162 		if (cptr->info->skip_init) continue;
2163 		if (!cptr->info->set_value) continue;
2164 		cptr->info->set_value(cptr,~0,cptr->info->default_value);
2165 	}
2166 
2167 	pvr2_hdw_cx25840_vbi_hack(hdw);
2168 
2169 	/* Set up special default values for the television and radio
2170 	   frequencies here.  It's not really important what these defaults
2171 	   are, but I set them to something usable in the Chicago area just
2172 	   to make driver testing a little easier. */
2173 
2174 	hdw->freqValTelevision = default_tv_freq;
2175 	hdw->freqValRadio = default_radio_freq;
2176 
2177 	// Do not use pvr2_reset_ctl_endpoints() here.  It is not
2178 	// thread-safe against the normal pvr2_send_request() mechanism.
2179 	// (We should make it thread safe).
2180 
2181 	if (hdw->hdw_desc->flag_has_hauppauge_rom) {
2182 		ret = pvr2_hdw_get_eeprom_addr(hdw);
2183 		if (!pvr2_hdw_dev_ok(hdw)) return;
2184 		if (ret < 0) {
2185 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2186 				   "Unable to determine location of eeprom, skipping");
2187 		} else {
2188 			hdw->eeprom_addr = ret;
2189 			pvr2_eeprom_analyze(hdw);
2190 			if (!pvr2_hdw_dev_ok(hdw)) return;
2191 		}
2192 	} else {
2193 		hdw->tuner_type = hdw->hdw_desc->default_tuner_type;
2194 		hdw->tuner_updated = !0;
2195 		hdw->std_mask_eeprom = V4L2_STD_ALL;
2196 	}
2197 
2198 	if (hdw->serial_number) {
2199 		idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2200 				"sn-%lu", hdw->serial_number);
2201 	} else if (hdw->unit_number >= 0) {
2202 		idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2203 				"unit-%c",
2204 				hdw->unit_number + 'a');
2205 	} else {
2206 		idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2207 				"unit-??");
2208 	}
2209 	hdw->identifier[idx] = 0;
2210 
2211 	pvr2_hdw_setup_std(hdw);
2212 
2213 	if (!get_default_tuner_type(hdw)) {
2214 		pvr2_trace(PVR2_TRACE_INIT,
2215 			   "pvr2_hdw_setup: Tuner type overridden to %d",
2216 			   hdw->tuner_type);
2217 	}
2218 
2219 
2220 	if (!pvr2_hdw_dev_ok(hdw)) return;
2221 
2222 	if (hdw->hdw_desc->signal_routing_scheme ==
2223 	    PVR2_ROUTING_SCHEME_GOTVIEW) {
2224 		/* Ensure that GPIO 11 is set to output for GOTVIEW
2225 		   hardware. */
2226 		pvr2_hdw_gpio_chg_dir(hdw,(1 << 11),~0);
2227 	}
2228 
2229 	pvr2_hdw_commit_setup(hdw);
2230 
2231 	hdw->vid_stream = pvr2_stream_create();
2232 	if (!pvr2_hdw_dev_ok(hdw)) return;
2233 	pvr2_trace(PVR2_TRACE_INIT,
2234 		   "pvr2_hdw_setup: video stream is %p",hdw->vid_stream);
2235 	if (hdw->vid_stream) {
2236 		idx = get_default_error_tolerance(hdw);
2237 		if (idx) {
2238 			pvr2_trace(PVR2_TRACE_INIT,
2239 				   "pvr2_hdw_setup: video stream %p setting tolerance %u",
2240 				   hdw->vid_stream,idx);
2241 		}
2242 		pvr2_stream_setup(hdw->vid_stream,hdw->usb_dev,
2243 				  PVR2_VID_ENDPOINT,idx);
2244 	}
2245 
2246 	if (!pvr2_hdw_dev_ok(hdw)) return;
2247 
2248 	hdw->flag_init_ok = !0;
2249 
2250 	pvr2_hdw_state_sched(hdw);
2251 }
2252 
2253 
2254 /* Set up the structure and attempt to put the device into a usable state.
2255    This can be a time-consuming operation, which is why it is not done
2256    internally as part of the create() step. */
2257 static void pvr2_hdw_setup(struct pvr2_hdw *hdw)
2258 {
2259 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_setup(hdw=%p) begin",hdw);
2260 	do {
2261 		pvr2_hdw_setup_low(hdw);
2262 		pvr2_trace(PVR2_TRACE_INIT,
2263 			   "pvr2_hdw_setup(hdw=%p) done, ok=%d init_ok=%d",
2264 			   hdw,pvr2_hdw_dev_ok(hdw),hdw->flag_init_ok);
2265 		if (pvr2_hdw_dev_ok(hdw)) {
2266 			if (hdw->flag_init_ok) {
2267 				pvr2_trace(
2268 					PVR2_TRACE_INFO,
2269 					"Device initialization completed successfully.");
2270 				break;
2271 			}
2272 			if (hdw->fw1_state == FW1_STATE_RELOAD) {
2273 				pvr2_trace(
2274 					PVR2_TRACE_INFO,
2275 					"Device microcontroller firmware (re)loaded; it should now reset and reconnect.");
2276 				break;
2277 			}
2278 			pvr2_trace(
2279 				PVR2_TRACE_ERROR_LEGS,
2280 				"Device initialization was not successful.");
2281 			if (hdw->fw1_state == FW1_STATE_MISSING) {
2282 				pvr2_trace(
2283 					PVR2_TRACE_ERROR_LEGS,
2284 					"Giving up since device microcontroller firmware appears to be missing.");
2285 				break;
2286 			}
2287 		}
2288 		if (hdw->flag_modulefail) {
2289 			pvr2_trace(
2290 				PVR2_TRACE_ERROR_LEGS,
2291 				"***WARNING*** pvrusb2 driver initialization failed due to the failure of one or more sub-device kernel modules.");
2292 			pvr2_trace(
2293 				PVR2_TRACE_ERROR_LEGS,
2294 				"You need to resolve the failing condition before this driver can function.  There should be some earlier messages giving more information about the problem.");
2295 			break;
2296 		}
2297 		if (procreload) {
2298 			pvr2_trace(
2299 				PVR2_TRACE_ERROR_LEGS,
2300 				"Attempting pvrusb2 recovery by reloading primary firmware.");
2301 			pvr2_trace(
2302 				PVR2_TRACE_ERROR_LEGS,
2303 				"If this works, device should disconnect and reconnect in a sane state.");
2304 			hdw->fw1_state = FW1_STATE_UNKNOWN;
2305 			pvr2_upload_firmware1(hdw);
2306 		} else {
2307 			pvr2_trace(
2308 				PVR2_TRACE_ERROR_LEGS,
2309 				"***WARNING*** pvrusb2 device hardware appears to be jammed and I can't clear it.");
2310 			pvr2_trace(
2311 				PVR2_TRACE_ERROR_LEGS,
2312 				"You might need to power cycle the pvrusb2 device in order to recover.");
2313 		}
2314 	} while (0);
2315 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_setup(hdw=%p) end",hdw);
2316 }
2317 
2318 
2319 /* Perform second stage initialization.  Set callback pointer first so that
2320    we can avoid a possible initialization race (if the kernel thread runs
2321    before the callback has been set). */
2322 int pvr2_hdw_initialize(struct pvr2_hdw *hdw,
2323 			void (*callback_func)(void *),
2324 			void *callback_data)
2325 {
2326 	LOCK_TAKE(hdw->big_lock); do {
2327 		if (hdw->flag_disconnected) {
2328 			/* Handle a race here: If we're already
2329 			   disconnected by this point, then give up.  If we
2330 			   get past this then we'll remain connected for
2331 			   the duration of initialization since the entire
2332 			   initialization sequence is now protected by the
2333 			   big_lock. */
2334 			break;
2335 		}
2336 		hdw->state_data = callback_data;
2337 		hdw->state_func = callback_func;
2338 		pvr2_hdw_setup(hdw);
2339 	} while (0); LOCK_GIVE(hdw->big_lock);
2340 	return hdw->flag_init_ok;
2341 }
2342 
2343 
2344 /* Create, set up, and return a structure for interacting with the
2345    underlying hardware.  */
2346 struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
2347 				 const struct usb_device_id *devid)
2348 {
2349 	unsigned int idx,cnt1,cnt2,m;
2350 	struct pvr2_hdw *hdw = NULL;
2351 	int valid_std_mask;
2352 	struct pvr2_ctrl *cptr;
2353 	struct usb_device *usb_dev;
2354 	const struct pvr2_device_desc *hdw_desc;
2355 	__u8 ifnum;
2356 	struct v4l2_queryctrl qctrl;
2357 	struct pvr2_ctl_info *ciptr;
2358 
2359 	usb_dev = interface_to_usbdev(intf);
2360 
2361 	hdw_desc = (const struct pvr2_device_desc *)(devid->driver_info);
2362 
2363 	if (hdw_desc == NULL) {
2364 		pvr2_trace(PVR2_TRACE_INIT, "pvr2_hdw_create: No device description pointer, unable to continue.");
2365 		pvr2_trace(PVR2_TRACE_INIT,
2366 			   "If you have a new device type, please contact Mike Isely <isely@pobox.com> to get it included in the driver");
2367 		goto fail;
2368 	}
2369 
2370 	hdw = kzalloc(sizeof(*hdw),GFP_KERNEL);
2371 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_create: hdw=%p, type \"%s\"",
2372 		   hdw,hdw_desc->description);
2373 	pvr2_trace(PVR2_TRACE_INFO, "Hardware description: %s",
2374 		hdw_desc->description);
2375 	if (hdw_desc->flag_is_experimental) {
2376 		pvr2_trace(PVR2_TRACE_INFO, "**********");
2377 		pvr2_trace(PVR2_TRACE_INFO,
2378 			   "***WARNING*** Support for this device (%s) is experimental.",
2379 							      hdw_desc->description);
2380 		pvr2_trace(PVR2_TRACE_INFO,
2381 			   "Important functionality might not be entirely working.");
2382 		pvr2_trace(PVR2_TRACE_INFO,
2383 			   "Please consider contacting the driver author to help with further stabilization of the driver.");
2384 		pvr2_trace(PVR2_TRACE_INFO, "**********");
2385 	}
2386 	if (!hdw) goto fail;
2387 
2388 	timer_setup(&hdw->quiescent_timer, pvr2_hdw_quiescent_timeout, 0);
2389 
2390 	timer_setup(&hdw->decoder_stabilization_timer,
2391 		    pvr2_hdw_decoder_stabilization_timeout, 0);
2392 
2393 	timer_setup(&hdw->encoder_wait_timer, pvr2_hdw_encoder_wait_timeout,
2394 		    0);
2395 
2396 	timer_setup(&hdw->encoder_run_timer, pvr2_hdw_encoder_run_timeout, 0);
2397 
2398 	hdw->master_state = PVR2_STATE_DEAD;
2399 
2400 	init_waitqueue_head(&hdw->state_wait_data);
2401 
2402 	hdw->tuner_signal_stale = !0;
2403 	cx2341x_fill_defaults(&hdw->enc_ctl_state);
2404 
2405 	/* Calculate which inputs are OK */
2406 	m = 0;
2407 	if (hdw_desc->flag_has_analogtuner) m |= 1 << PVR2_CVAL_INPUT_TV;
2408 	if (hdw_desc->digital_control_scheme != PVR2_DIGITAL_SCHEME_NONE) {
2409 		m |= 1 << PVR2_CVAL_INPUT_DTV;
2410 	}
2411 	if (hdw_desc->flag_has_svideo) m |= 1 << PVR2_CVAL_INPUT_SVIDEO;
2412 	if (hdw_desc->flag_has_composite) m |= 1 << PVR2_CVAL_INPUT_COMPOSITE;
2413 	if (hdw_desc->flag_has_fmradio) m |= 1 << PVR2_CVAL_INPUT_RADIO;
2414 	hdw->input_avail_mask = m;
2415 	hdw->input_allowed_mask = hdw->input_avail_mask;
2416 
2417 	/* If not a hybrid device, pathway_state never changes.  So
2418 	   initialize it here to what it should forever be. */
2419 	if (!(hdw->input_avail_mask & (1 << PVR2_CVAL_INPUT_DTV))) {
2420 		hdw->pathway_state = PVR2_PATHWAY_ANALOG;
2421 	} else if (!(hdw->input_avail_mask & (1 << PVR2_CVAL_INPUT_TV))) {
2422 		hdw->pathway_state = PVR2_PATHWAY_DIGITAL;
2423 	}
2424 
2425 	hdw->control_cnt = CTRLDEF_COUNT;
2426 	hdw->control_cnt += MPEGDEF_COUNT;
2427 	hdw->controls = kcalloc(hdw->control_cnt, sizeof(struct pvr2_ctrl),
2428 				GFP_KERNEL);
2429 	if (!hdw->controls) goto fail;
2430 	hdw->hdw_desc = hdw_desc;
2431 	hdw->ir_scheme_active = hdw->hdw_desc->ir_scheme;
2432 	for (idx = 0; idx < hdw->control_cnt; idx++) {
2433 		cptr = hdw->controls + idx;
2434 		cptr->hdw = hdw;
2435 	}
2436 	for (idx = 0; idx < 32; idx++) {
2437 		hdw->std_mask_ptrs[idx] = hdw->std_mask_names[idx];
2438 	}
2439 	for (idx = 0; idx < CTRLDEF_COUNT; idx++) {
2440 		cptr = hdw->controls + idx;
2441 		cptr->info = control_defs+idx;
2442 	}
2443 
2444 	/* Ensure that default input choice is a valid one. */
2445 	m = hdw->input_avail_mask;
2446 	if (m) for (idx = 0; idx < (sizeof(m) << 3); idx++) {
2447 		if (!((1UL << idx) & m)) continue;
2448 		hdw->input_val = idx;
2449 		break;
2450 	}
2451 
2452 	/* Define and configure additional controls from cx2341x module. */
2453 	hdw->mpeg_ctrl_info = kcalloc(MPEGDEF_COUNT,
2454 				      sizeof(*(hdw->mpeg_ctrl_info)),
2455 				      GFP_KERNEL);
2456 	if (!hdw->mpeg_ctrl_info) goto fail;
2457 	for (idx = 0; idx < MPEGDEF_COUNT; idx++) {
2458 		cptr = hdw->controls + idx + CTRLDEF_COUNT;
2459 		ciptr = &(hdw->mpeg_ctrl_info[idx].info);
2460 		ciptr->desc = hdw->mpeg_ctrl_info[idx].desc;
2461 		ciptr->name = mpeg_ids[idx].strid;
2462 		ciptr->v4l_id = mpeg_ids[idx].id;
2463 		ciptr->skip_init = !0;
2464 		ciptr->get_value = ctrl_cx2341x_get;
2465 		ciptr->get_v4lflags = ctrl_cx2341x_getv4lflags;
2466 		ciptr->is_dirty = ctrl_cx2341x_is_dirty;
2467 		if (!idx) ciptr->clear_dirty = ctrl_cx2341x_clear_dirty;
2468 		qctrl.id = ciptr->v4l_id;
2469 		cx2341x_ctrl_query(&hdw->enc_ctl_state,&qctrl);
2470 		if (!(qctrl.flags & V4L2_CTRL_FLAG_READ_ONLY)) {
2471 			ciptr->set_value = ctrl_cx2341x_set;
2472 		}
2473 		strscpy(hdw->mpeg_ctrl_info[idx].desc, qctrl.name,
2474 			sizeof(hdw->mpeg_ctrl_info[idx].desc));
2475 		ciptr->default_value = qctrl.default_value;
2476 		switch (qctrl.type) {
2477 		default:
2478 		case V4L2_CTRL_TYPE_INTEGER:
2479 			ciptr->type = pvr2_ctl_int;
2480 			ciptr->def.type_int.min_value = qctrl.minimum;
2481 			ciptr->def.type_int.max_value = qctrl.maximum;
2482 			break;
2483 		case V4L2_CTRL_TYPE_BOOLEAN:
2484 			ciptr->type = pvr2_ctl_bool;
2485 			break;
2486 		case V4L2_CTRL_TYPE_MENU:
2487 			ciptr->type = pvr2_ctl_enum;
2488 			ciptr->def.type_enum.value_names =
2489 				cx2341x_ctrl_get_menu(&hdw->enc_ctl_state,
2490 								ciptr->v4l_id);
2491 			for (cnt1 = 0;
2492 			     ciptr->def.type_enum.value_names[cnt1] != NULL;
2493 			     cnt1++) { }
2494 			ciptr->def.type_enum.count = cnt1;
2495 			break;
2496 		}
2497 		cptr->info = ciptr;
2498 	}
2499 
2500 	// Initialize control data regarding video standard masks
2501 	valid_std_mask = pvr2_std_get_usable();
2502 	for (idx = 0; idx < 32; idx++) {
2503 		if (!(valid_std_mask & (1UL << idx))) continue;
2504 		cnt1 = pvr2_std_id_to_str(
2505 			hdw->std_mask_names[idx],
2506 			sizeof(hdw->std_mask_names[idx])-1,
2507 			1UL << idx);
2508 		hdw->std_mask_names[idx][cnt1] = 0;
2509 	}
2510 	cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDAVAIL);
2511 	if (cptr) {
2512 		memcpy(&hdw->std_info_avail,cptr->info,
2513 		       sizeof(hdw->std_info_avail));
2514 		cptr->info = &hdw->std_info_avail;
2515 		hdw->std_info_avail.def.type_bitmask.bit_names =
2516 			hdw->std_mask_ptrs;
2517 		hdw->std_info_avail.def.type_bitmask.valid_bits =
2518 			valid_std_mask;
2519 	}
2520 	cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR);
2521 	if (cptr) {
2522 		memcpy(&hdw->std_info_cur,cptr->info,
2523 		       sizeof(hdw->std_info_cur));
2524 		cptr->info = &hdw->std_info_cur;
2525 		hdw->std_info_cur.def.type_bitmask.bit_names =
2526 			hdw->std_mask_ptrs;
2527 		hdw->std_info_cur.def.type_bitmask.valid_bits =
2528 			valid_std_mask;
2529 	}
2530 	cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDDETECT);
2531 	if (cptr) {
2532 		memcpy(&hdw->std_info_detect,cptr->info,
2533 		       sizeof(hdw->std_info_detect));
2534 		cptr->info = &hdw->std_info_detect;
2535 		hdw->std_info_detect.def.type_bitmask.bit_names =
2536 			hdw->std_mask_ptrs;
2537 		hdw->std_info_detect.def.type_bitmask.valid_bits =
2538 			valid_std_mask;
2539 	}
2540 
2541 	hdw->cropcap_stale = !0;
2542 	hdw->eeprom_addr = -1;
2543 	hdw->unit_number = -1;
2544 	hdw->v4l_minor_number_video = -1;
2545 	hdw->v4l_minor_number_vbi = -1;
2546 	hdw->v4l_minor_number_radio = -1;
2547 	hdw->ctl_write_buffer = kmalloc(PVR2_CTL_BUFFSIZE,GFP_KERNEL);
2548 	if (!hdw->ctl_write_buffer) goto fail;
2549 	hdw->ctl_read_buffer = kmalloc(PVR2_CTL_BUFFSIZE,GFP_KERNEL);
2550 	if (!hdw->ctl_read_buffer) goto fail;
2551 	hdw->ctl_write_urb = usb_alloc_urb(0,GFP_KERNEL);
2552 	if (!hdw->ctl_write_urb) goto fail;
2553 	hdw->ctl_read_urb = usb_alloc_urb(0,GFP_KERNEL);
2554 	if (!hdw->ctl_read_urb) goto fail;
2555 
2556 	if (v4l2_device_register(&intf->dev, &hdw->v4l2_dev) != 0) {
2557 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2558 			   "Error registering with v4l core, giving up");
2559 		goto fail;
2560 	}
2561 	mutex_lock(&pvr2_unit_mtx);
2562 	do {
2563 		for (idx = 0; idx < PVR_NUM; idx++) {
2564 			if (unit_pointers[idx]) continue;
2565 			hdw->unit_number = idx;
2566 			unit_pointers[idx] = hdw;
2567 			break;
2568 		}
2569 	} while (0);
2570 	mutex_unlock(&pvr2_unit_mtx);
2571 
2572 	INIT_WORK(&hdw->workpoll, pvr2_hdw_worker_poll);
2573 
2574 	if (hdw->unit_number == -1)
2575 		goto fail;
2576 
2577 	cnt1 = 0;
2578 	cnt2 = scnprintf(hdw->name+cnt1,sizeof(hdw->name)-cnt1,"pvrusb2");
2579 	cnt1 += cnt2;
2580 	if (hdw->unit_number >= 0) {
2581 		cnt2 = scnprintf(hdw->name+cnt1,sizeof(hdw->name)-cnt1,"_%c",
2582 				 ('a' + hdw->unit_number));
2583 		cnt1 += cnt2;
2584 	}
2585 	if (cnt1 >= sizeof(hdw->name)) cnt1 = sizeof(hdw->name)-1;
2586 	hdw->name[cnt1] = 0;
2587 
2588 	pvr2_trace(PVR2_TRACE_INIT,"Driver unit number is %d, name is %s",
2589 		   hdw->unit_number,hdw->name);
2590 
2591 	hdw->tuner_type = -1;
2592 	hdw->flag_ok = !0;
2593 
2594 	hdw->usb_intf = intf;
2595 	hdw->usb_dev = usb_dev;
2596 
2597 	usb_make_path(hdw->usb_dev, hdw->bus_info, sizeof(hdw->bus_info));
2598 
2599 	ifnum = hdw->usb_intf->cur_altsetting->desc.bInterfaceNumber;
2600 	usb_set_interface(hdw->usb_dev,ifnum,0);
2601 
2602 	mutex_init(&hdw->ctl_lock_mutex);
2603 	mutex_init(&hdw->big_lock_mutex);
2604 
2605 	return hdw;
2606  fail:
2607 	if (hdw) {
2608 		timer_shutdown_sync(&hdw->quiescent_timer);
2609 		timer_shutdown_sync(&hdw->decoder_stabilization_timer);
2610 		timer_shutdown_sync(&hdw->encoder_run_timer);
2611 		timer_shutdown_sync(&hdw->encoder_wait_timer);
2612 		flush_work(&hdw->workpoll);
2613 		v4l2_device_unregister(&hdw->v4l2_dev);
2614 		usb_free_urb(hdw->ctl_read_urb);
2615 		usb_free_urb(hdw->ctl_write_urb);
2616 		kfree(hdw->ctl_read_buffer);
2617 		kfree(hdw->ctl_write_buffer);
2618 		kfree(hdw->controls);
2619 		kfree(hdw->mpeg_ctrl_info);
2620 		kfree(hdw);
2621 	}
2622 	return NULL;
2623 }
2624 
2625 
2626 /* Remove _all_ associations between this driver and the underlying USB
2627    layer. */
2628 static void pvr2_hdw_remove_usb_stuff(struct pvr2_hdw *hdw)
2629 {
2630 	if (hdw->flag_disconnected) return;
2631 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_remove_usb_stuff: hdw=%p",hdw);
2632 	if (hdw->ctl_read_urb) {
2633 		usb_kill_urb(hdw->ctl_read_urb);
2634 		usb_free_urb(hdw->ctl_read_urb);
2635 		hdw->ctl_read_urb = NULL;
2636 	}
2637 	if (hdw->ctl_write_urb) {
2638 		usb_kill_urb(hdw->ctl_write_urb);
2639 		usb_free_urb(hdw->ctl_write_urb);
2640 		hdw->ctl_write_urb = NULL;
2641 	}
2642 	if (hdw->ctl_read_buffer) {
2643 		kfree(hdw->ctl_read_buffer);
2644 		hdw->ctl_read_buffer = NULL;
2645 	}
2646 	if (hdw->ctl_write_buffer) {
2647 		kfree(hdw->ctl_write_buffer);
2648 		hdw->ctl_write_buffer = NULL;
2649 	}
2650 	hdw->flag_disconnected = !0;
2651 	/* If we don't do this, then there will be a dangling struct device
2652 	   reference to our disappearing device persisting inside the V4L
2653 	   core... */
2654 	v4l2_device_disconnect(&hdw->v4l2_dev);
2655 	hdw->usb_dev = NULL;
2656 	hdw->usb_intf = NULL;
2657 	pvr2_hdw_render_useless(hdw);
2658 }
2659 
2660 void pvr2_hdw_set_v4l2_dev(struct pvr2_hdw *hdw, struct video_device *vdev)
2661 {
2662 	vdev->v4l2_dev = &hdw->v4l2_dev;
2663 }
2664 
2665 /* Destroy hardware interaction structure */
2666 void pvr2_hdw_destroy(struct pvr2_hdw *hdw)
2667 {
2668 	if (!hdw) return;
2669 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_destroy: hdw=%p",hdw);
2670 	flush_work(&hdw->workpoll);
2671 	timer_shutdown_sync(&hdw->quiescent_timer);
2672 	timer_shutdown_sync(&hdw->decoder_stabilization_timer);
2673 	timer_shutdown_sync(&hdw->encoder_run_timer);
2674 	timer_shutdown_sync(&hdw->encoder_wait_timer);
2675 	if (hdw->fw_buffer) {
2676 		kfree(hdw->fw_buffer);
2677 		hdw->fw_buffer = NULL;
2678 	}
2679 	if (hdw->vid_stream) {
2680 		pvr2_stream_destroy(hdw->vid_stream);
2681 		hdw->vid_stream = NULL;
2682 	}
2683 	v4l2_device_unregister(&hdw->v4l2_dev);
2684 	pvr2_hdw_disconnect(hdw);
2685 	mutex_lock(&pvr2_unit_mtx);
2686 	do {
2687 		if ((hdw->unit_number >= 0) &&
2688 		    (hdw->unit_number < PVR_NUM) &&
2689 		    (unit_pointers[hdw->unit_number] == hdw)) {
2690 			unit_pointers[hdw->unit_number] = NULL;
2691 		}
2692 	} while (0);
2693 	mutex_unlock(&pvr2_unit_mtx);
2694 	kfree(hdw->controls);
2695 	kfree(hdw->mpeg_ctrl_info);
2696 	kfree(hdw);
2697 }
2698 
2699 
2700 int pvr2_hdw_dev_ok(struct pvr2_hdw *hdw)
2701 {
2702 	return (hdw && hdw->flag_ok);
2703 }
2704 
2705 
2706 /* Called when hardware has been unplugged */
2707 void pvr2_hdw_disconnect(struct pvr2_hdw *hdw)
2708 {
2709 	pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_disconnect(hdw=%p)",hdw);
2710 	LOCK_TAKE(hdw->big_lock);
2711 	pvr2_i2c_core_done(hdw);
2712 	LOCK_TAKE(hdw->ctl_lock);
2713 	pvr2_hdw_remove_usb_stuff(hdw);
2714 	LOCK_GIVE(hdw->ctl_lock);
2715 	LOCK_GIVE(hdw->big_lock);
2716 }
2717 
2718 
2719 /* Get the number of defined controls */
2720 unsigned int pvr2_hdw_get_ctrl_count(struct pvr2_hdw *hdw)
2721 {
2722 	return hdw->control_cnt;
2723 }
2724 
2725 
2726 /* Retrieve a control handle given its index (0..count-1) */
2727 struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_index(struct pvr2_hdw *hdw,
2728 					     unsigned int idx)
2729 {
2730 	if (idx >= hdw->control_cnt) return NULL;
2731 	return hdw->controls + idx;
2732 }
2733 
2734 
2735 /* Retrieve a control handle given its index (0..count-1) */
2736 struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_id(struct pvr2_hdw *hdw,
2737 					  unsigned int ctl_id)
2738 {
2739 	struct pvr2_ctrl *cptr;
2740 	unsigned int idx;
2741 	int i;
2742 
2743 	/* This could be made a lot more efficient, but for now... */
2744 	for (idx = 0; idx < hdw->control_cnt; idx++) {
2745 		cptr = hdw->controls + idx;
2746 		i = cptr->info->internal_id;
2747 		if (i && (i == ctl_id)) return cptr;
2748 	}
2749 	return NULL;
2750 }
2751 
2752 
2753 /* Given a V4L ID, retrieve the control structure associated with it. */
2754 struct pvr2_ctrl *pvr2_hdw_get_ctrl_v4l(struct pvr2_hdw *hdw,unsigned int ctl_id)
2755 {
2756 	struct pvr2_ctrl *cptr;
2757 	unsigned int idx;
2758 	int i;
2759 
2760 	/* This could be made a lot more efficient, but for now... */
2761 	for (idx = 0; idx < hdw->control_cnt; idx++) {
2762 		cptr = hdw->controls + idx;
2763 		i = cptr->info->v4l_id;
2764 		if (i && (i == ctl_id)) return cptr;
2765 	}
2766 	return NULL;
2767 }
2768 
2769 
2770 /* Given a V4L ID for its immediate predecessor, retrieve the control
2771    structure associated with it. */
2772 struct pvr2_ctrl *pvr2_hdw_get_ctrl_nextv4l(struct pvr2_hdw *hdw,
2773 					    unsigned int ctl_id)
2774 {
2775 	struct pvr2_ctrl *cptr,*cp2;
2776 	unsigned int idx;
2777 	int i;
2778 
2779 	/* This could be made a lot more efficient, but for now... */
2780 	cp2 = NULL;
2781 	for (idx = 0; idx < hdw->control_cnt; idx++) {
2782 		cptr = hdw->controls + idx;
2783 		i = cptr->info->v4l_id;
2784 		if (!i) continue;
2785 		if (i <= ctl_id) continue;
2786 		if (cp2 && (cp2->info->v4l_id < i)) continue;
2787 		cp2 = cptr;
2788 	}
2789 	return cp2;
2790 	return NULL;
2791 }
2792 
2793 
2794 static const char *get_ctrl_typename(enum pvr2_ctl_type tp)
2795 {
2796 	switch (tp) {
2797 	case pvr2_ctl_int: return "integer";
2798 	case pvr2_ctl_enum: return "enum";
2799 	case pvr2_ctl_bool: return "boolean";
2800 	case pvr2_ctl_bitmask: return "bitmask";
2801 	}
2802 	return "";
2803 }
2804 
2805 
2806 static void pvr2_subdev_set_control(struct pvr2_hdw *hdw, int id,
2807 				    const char *name, int val)
2808 {
2809 	struct v4l2_control ctrl;
2810 	struct v4l2_subdev *sd;
2811 
2812 	pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 %s=%d", name, val);
2813 	memset(&ctrl, 0, sizeof(ctrl));
2814 	ctrl.id = id;
2815 	ctrl.value = val;
2816 
2817 	v4l2_device_for_each_subdev(sd, &hdw->v4l2_dev)
2818 		v4l2_s_ctrl(NULL, sd->ctrl_handler, &ctrl);
2819 }
2820 
2821 #define PVR2_SUBDEV_SET_CONTROL(hdw, id, lab) \
2822 	if ((hdw)->lab##_dirty || (hdw)->force_dirty) {		\
2823 		pvr2_subdev_set_control(hdw, id, #lab, (hdw)->lab##_val); \
2824 	}
2825 
2826 static v4l2_std_id pvr2_hdw_get_detected_std(struct pvr2_hdw *hdw)
2827 {
2828 	v4l2_std_id std;
2829 	std = (v4l2_std_id)hdw->std_mask_avail;
2830 	v4l2_device_call_all(&hdw->v4l2_dev, 0,
2831 			     video, querystd, &std);
2832 	return std;
2833 }
2834 
2835 /* Execute whatever commands are required to update the state of all the
2836    sub-devices so that they match our current control values. */
2837 static void pvr2_subdev_update(struct pvr2_hdw *hdw)
2838 {
2839 	struct v4l2_subdev *sd;
2840 	unsigned int id;
2841 	pvr2_subdev_update_func fp;
2842 
2843 	pvr2_trace(PVR2_TRACE_CHIPS, "subdev update...");
2844 
2845 	if (hdw->tuner_updated || hdw->force_dirty) {
2846 		struct tuner_setup setup;
2847 		pvr2_trace(PVR2_TRACE_CHIPS, "subdev tuner set_type(%d)",
2848 			   hdw->tuner_type);
2849 		if (((int)(hdw->tuner_type)) >= 0) {
2850 			memset(&setup, 0, sizeof(setup));
2851 			setup.addr = ADDR_UNSET;
2852 			setup.type = hdw->tuner_type;
2853 			setup.mode_mask = T_RADIO | T_ANALOG_TV;
2854 			v4l2_device_call_all(&hdw->v4l2_dev, 0,
2855 					     tuner, s_type_addr, &setup);
2856 		}
2857 	}
2858 
2859 	if (hdw->input_dirty || hdw->std_dirty || hdw->force_dirty) {
2860 		pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_standard");
2861 		if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
2862 			v4l2_device_call_all(&hdw->v4l2_dev, 0,
2863 					     tuner, s_radio);
2864 		} else {
2865 			v4l2_std_id vs;
2866 			vs = hdw->std_mask_cur;
2867 			v4l2_device_call_all(&hdw->v4l2_dev, 0,
2868 					     video, s_std, vs);
2869 			pvr2_hdw_cx25840_vbi_hack(hdw);
2870 		}
2871 		hdw->tuner_signal_stale = !0;
2872 		hdw->cropcap_stale = !0;
2873 	}
2874 
2875 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_BRIGHTNESS, brightness);
2876 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_CONTRAST, contrast);
2877 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_SATURATION, saturation);
2878 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_HUE, hue);
2879 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_MUTE, mute);
2880 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_VOLUME, volume);
2881 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_BALANCE, balance);
2882 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_BASS, bass);
2883 	PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_TREBLE, treble);
2884 
2885 	if (hdw->input_dirty || hdw->audiomode_dirty || hdw->force_dirty) {
2886 		struct v4l2_tuner vt;
2887 		memset(&vt, 0, sizeof(vt));
2888 		vt.type = (hdw->input_val == PVR2_CVAL_INPUT_RADIO) ?
2889 			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2890 		vt.audmode = hdw->audiomode_val;
2891 		v4l2_device_call_all(&hdw->v4l2_dev, 0, tuner, s_tuner, &vt);
2892 	}
2893 
2894 	if (hdw->freqDirty || hdw->force_dirty) {
2895 		unsigned long fv;
2896 		struct v4l2_frequency freq;
2897 		fv = pvr2_hdw_get_cur_freq(hdw);
2898 		pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_freq(%lu)", fv);
2899 		if (hdw->tuner_signal_stale) pvr2_hdw_status_poll(hdw);
2900 		memset(&freq, 0, sizeof(freq));
2901 		if (hdw->tuner_signal_info.capability & V4L2_TUNER_CAP_LOW) {
2902 			/* ((fv * 1000) / 62500) */
2903 			freq.frequency = (fv * 2) / 125;
2904 		} else {
2905 			freq.frequency = fv / 62500;
2906 		}
2907 		/* tuner-core currently doesn't seem to care about this, but
2908 		   let's set it anyway for completeness. */
2909 		if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
2910 			freq.type = V4L2_TUNER_RADIO;
2911 		} else {
2912 			freq.type = V4L2_TUNER_ANALOG_TV;
2913 		}
2914 		freq.tuner = 0;
2915 		v4l2_device_call_all(&hdw->v4l2_dev, 0, tuner,
2916 				     s_frequency, &freq);
2917 	}
2918 
2919 	if (hdw->res_hor_dirty || hdw->res_ver_dirty || hdw->force_dirty) {
2920 		struct v4l2_subdev_format format = {
2921 			.which = V4L2_SUBDEV_FORMAT_ACTIVE,
2922 		};
2923 
2924 		format.format.width = hdw->res_hor_val;
2925 		format.format.height = hdw->res_ver_val;
2926 		format.format.code = MEDIA_BUS_FMT_FIXED;
2927 		pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_size(%dx%d)",
2928 			   format.format.width, format.format.height);
2929 		v4l2_device_call_all(&hdw->v4l2_dev, 0, pad, set_fmt,
2930 				     NULL, &format);
2931 	}
2932 
2933 	if (hdw->srate_dirty || hdw->force_dirty) {
2934 		u32 val;
2935 		pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_audio %d",
2936 			   hdw->srate_val);
2937 		switch (hdw->srate_val) {
2938 		default:
2939 		case V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000:
2940 			val = 48000;
2941 			break;
2942 		case V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100:
2943 			val = 44100;
2944 			break;
2945 		case V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000:
2946 			val = 32000;
2947 			break;
2948 		}
2949 		v4l2_device_call_all(&hdw->v4l2_dev, 0,
2950 				     audio, s_clock_freq, val);
2951 	}
2952 
2953 	/* Unable to set crop parameters; there is apparently no equivalent
2954 	   for VIDIOC_S_CROP */
2955 
2956 	v4l2_device_for_each_subdev(sd, &hdw->v4l2_dev) {
2957 		id = sd->grp_id;
2958 		if (id >= ARRAY_SIZE(pvr2_module_update_functions)) continue;
2959 		fp = pvr2_module_update_functions[id];
2960 		if (!fp) continue;
2961 		(*fp)(hdw, sd);
2962 	}
2963 
2964 	if (hdw->tuner_signal_stale || hdw->cropcap_stale) {
2965 		pvr2_hdw_status_poll(hdw);
2966 	}
2967 }
2968 
2969 
2970 /* Figure out if we need to commit control changes.  If so, mark internal
2971    state flags to indicate this fact and return true.  Otherwise do nothing
2972    else and return false. */
2973 static int pvr2_hdw_commit_setup(struct pvr2_hdw *hdw)
2974 {
2975 	unsigned int idx;
2976 	struct pvr2_ctrl *cptr;
2977 	int value;
2978 	int commit_flag = hdw->force_dirty;
2979 	char buf[100];
2980 	unsigned int bcnt,ccnt;
2981 
2982 	for (idx = 0; idx < hdw->control_cnt; idx++) {
2983 		cptr = hdw->controls + idx;
2984 		if (!cptr->info->is_dirty) continue;
2985 		if (!cptr->info->is_dirty(cptr)) continue;
2986 		commit_flag = !0;
2987 
2988 		if (!(pvrusb2_debug & PVR2_TRACE_CTL)) continue;
2989 		bcnt = scnprintf(buf,sizeof(buf),"\"%s\" <-- ",
2990 				 cptr->info->name);
2991 		value = 0;
2992 		cptr->info->get_value(cptr,&value);
2993 		pvr2_ctrl_value_to_sym_internal(cptr,~0,value,
2994 						buf+bcnt,
2995 						sizeof(buf)-bcnt,&ccnt);
2996 		bcnt += ccnt;
2997 		bcnt += scnprintf(buf+bcnt,sizeof(buf)-bcnt," <%s>",
2998 				  get_ctrl_typename(cptr->info->type));
2999 		pvr2_trace(PVR2_TRACE_CTL,
3000 			   "/*--TRACE_COMMIT--*/ %.*s",
3001 			   bcnt,buf);
3002 	}
3003 
3004 	if (!commit_flag) {
3005 		/* Nothing has changed */
3006 		return 0;
3007 	}
3008 
3009 	hdw->state_pipeline_config = 0;
3010 	trace_stbit("state_pipeline_config",hdw->state_pipeline_config);
3011 	pvr2_hdw_state_sched(hdw);
3012 
3013 	return !0;
3014 }
3015 
3016 
3017 /* Perform all operations needed to commit all control changes.  This must
3018    be performed in synchronization with the pipeline state and is thus
3019    expected to be called as part of the driver's worker thread.  Return
3020    true if commit successful, otherwise return false to indicate that
3021    commit isn't possible at this time. */
3022 static int pvr2_hdw_commit_execute(struct pvr2_hdw *hdw)
3023 {
3024 	unsigned int idx;
3025 	struct pvr2_ctrl *cptr;
3026 	int disruptive_change;
3027 
3028 	if (hdw->input_dirty && hdw->state_pathway_ok &&
3029 	    (((hdw->input_val == PVR2_CVAL_INPUT_DTV) ?
3030 	      PVR2_PATHWAY_DIGITAL : PVR2_PATHWAY_ANALOG) !=
3031 	     hdw->pathway_state)) {
3032 		/* Change of mode being asked for... */
3033 		hdw->state_pathway_ok = 0;
3034 		trace_stbit("state_pathway_ok", hdw->state_pathway_ok);
3035 	}
3036 	if (!hdw->state_pathway_ok) {
3037 		/* Can't commit anything until pathway is ok. */
3038 		return 0;
3039 	}
3040 
3041 	/* Handle some required side effects when the video standard is
3042 	   changed.... */
3043 	if (hdw->std_dirty) {
3044 		int nvres;
3045 		int gop_size;
3046 		if (hdw->std_mask_cur & V4L2_STD_525_60) {
3047 			nvres = 480;
3048 			gop_size = 15;
3049 		} else {
3050 			nvres = 576;
3051 			gop_size = 12;
3052 		}
3053 		/* Rewrite the vertical resolution to be appropriate to the
3054 		   video standard that has been selected. */
3055 		if (nvres != hdw->res_ver_val) {
3056 			hdw->res_ver_val = nvres;
3057 			hdw->res_ver_dirty = !0;
3058 		}
3059 		/* Rewrite the GOP size to be appropriate to the video
3060 		   standard that has been selected. */
3061 		if (gop_size != hdw->enc_ctl_state.video_gop_size) {
3062 			struct v4l2_ext_controls cs;
3063 			struct v4l2_ext_control c1;
3064 			memset(&cs, 0, sizeof(cs));
3065 			memset(&c1, 0, sizeof(c1));
3066 			cs.controls = &c1;
3067 			cs.count = 1;
3068 			c1.id = V4L2_CID_MPEG_VIDEO_GOP_SIZE;
3069 			c1.value = gop_size;
3070 			cx2341x_ext_ctrls(&hdw->enc_ctl_state, 0, &cs,
3071 					  VIDIOC_S_EXT_CTRLS);
3072 		}
3073 	}
3074 
3075 	/* The broadcast decoder can only scale down, so if
3076 	 * res_*_dirty && crop window < output format ==> enlarge crop.
3077 	 *
3078 	 * The mpeg encoder receives fields of res_hor_val dots and
3079 	 * res_ver_val halflines.  Limits: hor<=720, ver<=576.
3080 	 */
3081 	if (hdw->res_hor_dirty && hdw->cropw_val < hdw->res_hor_val) {
3082 		hdw->cropw_val = hdw->res_hor_val;
3083 		hdw->cropw_dirty = !0;
3084 	} else if (hdw->cropw_dirty) {
3085 		hdw->res_hor_dirty = !0;           /* must rescale */
3086 		hdw->res_hor_val = min(720, hdw->cropw_val);
3087 	}
3088 	if (hdw->res_ver_dirty && hdw->croph_val < hdw->res_ver_val) {
3089 		hdw->croph_val = hdw->res_ver_val;
3090 		hdw->croph_dirty = !0;
3091 	} else if (hdw->croph_dirty) {
3092 		int nvres = hdw->std_mask_cur & V4L2_STD_525_60 ? 480 : 576;
3093 		hdw->res_ver_dirty = !0;
3094 		hdw->res_ver_val = min(nvres, hdw->croph_val);
3095 	}
3096 
3097 	/* If any of the below has changed, then we can't do the update
3098 	   while the pipeline is running.  Pipeline must be paused first
3099 	   and decoder -> encoder connection be made quiescent before we
3100 	   can proceed. */
3101 	disruptive_change =
3102 		(hdw->std_dirty ||
3103 		 hdw->enc_unsafe_stale ||
3104 		 hdw->srate_dirty ||
3105 		 hdw->res_ver_dirty ||
3106 		 hdw->res_hor_dirty ||
3107 		 hdw->cropw_dirty ||
3108 		 hdw->croph_dirty ||
3109 		 hdw->input_dirty ||
3110 		 (hdw->active_stream_type != hdw->desired_stream_type));
3111 	if (disruptive_change && !hdw->state_pipeline_idle) {
3112 		/* Pipeline is not idle; we can't proceed.  Arrange to
3113 		   cause pipeline to stop so that we can try this again
3114 		   later.... */
3115 		hdw->state_pipeline_pause = !0;
3116 		return 0;
3117 	}
3118 
3119 	if (hdw->srate_dirty) {
3120 		/* Write new sample rate into control structure since
3121 		 * the master copy is stale.  We must track srate
3122 		 * separate from the mpeg control structure because
3123 		 * other logic also uses this value. */
3124 		struct v4l2_ext_controls cs;
3125 		struct v4l2_ext_control c1;
3126 		memset(&cs,0,sizeof(cs));
3127 		memset(&c1,0,sizeof(c1));
3128 		cs.controls = &c1;
3129 		cs.count = 1;
3130 		c1.id = V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ;
3131 		c1.value = hdw->srate_val;
3132 		cx2341x_ext_ctrls(&hdw->enc_ctl_state, 0, &cs,VIDIOC_S_EXT_CTRLS);
3133 	}
3134 
3135 	if (hdw->active_stream_type != hdw->desired_stream_type) {
3136 		/* Handle any side effects of stream config here */
3137 		hdw->active_stream_type = hdw->desired_stream_type;
3138 	}
3139 
3140 	if (hdw->hdw_desc->signal_routing_scheme ==
3141 	    PVR2_ROUTING_SCHEME_GOTVIEW) {
3142 		u32 b;
3143 		/* Handle GOTVIEW audio switching */
3144 		pvr2_hdw_gpio_get_out(hdw,&b);
3145 		if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
3146 			/* Set GPIO 11 */
3147 			pvr2_hdw_gpio_chg_out(hdw,(1 << 11),~0);
3148 		} else {
3149 			/* Clear GPIO 11 */
3150 			pvr2_hdw_gpio_chg_out(hdw,(1 << 11),0);
3151 		}
3152 	}
3153 
3154 	/* Check and update state for all sub-devices. */
3155 	pvr2_subdev_update(hdw);
3156 
3157 	hdw->tuner_updated = 0;
3158 	hdw->force_dirty = 0;
3159 	for (idx = 0; idx < hdw->control_cnt; idx++) {
3160 		cptr = hdw->controls + idx;
3161 		if (!cptr->info->clear_dirty) continue;
3162 		cptr->info->clear_dirty(cptr);
3163 	}
3164 
3165 	if ((hdw->pathway_state == PVR2_PATHWAY_ANALOG) &&
3166 	    hdw->state_encoder_run) {
3167 		/* If encoder isn't running or it can't be touched, then
3168 		   this will get worked out later when we start the
3169 		   encoder. */
3170 		if (pvr2_encoder_adjust(hdw) < 0) return !0;
3171 	}
3172 
3173 	hdw->state_pipeline_config = !0;
3174 	/* Hardware state may have changed in a way to cause the cropping
3175 	   capabilities to have changed.  So mark it stale, which will
3176 	   cause a later re-fetch. */
3177 	trace_stbit("state_pipeline_config",hdw->state_pipeline_config);
3178 	return !0;
3179 }
3180 
3181 
3182 int pvr2_hdw_commit_ctl(struct pvr2_hdw *hdw)
3183 {
3184 	int fl;
3185 	LOCK_TAKE(hdw->big_lock);
3186 	fl = pvr2_hdw_commit_setup(hdw);
3187 	LOCK_GIVE(hdw->big_lock);
3188 	if (!fl) return 0;
3189 	return pvr2_hdw_wait(hdw,0);
3190 }
3191 
3192 
3193 static void pvr2_hdw_worker_poll(struct work_struct *work)
3194 {
3195 	int fl = 0;
3196 	struct pvr2_hdw *hdw = container_of(work,struct pvr2_hdw,workpoll);
3197 	LOCK_TAKE(hdw->big_lock); do {
3198 		fl = pvr2_hdw_state_eval(hdw);
3199 	} while (0); LOCK_GIVE(hdw->big_lock);
3200 	if (fl && hdw->state_func) {
3201 		hdw->state_func(hdw->state_data);
3202 	}
3203 }
3204 
3205 
3206 static int pvr2_hdw_wait(struct pvr2_hdw *hdw,int state)
3207 {
3208 	return wait_event_interruptible(
3209 		hdw->state_wait_data,
3210 		(hdw->state_stale == 0) &&
3211 		(!state || (hdw->master_state != state)));
3212 }
3213 
3214 
3215 /* Return name for this driver instance */
3216 const char *pvr2_hdw_get_driver_name(struct pvr2_hdw *hdw)
3217 {
3218 	return hdw->name;
3219 }
3220 
3221 
3222 const char *pvr2_hdw_get_desc(struct pvr2_hdw *hdw)
3223 {
3224 	return hdw->hdw_desc->description;
3225 }
3226 
3227 
3228 const char *pvr2_hdw_get_type(struct pvr2_hdw *hdw)
3229 {
3230 	return hdw->hdw_desc->shortname;
3231 }
3232 
3233 
3234 int pvr2_hdw_is_hsm(struct pvr2_hdw *hdw)
3235 {
3236 	int result;
3237 	LOCK_TAKE(hdw->ctl_lock); do {
3238 		hdw->cmd_buffer[0] = FX2CMD_GET_USB_SPEED;
3239 		result = pvr2_send_request(hdw,
3240 					   hdw->cmd_buffer,1,
3241 					   hdw->cmd_buffer,1);
3242 		if (result < 0) break;
3243 		result = (hdw->cmd_buffer[0] != 0);
3244 	} while(0); LOCK_GIVE(hdw->ctl_lock);
3245 	return result;
3246 }
3247 
3248 
3249 /* Execute poll of tuner status */
3250 void pvr2_hdw_execute_tuner_poll(struct pvr2_hdw *hdw)
3251 {
3252 	LOCK_TAKE(hdw->big_lock); do {
3253 		pvr2_hdw_status_poll(hdw);
3254 	} while (0); LOCK_GIVE(hdw->big_lock);
3255 }
3256 
3257 
3258 static int pvr2_hdw_check_cropcap(struct pvr2_hdw *hdw)
3259 {
3260 	if (!hdw->cropcap_stale) {
3261 		return 0;
3262 	}
3263 	pvr2_hdw_status_poll(hdw);
3264 	if (hdw->cropcap_stale) {
3265 		return -EIO;
3266 	}
3267 	return 0;
3268 }
3269 
3270 
3271 /* Return information about cropping capabilities */
3272 int pvr2_hdw_get_cropcap(struct pvr2_hdw *hdw, struct v4l2_cropcap *pp)
3273 {
3274 	int stat = 0;
3275 	LOCK_TAKE(hdw->big_lock);
3276 	stat = pvr2_hdw_check_cropcap(hdw);
3277 	if (!stat) {
3278 		memcpy(pp, &hdw->cropcap_info, sizeof(hdw->cropcap_info));
3279 	}
3280 	LOCK_GIVE(hdw->big_lock);
3281 	return stat;
3282 }
3283 
3284 
3285 /* Return information about the tuner */
3286 int pvr2_hdw_get_tuner_status(struct pvr2_hdw *hdw,struct v4l2_tuner *vtp)
3287 {
3288 	LOCK_TAKE(hdw->big_lock);
3289 	do {
3290 		if (hdw->tuner_signal_stale) {
3291 			pvr2_hdw_status_poll(hdw);
3292 		}
3293 		memcpy(vtp,&hdw->tuner_signal_info,sizeof(struct v4l2_tuner));
3294 	} while (0);
3295 	LOCK_GIVE(hdw->big_lock);
3296 	return 0;
3297 }
3298 
3299 
3300 /* Get handle to video output stream */
3301 struct pvr2_stream *pvr2_hdw_get_video_stream(struct pvr2_hdw *hp)
3302 {
3303 	return hp->vid_stream;
3304 }
3305 
3306 
3307 void pvr2_hdw_trigger_module_log(struct pvr2_hdw *hdw)
3308 {
3309 	int nr = pvr2_hdw_get_unit_number(hdw);
3310 	LOCK_TAKE(hdw->big_lock);
3311 	do {
3312 		pr_info("pvrusb2: =================  START STATUS CARD #%d  =================\n", nr);
3313 		v4l2_device_call_all(&hdw->v4l2_dev, 0, core, log_status);
3314 		pvr2_trace(PVR2_TRACE_INFO,"cx2341x config:");
3315 		cx2341x_log_status(&hdw->enc_ctl_state, "pvrusb2");
3316 		pvr2_hdw_state_log_state(hdw);
3317 		pr_info("pvrusb2: ==================  END STATUS CARD #%d  ==================\n", nr);
3318 	} while (0);
3319 	LOCK_GIVE(hdw->big_lock);
3320 }
3321 
3322 
3323 /* Grab EEPROM contents, needed for direct method. */
3324 #define EEPROM_SIZE 8192
3325 #define trace_eeprom(...) pvr2_trace(PVR2_TRACE_EEPROM,__VA_ARGS__)
3326 static u8 *pvr2_full_eeprom_fetch(struct pvr2_hdw *hdw)
3327 {
3328 	struct i2c_msg msg[2];
3329 	u8 *eeprom;
3330 	u8 iadd[2];
3331 	u8 addr;
3332 	u16 eepromSize;
3333 	unsigned int offs;
3334 	int ret;
3335 	int mode16 = 0;
3336 	unsigned pcnt,tcnt;
3337 	eeprom = kzalloc(EEPROM_SIZE, GFP_KERNEL);
3338 	if (!eeprom) {
3339 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3340 			   "Failed to allocate memory required to read eeprom");
3341 		return NULL;
3342 	}
3343 
3344 	trace_eeprom("Value for eeprom addr from controller was 0x%x",
3345 		     hdw->eeprom_addr);
3346 	addr = hdw->eeprom_addr;
3347 	/* Seems that if the high bit is set, then the *real* eeprom
3348 	   address is shifted right now bit position (noticed this in
3349 	   newer PVR USB2 hardware) */
3350 	if (addr & 0x80) addr >>= 1;
3351 
3352 	/* FX2 documentation states that a 16bit-addressed eeprom is
3353 	   expected if the I2C address is an odd number (yeah, this is
3354 	   strange but it's what they do) */
3355 	mode16 = (addr & 1);
3356 	eepromSize = (mode16 ? EEPROM_SIZE : 256);
3357 	trace_eeprom("Examining %d byte eeprom at location 0x%x using %d bit addressing",
3358 		     eepromSize, addr,
3359 		     mode16 ? 16 : 8);
3360 
3361 	msg[0].addr = addr;
3362 	msg[0].flags = 0;
3363 	msg[0].len = mode16 ? 2 : 1;
3364 	msg[0].buf = iadd;
3365 	msg[1].addr = addr;
3366 	msg[1].flags = I2C_M_RD;
3367 
3368 	/* We have to do the actual eeprom data fetch ourselves, because
3369 	   (1) we're only fetching part of the eeprom, and (2) if we were
3370 	   getting the whole thing our I2C driver can't grab it in one
3371 	   pass - which is what tveeprom is otherwise going to attempt */
3372 	for (tcnt = 0; tcnt < EEPROM_SIZE; tcnt += pcnt) {
3373 		pcnt = 16;
3374 		if (pcnt + tcnt > EEPROM_SIZE) pcnt = EEPROM_SIZE-tcnt;
3375 		offs = tcnt + (eepromSize - EEPROM_SIZE);
3376 		if (mode16) {
3377 			iadd[0] = offs >> 8;
3378 			iadd[1] = offs;
3379 		} else {
3380 			iadd[0] = offs;
3381 		}
3382 		msg[1].len = pcnt;
3383 		msg[1].buf = eeprom+tcnt;
3384 		if ((ret = i2c_transfer(&hdw->i2c_adap,
3385 					msg,ARRAY_SIZE(msg))) != 2) {
3386 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3387 				   "eeprom fetch set offs err=%d",ret);
3388 			kfree(eeprom);
3389 			return NULL;
3390 		}
3391 	}
3392 	return eeprom;
3393 }
3394 
3395 
3396 void pvr2_hdw_cpufw_set_enabled(struct pvr2_hdw *hdw,
3397 				int mode,
3398 				int enable_flag)
3399 {
3400 	int ret;
3401 	u16 address;
3402 	unsigned int pipe;
3403 	LOCK_TAKE(hdw->big_lock);
3404 	do {
3405 		if ((hdw->fw_buffer == NULL) == !enable_flag) break;
3406 
3407 		if (!enable_flag) {
3408 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3409 				   "Cleaning up after CPU firmware fetch");
3410 			kfree(hdw->fw_buffer);
3411 			hdw->fw_buffer = NULL;
3412 			hdw->fw_size = 0;
3413 			if (hdw->fw_cpu_flag) {
3414 				/* Now release the CPU.  It will disconnect
3415 				   and reconnect later. */
3416 				pvr2_hdw_cpureset_assert(hdw,0);
3417 			}
3418 			break;
3419 		}
3420 
3421 		hdw->fw_cpu_flag = (mode != 2);
3422 		if (hdw->fw_cpu_flag) {
3423 			hdw->fw_size = (mode == 1) ? 0x4000 : 0x2000;
3424 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3425 				   "Preparing to suck out CPU firmware (size=%u)",
3426 				   hdw->fw_size);
3427 			hdw->fw_buffer = kzalloc(hdw->fw_size,GFP_KERNEL);
3428 			if (!hdw->fw_buffer) {
3429 				hdw->fw_size = 0;
3430 				break;
3431 			}
3432 
3433 			/* We have to hold the CPU during firmware upload. */
3434 			pvr2_hdw_cpureset_assert(hdw,1);
3435 
3436 			/* download the firmware from address 0000-1fff in 2048
3437 			   (=0x800) bytes chunk. */
3438 
3439 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3440 				   "Grabbing CPU firmware");
3441 			pipe = usb_rcvctrlpipe(hdw->usb_dev, 0);
3442 			for(address = 0; address < hdw->fw_size;
3443 			    address += 0x800) {
3444 				ret = usb_control_msg(hdw->usb_dev,pipe,
3445 						      0xa0,0xc0,
3446 						      address,0,
3447 						      hdw->fw_buffer+address,
3448 						      0x800,1000);
3449 				if (ret < 0) break;
3450 			}
3451 
3452 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3453 				   "Done grabbing CPU firmware");
3454 		} else {
3455 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3456 				   "Sucking down EEPROM contents");
3457 			hdw->fw_buffer = pvr2_full_eeprom_fetch(hdw);
3458 			if (!hdw->fw_buffer) {
3459 				pvr2_trace(PVR2_TRACE_FIRMWARE,
3460 					   "EEPROM content suck failed.");
3461 				break;
3462 			}
3463 			hdw->fw_size = EEPROM_SIZE;
3464 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3465 				   "Done sucking down EEPROM contents");
3466 		}
3467 	} while (0);
3468 	LOCK_GIVE(hdw->big_lock);
3469 }
3470 
3471 
3472 /* Return true if we're in a mode for retrieval CPU firmware */
3473 int pvr2_hdw_cpufw_get_enabled(struct pvr2_hdw *hdw)
3474 {
3475 	return hdw->fw_buffer != NULL;
3476 }
3477 
3478 
3479 int pvr2_hdw_cpufw_get(struct pvr2_hdw *hdw,unsigned int offs,
3480 		       char *buf,unsigned int cnt)
3481 {
3482 	int ret = -EINVAL;
3483 	LOCK_TAKE(hdw->big_lock);
3484 	do {
3485 		if (!buf) break;
3486 		if (!cnt) break;
3487 
3488 		if (!hdw->fw_buffer) {
3489 			ret = -EIO;
3490 			break;
3491 		}
3492 
3493 		if (offs >= hdw->fw_size) {
3494 			pvr2_trace(PVR2_TRACE_FIRMWARE,
3495 				   "Read firmware data offs=%d EOF",
3496 				   offs);
3497 			ret = 0;
3498 			break;
3499 		}
3500 
3501 		if (offs + cnt > hdw->fw_size) cnt = hdw->fw_size - offs;
3502 
3503 		memcpy(buf,hdw->fw_buffer+offs,cnt);
3504 
3505 		pvr2_trace(PVR2_TRACE_FIRMWARE,
3506 			   "Read firmware data offs=%d cnt=%d",
3507 			   offs,cnt);
3508 		ret = cnt;
3509 	} while (0);
3510 	LOCK_GIVE(hdw->big_lock);
3511 
3512 	return ret;
3513 }
3514 
3515 
3516 int pvr2_hdw_v4l_get_minor_number(struct pvr2_hdw *hdw,
3517 				  enum pvr2_v4l_type index)
3518 {
3519 	switch (index) {
3520 	case pvr2_v4l_type_video: return hdw->v4l_minor_number_video;
3521 	case pvr2_v4l_type_vbi: return hdw->v4l_minor_number_vbi;
3522 	case pvr2_v4l_type_radio: return hdw->v4l_minor_number_radio;
3523 	default: return -1;
3524 	}
3525 }
3526 
3527 
3528 /* Store a v4l minor device number */
3529 void pvr2_hdw_v4l_store_minor_number(struct pvr2_hdw *hdw,
3530 				     enum pvr2_v4l_type index,int v)
3531 {
3532 	switch (index) {
3533 	case pvr2_v4l_type_video: hdw->v4l_minor_number_video = v;break;
3534 	case pvr2_v4l_type_vbi: hdw->v4l_minor_number_vbi = v;break;
3535 	case pvr2_v4l_type_radio: hdw->v4l_minor_number_radio = v;break;
3536 	default: break;
3537 	}
3538 }
3539 
3540 
3541 static void pvr2_ctl_write_complete(struct urb *urb)
3542 {
3543 	struct pvr2_hdw *hdw = urb->context;
3544 	hdw->ctl_write_pend_flag = 0;
3545 	if (hdw->ctl_read_pend_flag) return;
3546 	complete(&hdw->ctl_done);
3547 }
3548 
3549 
3550 static void pvr2_ctl_read_complete(struct urb *urb)
3551 {
3552 	struct pvr2_hdw *hdw = urb->context;
3553 	hdw->ctl_read_pend_flag = 0;
3554 	if (hdw->ctl_write_pend_flag) return;
3555 	complete(&hdw->ctl_done);
3556 }
3557 
3558 struct hdw_timer {
3559 	struct timer_list timer;
3560 	struct pvr2_hdw *hdw;
3561 };
3562 
3563 static void pvr2_ctl_timeout(struct timer_list *t)
3564 {
3565 	struct hdw_timer *timer = from_timer(timer, t, timer);
3566 	struct pvr2_hdw *hdw = timer->hdw;
3567 
3568 	if (hdw->ctl_write_pend_flag || hdw->ctl_read_pend_flag) {
3569 		hdw->ctl_timeout_flag = !0;
3570 		if (hdw->ctl_write_pend_flag)
3571 			usb_unlink_urb(hdw->ctl_write_urb);
3572 		if (hdw->ctl_read_pend_flag)
3573 			usb_unlink_urb(hdw->ctl_read_urb);
3574 	}
3575 }
3576 
3577 
3578 /* Issue a command and get a response from the device.  This extended
3579    version includes a probe flag (which if set means that device errors
3580    should not be logged or treated as fatal) and a timeout in jiffies.
3581    This can be used to non-lethally probe the health of endpoint 1. */
3582 static int pvr2_send_request_ex(struct pvr2_hdw *hdw,
3583 				unsigned int timeout,int probe_fl,
3584 				void *write_data,unsigned int write_len,
3585 				void *read_data,unsigned int read_len)
3586 {
3587 	unsigned int idx;
3588 	int status = 0;
3589 	struct hdw_timer timer = {
3590 		.hdw = hdw,
3591 	};
3592 
3593 	if (!hdw->ctl_lock_held) {
3594 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3595 			   "Attempted to execute control transfer without lock!!");
3596 		return -EDEADLK;
3597 	}
3598 	if (!hdw->flag_ok && !probe_fl) {
3599 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3600 			   "Attempted to execute control transfer when device not ok");
3601 		return -EIO;
3602 	}
3603 	if (!(hdw->ctl_read_urb && hdw->ctl_write_urb)) {
3604 		if (!probe_fl) {
3605 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3606 				   "Attempted to execute control transfer when USB is disconnected");
3607 		}
3608 		return -ENOTTY;
3609 	}
3610 
3611 	/* Ensure that we have sane parameters */
3612 	if (!write_data) write_len = 0;
3613 	if (!read_data) read_len = 0;
3614 	if (write_len > PVR2_CTL_BUFFSIZE) {
3615 		pvr2_trace(
3616 			PVR2_TRACE_ERROR_LEGS,
3617 			"Attempted to execute %d byte control-write transfer (limit=%d)",
3618 			write_len,PVR2_CTL_BUFFSIZE);
3619 		return -EINVAL;
3620 	}
3621 	if (read_len > PVR2_CTL_BUFFSIZE) {
3622 		pvr2_trace(
3623 			PVR2_TRACE_ERROR_LEGS,
3624 			"Attempted to execute %d byte control-read transfer (limit=%d)",
3625 			write_len,PVR2_CTL_BUFFSIZE);
3626 		return -EINVAL;
3627 	}
3628 	if ((!write_len) && (!read_len)) {
3629 		pvr2_trace(
3630 			PVR2_TRACE_ERROR_LEGS,
3631 			"Attempted to execute null control transfer?");
3632 		return -EINVAL;
3633 	}
3634 
3635 
3636 	hdw->cmd_debug_state = 1;
3637 	if (write_len && write_data)
3638 		hdw->cmd_debug_code = ((unsigned char *)write_data)[0];
3639 	else
3640 		hdw->cmd_debug_code = 0;
3641 	hdw->cmd_debug_write_len = write_len;
3642 	hdw->cmd_debug_read_len = read_len;
3643 
3644 	/* Initialize common stuff */
3645 	init_completion(&hdw->ctl_done);
3646 	hdw->ctl_timeout_flag = 0;
3647 	hdw->ctl_write_pend_flag = 0;
3648 	hdw->ctl_read_pend_flag = 0;
3649 	timer_setup_on_stack(&timer.timer, pvr2_ctl_timeout, 0);
3650 	timer.timer.expires = jiffies + timeout;
3651 
3652 	if (write_len && write_data) {
3653 		hdw->cmd_debug_state = 2;
3654 		/* Transfer write data to internal buffer */
3655 		for (idx = 0; idx < write_len; idx++) {
3656 			hdw->ctl_write_buffer[idx] =
3657 				((unsigned char *)write_data)[idx];
3658 		}
3659 		/* Initiate a write request */
3660 		usb_fill_bulk_urb(hdw->ctl_write_urb,
3661 				  hdw->usb_dev,
3662 				  usb_sndbulkpipe(hdw->usb_dev,
3663 						  PVR2_CTL_WRITE_ENDPOINT),
3664 				  hdw->ctl_write_buffer,
3665 				  write_len,
3666 				  pvr2_ctl_write_complete,
3667 				  hdw);
3668 		hdw->ctl_write_urb->actual_length = 0;
3669 		hdw->ctl_write_pend_flag = !0;
3670 		if (usb_urb_ep_type_check(hdw->ctl_write_urb)) {
3671 			pvr2_trace(
3672 				PVR2_TRACE_ERROR_LEGS,
3673 				"Invalid write control endpoint");
3674 			return -EINVAL;
3675 		}
3676 		status = usb_submit_urb(hdw->ctl_write_urb,GFP_KERNEL);
3677 		if (status < 0) {
3678 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3679 				   "Failed to submit write-control URB status=%d",
3680 status);
3681 			hdw->ctl_write_pend_flag = 0;
3682 			goto done;
3683 		}
3684 	}
3685 
3686 	if (read_len) {
3687 		hdw->cmd_debug_state = 3;
3688 		memset(hdw->ctl_read_buffer,0x43,read_len);
3689 		/* Initiate a read request */
3690 		usb_fill_bulk_urb(hdw->ctl_read_urb,
3691 				  hdw->usb_dev,
3692 				  usb_rcvbulkpipe(hdw->usb_dev,
3693 						  PVR2_CTL_READ_ENDPOINT),
3694 				  hdw->ctl_read_buffer,
3695 				  read_len,
3696 				  pvr2_ctl_read_complete,
3697 				  hdw);
3698 		hdw->ctl_read_urb->actual_length = 0;
3699 		hdw->ctl_read_pend_flag = !0;
3700 		if (usb_urb_ep_type_check(hdw->ctl_read_urb)) {
3701 			pvr2_trace(
3702 				PVR2_TRACE_ERROR_LEGS,
3703 				"Invalid read control endpoint");
3704 			return -EINVAL;
3705 		}
3706 		status = usb_submit_urb(hdw->ctl_read_urb,GFP_KERNEL);
3707 		if (status < 0) {
3708 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3709 				   "Failed to submit read-control URB status=%d",
3710 status);
3711 			hdw->ctl_read_pend_flag = 0;
3712 			goto done;
3713 		}
3714 	}
3715 
3716 	/* Start timer */
3717 	add_timer(&timer.timer);
3718 
3719 	/* Now wait for all I/O to complete */
3720 	hdw->cmd_debug_state = 4;
3721 	while (hdw->ctl_write_pend_flag || hdw->ctl_read_pend_flag) {
3722 		wait_for_completion(&hdw->ctl_done);
3723 	}
3724 	hdw->cmd_debug_state = 5;
3725 
3726 	/* Stop timer */
3727 	del_timer_sync(&timer.timer);
3728 
3729 	hdw->cmd_debug_state = 6;
3730 	status = 0;
3731 
3732 	if (hdw->ctl_timeout_flag) {
3733 		status = -ETIMEDOUT;
3734 		if (!probe_fl) {
3735 			pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3736 				   "Timed out control-write");
3737 		}
3738 		goto done;
3739 	}
3740 
3741 	if (write_len) {
3742 		/* Validate results of write request */
3743 		if ((hdw->ctl_write_urb->status != 0) &&
3744 		    (hdw->ctl_write_urb->status != -ENOENT) &&
3745 		    (hdw->ctl_write_urb->status != -ESHUTDOWN) &&
3746 		    (hdw->ctl_write_urb->status != -ECONNRESET)) {
3747 			/* USB subsystem is reporting some kind of failure
3748 			   on the write */
3749 			status = hdw->ctl_write_urb->status;
3750 			if (!probe_fl) {
3751 				pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3752 					   "control-write URB failure, status=%d",
3753 					   status);
3754 			}
3755 			goto done;
3756 		}
3757 		if (hdw->ctl_write_urb->actual_length < write_len) {
3758 			/* Failed to write enough data */
3759 			status = -EIO;
3760 			if (!probe_fl) {
3761 				pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3762 					   "control-write URB short, expected=%d got=%d",
3763 					   write_len,
3764 					   hdw->ctl_write_urb->actual_length);
3765 			}
3766 			goto done;
3767 		}
3768 	}
3769 	if (read_len && read_data) {
3770 		/* Validate results of read request */
3771 		if ((hdw->ctl_read_urb->status != 0) &&
3772 		    (hdw->ctl_read_urb->status != -ENOENT) &&
3773 		    (hdw->ctl_read_urb->status != -ESHUTDOWN) &&
3774 		    (hdw->ctl_read_urb->status != -ECONNRESET)) {
3775 			/* USB subsystem is reporting some kind of failure
3776 			   on the read */
3777 			status = hdw->ctl_read_urb->status;
3778 			if (!probe_fl) {
3779 				pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3780 					   "control-read URB failure, status=%d",
3781 					   status);
3782 			}
3783 			goto done;
3784 		}
3785 		if (hdw->ctl_read_urb->actual_length < read_len) {
3786 			/* Failed to read enough data */
3787 			status = -EIO;
3788 			if (!probe_fl) {
3789 				pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3790 					   "control-read URB short, expected=%d got=%d",
3791 					   read_len,
3792 					   hdw->ctl_read_urb->actual_length);
3793 			}
3794 			goto done;
3795 		}
3796 		/* Transfer retrieved data out from internal buffer */
3797 		for (idx = 0; idx < read_len; idx++) {
3798 			((unsigned char *)read_data)[idx] =
3799 				hdw->ctl_read_buffer[idx];
3800 		}
3801 	}
3802 
3803  done:
3804 
3805 	hdw->cmd_debug_state = 0;
3806 	if ((status < 0) && (!probe_fl)) {
3807 		pvr2_hdw_render_useless(hdw);
3808 	}
3809 	destroy_timer_on_stack(&timer.timer);
3810 
3811 	return status;
3812 }
3813 
3814 
3815 int pvr2_send_request(struct pvr2_hdw *hdw,
3816 		      void *write_data,unsigned int write_len,
3817 		      void *read_data,unsigned int read_len)
3818 {
3819 	return pvr2_send_request_ex(hdw,HZ*4,0,
3820 				    write_data,write_len,
3821 				    read_data,read_len);
3822 }
3823 
3824 
3825 static int pvr2_issue_simple_cmd(struct pvr2_hdw *hdw,u32 cmdcode)
3826 {
3827 	int ret;
3828 	unsigned int cnt = 1;
3829 	unsigned int args = 0;
3830 	LOCK_TAKE(hdw->ctl_lock);
3831 	hdw->cmd_buffer[0] = cmdcode & 0xffu;
3832 	args = (cmdcode >> 8) & 0xffu;
3833 	args = (args > 2) ? 2 : args;
3834 	if (args) {
3835 		cnt += args;
3836 		hdw->cmd_buffer[1] = (cmdcode >> 16) & 0xffu;
3837 		if (args > 1) {
3838 			hdw->cmd_buffer[2] = (cmdcode >> 24) & 0xffu;
3839 		}
3840 	}
3841 	if (pvrusb2_debug & PVR2_TRACE_INIT) {
3842 		unsigned int idx;
3843 		unsigned int ccnt,bcnt;
3844 		char tbuf[50];
3845 		cmdcode &= 0xffu;
3846 		bcnt = 0;
3847 		ccnt = scnprintf(tbuf+bcnt,
3848 				 sizeof(tbuf)-bcnt,
3849 				 "Sending FX2 command 0x%x",cmdcode);
3850 		bcnt += ccnt;
3851 		for (idx = 0; idx < ARRAY_SIZE(pvr2_fx2cmd_desc); idx++) {
3852 			if (pvr2_fx2cmd_desc[idx].id == cmdcode) {
3853 				ccnt = scnprintf(tbuf+bcnt,
3854 						 sizeof(tbuf)-bcnt,
3855 						 " \"%s\"",
3856 						 pvr2_fx2cmd_desc[idx].desc);
3857 				bcnt += ccnt;
3858 				break;
3859 			}
3860 		}
3861 		if (args) {
3862 			ccnt = scnprintf(tbuf+bcnt,
3863 					 sizeof(tbuf)-bcnt,
3864 					 " (%u",hdw->cmd_buffer[1]);
3865 			bcnt += ccnt;
3866 			if (args > 1) {
3867 				ccnt = scnprintf(tbuf+bcnt,
3868 						 sizeof(tbuf)-bcnt,
3869 						 ",%u",hdw->cmd_buffer[2]);
3870 				bcnt += ccnt;
3871 			}
3872 			ccnt = scnprintf(tbuf+bcnt,
3873 					 sizeof(tbuf)-bcnt,
3874 					 ")");
3875 			bcnt += ccnt;
3876 		}
3877 		pvr2_trace(PVR2_TRACE_INIT,"%.*s",bcnt,tbuf);
3878 	}
3879 	ret = pvr2_send_request(hdw,hdw->cmd_buffer,cnt,NULL,0);
3880 	LOCK_GIVE(hdw->ctl_lock);
3881 	return ret;
3882 }
3883 
3884 
3885 int pvr2_write_register(struct pvr2_hdw *hdw, u16 reg, u32 data)
3886 {
3887 	int ret;
3888 
3889 	LOCK_TAKE(hdw->ctl_lock);
3890 
3891 	hdw->cmd_buffer[0] = FX2CMD_REG_WRITE;  /* write register prefix */
3892 	PVR2_DECOMPOSE_LE(hdw->cmd_buffer,1,data);
3893 	hdw->cmd_buffer[5] = 0;
3894 	hdw->cmd_buffer[6] = (reg >> 8) & 0xff;
3895 	hdw->cmd_buffer[7] = reg & 0xff;
3896 
3897 
3898 	ret = pvr2_send_request(hdw, hdw->cmd_buffer, 8, hdw->cmd_buffer, 0);
3899 
3900 	LOCK_GIVE(hdw->ctl_lock);
3901 
3902 	return ret;
3903 }
3904 
3905 
3906 static int pvr2_read_register(struct pvr2_hdw *hdw, u16 reg, u32 *data)
3907 {
3908 	int ret = 0;
3909 
3910 	LOCK_TAKE(hdw->ctl_lock);
3911 
3912 	hdw->cmd_buffer[0] = FX2CMD_REG_READ;  /* read register prefix */
3913 	hdw->cmd_buffer[1] = 0;
3914 	hdw->cmd_buffer[2] = 0;
3915 	hdw->cmd_buffer[3] = 0;
3916 	hdw->cmd_buffer[4] = 0;
3917 	hdw->cmd_buffer[5] = 0;
3918 	hdw->cmd_buffer[6] = (reg >> 8) & 0xff;
3919 	hdw->cmd_buffer[7] = reg & 0xff;
3920 
3921 	ret |= pvr2_send_request(hdw, hdw->cmd_buffer, 8, hdw->cmd_buffer, 4);
3922 	*data = PVR2_COMPOSE_LE(hdw->cmd_buffer,0);
3923 
3924 	LOCK_GIVE(hdw->ctl_lock);
3925 
3926 	return ret;
3927 }
3928 
3929 
3930 void pvr2_hdw_render_useless(struct pvr2_hdw *hdw)
3931 {
3932 	if (!hdw->flag_ok) return;
3933 	pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3934 		   "Device being rendered inoperable");
3935 	if (hdw->vid_stream) {
3936 		pvr2_stream_setup(hdw->vid_stream,NULL,0,0);
3937 	}
3938 	hdw->flag_ok = 0;
3939 	trace_stbit("flag_ok",hdw->flag_ok);
3940 	pvr2_hdw_state_sched(hdw);
3941 }
3942 
3943 
3944 void pvr2_hdw_device_reset(struct pvr2_hdw *hdw)
3945 {
3946 	int ret;
3947 	pvr2_trace(PVR2_TRACE_INIT,"Performing a device reset...");
3948 	ret = usb_lock_device_for_reset(hdw->usb_dev,NULL);
3949 	if (ret == 0) {
3950 		ret = usb_reset_device(hdw->usb_dev);
3951 		usb_unlock_device(hdw->usb_dev);
3952 	} else {
3953 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3954 			   "Failed to lock USB device ret=%d",ret);
3955 	}
3956 	if (init_pause_msec) {
3957 		pvr2_trace(PVR2_TRACE_INFO,
3958 			   "Waiting %u msec for hardware to settle",
3959 			   init_pause_msec);
3960 		msleep(init_pause_msec);
3961 	}
3962 
3963 }
3964 
3965 
3966 void pvr2_hdw_cpureset_assert(struct pvr2_hdw *hdw,int val)
3967 {
3968 	char *da;
3969 	unsigned int pipe;
3970 	int ret;
3971 
3972 	if (!hdw->usb_dev) return;
3973 
3974 	da = kmalloc(16, GFP_KERNEL);
3975 
3976 	if (da == NULL) {
3977 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3978 			   "Unable to allocate memory to control CPU reset");
3979 		return;
3980 	}
3981 
3982 	pvr2_trace(PVR2_TRACE_INIT,"cpureset_assert(%d)",val);
3983 
3984 	da[0] = val ? 0x01 : 0x00;
3985 
3986 	/* Write the CPUCS register on the 8051.  The lsb of the register
3987 	   is the reset bit; a 1 asserts reset while a 0 clears it. */
3988 	pipe = usb_sndctrlpipe(hdw->usb_dev, 0);
3989 	ret = usb_control_msg(hdw->usb_dev,pipe,0xa0,0x40,0xe600,0,da,1,1000);
3990 	if (ret < 0) {
3991 		pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3992 			   "cpureset_assert(%d) error=%d",val,ret);
3993 		pvr2_hdw_render_useless(hdw);
3994 	}
3995 
3996 	kfree(da);
3997 }
3998 
3999 
4000 int pvr2_hdw_cmd_deep_reset(struct pvr2_hdw *hdw)
4001 {
4002 	return pvr2_issue_simple_cmd(hdw,FX2CMD_DEEP_RESET);
4003 }
4004 
4005 
4006 int pvr2_hdw_cmd_powerup(struct pvr2_hdw *hdw)
4007 {
4008 	return pvr2_issue_simple_cmd(hdw,FX2CMD_POWER_ON);
4009 }
4010 
4011 
4012 
4013 int pvr2_hdw_cmd_decoder_reset(struct pvr2_hdw *hdw)
4014 {
4015 	pvr2_trace(PVR2_TRACE_INIT,
4016 		   "Requesting decoder reset");
4017 	if (hdw->decoder_client_id) {
4018 		v4l2_device_call_all(&hdw->v4l2_dev, hdw->decoder_client_id,
4019 				     core, reset, 0);
4020 		pvr2_hdw_cx25840_vbi_hack(hdw);
4021 		return 0;
4022 	}
4023 	pvr2_trace(PVR2_TRACE_INIT,
4024 		   "Unable to reset decoder: nothing attached");
4025 	return -ENOTTY;
4026 }
4027 
4028 
4029 static int pvr2_hdw_cmd_hcw_demod_reset(struct pvr2_hdw *hdw, int onoff)
4030 {
4031 	hdw->flag_ok = !0;
4032 
4033 	/* Use this for Hauppauge 160xxx only */
4034 	if (le16_to_cpu(hdw->usb_dev->descriptor.idVendor) == 0x2040 &&
4035 	    (le16_to_cpu(hdw->usb_dev->descriptor.idProduct) == 0x7502 ||
4036 	     le16_to_cpu(hdw->usb_dev->descriptor.idProduct) == 0x7510)) {
4037 		pr_debug("%s(): resetting demod on Hauppauge 160xxx platform skipped\n",
4038 			 __func__);
4039 		/* Can't reset 160xxx or it will trash Demod tristate */
4040 		return pvr2_issue_simple_cmd(hdw,
4041 					     FX2CMD_HCW_MAKO_SLEEP_PIN |
4042 					     (1 << 8) |
4043 					     ((onoff ? 1 : 0) << 16));
4044 	}
4045 
4046 	return pvr2_issue_simple_cmd(hdw,
4047 				     FX2CMD_HCW_DEMOD_RESETIN |
4048 				     (1 << 8) |
4049 				     ((onoff ? 1 : 0) << 16));
4050 }
4051 
4052 
4053 static int pvr2_hdw_cmd_onair_fe_power_ctrl(struct pvr2_hdw *hdw, int onoff)
4054 {
4055 	hdw->flag_ok = !0;
4056 	return pvr2_issue_simple_cmd(hdw,(onoff ?
4057 					  FX2CMD_ONAIR_DTV_POWER_ON :
4058 					  FX2CMD_ONAIR_DTV_POWER_OFF));
4059 }
4060 
4061 
4062 static int pvr2_hdw_cmd_onair_digital_path_ctrl(struct pvr2_hdw *hdw,
4063 						int onoff)
4064 {
4065 	return pvr2_issue_simple_cmd(hdw,(onoff ?
4066 					  FX2CMD_ONAIR_DTV_STREAMING_ON :
4067 					  FX2CMD_ONAIR_DTV_STREAMING_OFF));
4068 }
4069 
4070 
4071 static void pvr2_hdw_cmd_modeswitch(struct pvr2_hdw *hdw,int digitalFl)
4072 {
4073 	int cmode;
4074 	/* Compare digital/analog desired setting with current setting.  If
4075 	   they don't match, fix it... */
4076 	cmode = (digitalFl ? PVR2_PATHWAY_DIGITAL : PVR2_PATHWAY_ANALOG);
4077 	if (cmode == hdw->pathway_state) {
4078 		/* They match; nothing to do */
4079 		return;
4080 	}
4081 
4082 	switch (hdw->hdw_desc->digital_control_scheme) {
4083 	case PVR2_DIGITAL_SCHEME_HAUPPAUGE:
4084 		pvr2_hdw_cmd_hcw_demod_reset(hdw,digitalFl);
4085 		if (cmode == PVR2_PATHWAY_ANALOG) {
4086 			/* If moving to analog mode, also force the decoder
4087 			   to reset.  If no decoder is attached, then it's
4088 			   ok to ignore this because if/when the decoder
4089 			   attaches, it will reset itself at that time. */
4090 			pvr2_hdw_cmd_decoder_reset(hdw);
4091 		}
4092 		break;
4093 	case PVR2_DIGITAL_SCHEME_ONAIR:
4094 		/* Supposedly we should always have the power on whether in
4095 		   digital or analog mode.  But for now do what appears to
4096 		   work... */
4097 		pvr2_hdw_cmd_onair_fe_power_ctrl(hdw,digitalFl);
4098 		break;
4099 	default: break;
4100 	}
4101 
4102 	pvr2_hdw_untrip_unlocked(hdw);
4103 	hdw->pathway_state = cmode;
4104 }
4105 
4106 
4107 static void pvr2_led_ctrl_hauppauge(struct pvr2_hdw *hdw, int onoff)
4108 {
4109 	/* change some GPIO data
4110 	 *
4111 	 * note: bit d7 of dir appears to control the LED,
4112 	 * so we shut it off here.
4113 	 *
4114 	 */
4115 	if (onoff) {
4116 		pvr2_hdw_gpio_chg_dir(hdw, 0xffffffff, 0x00000481);
4117 	} else {
4118 		pvr2_hdw_gpio_chg_dir(hdw, 0xffffffff, 0x00000401);
4119 	}
4120 	pvr2_hdw_gpio_chg_out(hdw, 0xffffffff, 0x00000000);
4121 }
4122 
4123 
4124 typedef void (*led_method_func)(struct pvr2_hdw *,int);
4125 
4126 static led_method_func led_methods[] = {
4127 	[PVR2_LED_SCHEME_HAUPPAUGE] = pvr2_led_ctrl_hauppauge,
4128 };
4129 
4130 
4131 /* Toggle LED */
4132 static void pvr2_led_ctrl(struct pvr2_hdw *hdw,int onoff)
4133 {
4134 	unsigned int scheme_id;
4135 	led_method_func fp;
4136 
4137 	if ((!onoff) == (!hdw->led_on)) return;
4138 
4139 	hdw->led_on = onoff != 0;
4140 
4141 	scheme_id = hdw->hdw_desc->led_scheme;
4142 	if (scheme_id < ARRAY_SIZE(led_methods)) {
4143 		fp = led_methods[scheme_id];
4144 	} else {
4145 		fp = NULL;
4146 	}
4147 
4148 	if (fp) (*fp)(hdw,onoff);
4149 }
4150 
4151 
4152 /* Stop / start video stream transport */
4153 static int pvr2_hdw_cmd_usbstream(struct pvr2_hdw *hdw,int runFl)
4154 {
4155 	int ret;
4156 
4157 	/* If we're in analog mode, then just issue the usual analog
4158 	   command. */
4159 	if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
4160 		return pvr2_issue_simple_cmd(hdw,
4161 					     (runFl ?
4162 					      FX2CMD_STREAMING_ON :
4163 					      FX2CMD_STREAMING_OFF));
4164 		/*Note: Not reached */
4165 	}
4166 
4167 	if (hdw->pathway_state != PVR2_PATHWAY_DIGITAL) {
4168 		/* Whoops, we don't know what mode we're in... */
4169 		return -EINVAL;
4170 	}
4171 
4172 	/* To get here we have to be in digital mode.  The mechanism here
4173 	   is unfortunately different for different vendors.  So we switch
4174 	   on the device's digital scheme attribute in order to figure out
4175 	   what to do. */
4176 	switch (hdw->hdw_desc->digital_control_scheme) {
4177 	case PVR2_DIGITAL_SCHEME_HAUPPAUGE:
4178 		return pvr2_issue_simple_cmd(hdw,
4179 					     (runFl ?
4180 					      FX2CMD_HCW_DTV_STREAMING_ON :
4181 					      FX2CMD_HCW_DTV_STREAMING_OFF));
4182 	case PVR2_DIGITAL_SCHEME_ONAIR:
4183 		ret = pvr2_issue_simple_cmd(hdw,
4184 					    (runFl ?
4185 					     FX2CMD_STREAMING_ON :
4186 					     FX2CMD_STREAMING_OFF));
4187 		if (ret) return ret;
4188 		return pvr2_hdw_cmd_onair_digital_path_ctrl(hdw,runFl);
4189 	default:
4190 		return -EINVAL;
4191 	}
4192 }
4193 
4194 
4195 /* Evaluate whether or not state_pathway_ok can change */
4196 static int state_eval_pathway_ok(struct pvr2_hdw *hdw)
4197 {
4198 	if (hdw->state_pathway_ok) {
4199 		/* Nothing to do if pathway is already ok */
4200 		return 0;
4201 	}
4202 	if (!hdw->state_pipeline_idle) {
4203 		/* Not allowed to change anything if pipeline is not idle */
4204 		return 0;
4205 	}
4206 	pvr2_hdw_cmd_modeswitch(hdw,hdw->input_val == PVR2_CVAL_INPUT_DTV);
4207 	hdw->state_pathway_ok = !0;
4208 	trace_stbit("state_pathway_ok",hdw->state_pathway_ok);
4209 	return !0;
4210 }
4211 
4212 
4213 /* Evaluate whether or not state_encoder_ok can change */
4214 static int state_eval_encoder_ok(struct pvr2_hdw *hdw)
4215 {
4216 	if (hdw->state_encoder_ok) return 0;
4217 	if (hdw->flag_tripped) return 0;
4218 	if (hdw->state_encoder_run) return 0;
4219 	if (hdw->state_encoder_config) return 0;
4220 	if (hdw->state_decoder_run) return 0;
4221 	if (hdw->state_usbstream_run) return 0;
4222 	if (hdw->pathway_state == PVR2_PATHWAY_DIGITAL) {
4223 		if (!hdw->hdw_desc->flag_digital_requires_cx23416) return 0;
4224 	} else if (hdw->pathway_state != PVR2_PATHWAY_ANALOG) {
4225 		return 0;
4226 	}
4227 
4228 	if (pvr2_upload_firmware2(hdw) < 0) {
4229 		hdw->flag_tripped = !0;
4230 		trace_stbit("flag_tripped",hdw->flag_tripped);
4231 		return !0;
4232 	}
4233 	hdw->state_encoder_ok = !0;
4234 	trace_stbit("state_encoder_ok",hdw->state_encoder_ok);
4235 	return !0;
4236 }
4237 
4238 
4239 /* Evaluate whether or not state_encoder_config can change */
4240 static int state_eval_encoder_config(struct pvr2_hdw *hdw)
4241 {
4242 	if (hdw->state_encoder_config) {
4243 		if (hdw->state_encoder_ok) {
4244 			if (hdw->state_pipeline_req &&
4245 			    !hdw->state_pipeline_pause) return 0;
4246 		}
4247 		hdw->state_encoder_config = 0;
4248 		hdw->state_encoder_waitok = 0;
4249 		trace_stbit("state_encoder_waitok",hdw->state_encoder_waitok);
4250 		/* paranoia - solve race if timer just completed */
4251 		del_timer_sync(&hdw->encoder_wait_timer);
4252 	} else {
4253 		if (!hdw->state_pathway_ok ||
4254 		    (hdw->pathway_state != PVR2_PATHWAY_ANALOG) ||
4255 		    !hdw->state_encoder_ok ||
4256 		    !hdw->state_pipeline_idle ||
4257 		    hdw->state_pipeline_pause ||
4258 		    !hdw->state_pipeline_req ||
4259 		    !hdw->state_pipeline_config) {
4260 			/* We must reset the enforced wait interval if
4261 			   anything has happened that might have disturbed
4262 			   the encoder.  This should be a rare case. */
4263 			if (timer_pending(&hdw->encoder_wait_timer)) {
4264 				del_timer_sync(&hdw->encoder_wait_timer);
4265 			}
4266 			if (hdw->state_encoder_waitok) {
4267 				/* Must clear the state - therefore we did
4268 				   something to a state bit and must also
4269 				   return true. */
4270 				hdw->state_encoder_waitok = 0;
4271 				trace_stbit("state_encoder_waitok",
4272 					    hdw->state_encoder_waitok);
4273 				return !0;
4274 			}
4275 			return 0;
4276 		}
4277 		if (!hdw->state_encoder_waitok) {
4278 			if (!timer_pending(&hdw->encoder_wait_timer)) {
4279 				/* waitok flag wasn't set and timer isn't
4280 				   running.  Check flag once more to avoid
4281 				   a race then start the timer.  This is
4282 				   the point when we measure out a minimal
4283 				   quiet interval before doing something to
4284 				   the encoder. */
4285 				if (!hdw->state_encoder_waitok) {
4286 					hdw->encoder_wait_timer.expires =
4287 						jiffies + msecs_to_jiffies(
4288 						TIME_MSEC_ENCODER_WAIT);
4289 					add_timer(&hdw->encoder_wait_timer);
4290 				}
4291 			}
4292 			/* We can't continue until we know we have been
4293 			   quiet for the interval measured by this
4294 			   timer. */
4295 			return 0;
4296 		}
4297 		pvr2_encoder_configure(hdw);
4298 		if (hdw->state_encoder_ok) hdw->state_encoder_config = !0;
4299 	}
4300 	trace_stbit("state_encoder_config",hdw->state_encoder_config);
4301 	return !0;
4302 }
4303 
4304 
4305 /* Return true if the encoder should not be running. */
4306 static int state_check_disable_encoder_run(struct pvr2_hdw *hdw)
4307 {
4308 	if (!hdw->state_encoder_ok) {
4309 		/* Encoder isn't healthy at the moment, so stop it. */
4310 		return !0;
4311 	}
4312 	if (!hdw->state_pathway_ok) {
4313 		/* Mode is not understood at the moment (i.e. it wants to
4314 		   change), so encoder must be stopped. */
4315 		return !0;
4316 	}
4317 
4318 	switch (hdw->pathway_state) {
4319 	case PVR2_PATHWAY_ANALOG:
4320 		if (!hdw->state_decoder_run) {
4321 			/* We're in analog mode and the decoder is not
4322 			   running; thus the encoder should be stopped as
4323 			   well. */
4324 			return !0;
4325 		}
4326 		break;
4327 	case PVR2_PATHWAY_DIGITAL:
4328 		if (hdw->state_encoder_runok) {
4329 			/* This is a funny case.  We're in digital mode so
4330 			   really the encoder should be stopped.  However
4331 			   if it really is running, only kill it after
4332 			   runok has been set.  This gives a chance for the
4333 			   onair quirk to function (encoder must run
4334 			   briefly first, at least once, before onair
4335 			   digital streaming can work). */
4336 			return !0;
4337 		}
4338 		break;
4339 	default:
4340 		/* Unknown mode; so encoder should be stopped. */
4341 		return !0;
4342 	}
4343 
4344 	/* If we get here, we haven't found a reason to stop the
4345 	   encoder. */
4346 	return 0;
4347 }
4348 
4349 
4350 /* Return true if the encoder should be running. */
4351 static int state_check_enable_encoder_run(struct pvr2_hdw *hdw)
4352 {
4353 	if (!hdw->state_encoder_ok) {
4354 		/* Don't run the encoder if it isn't healthy... */
4355 		return 0;
4356 	}
4357 	if (!hdw->state_pathway_ok) {
4358 		/* Don't run the encoder if we don't (yet) know what mode
4359 		   we need to be in... */
4360 		return 0;
4361 	}
4362 
4363 	switch (hdw->pathway_state) {
4364 	case PVR2_PATHWAY_ANALOG:
4365 		if (hdw->state_decoder_run && hdw->state_decoder_ready) {
4366 			/* In analog mode, if the decoder is running, then
4367 			   run the encoder. */
4368 			return !0;
4369 		}
4370 		break;
4371 	case PVR2_PATHWAY_DIGITAL:
4372 		if ((hdw->hdw_desc->digital_control_scheme ==
4373 		     PVR2_DIGITAL_SCHEME_ONAIR) &&
4374 		    !hdw->state_encoder_runok) {
4375 			/* This is a quirk.  OnAir hardware won't stream
4376 			   digital until the encoder has been run at least
4377 			   once, for a minimal period of time (empiricially
4378 			   measured to be 1/4 second).  So if we're on
4379 			   OnAir hardware and the encoder has never been
4380 			   run at all, then start the encoder.  Normal
4381 			   state machine logic in the driver will
4382 			   automatically handle the remaining bits. */
4383 			return !0;
4384 		}
4385 		break;
4386 	default:
4387 		/* For completeness (unknown mode; encoder won't run ever) */
4388 		break;
4389 	}
4390 	/* If we get here, then we haven't found any reason to run the
4391 	   encoder, so don't run it. */
4392 	return 0;
4393 }
4394 
4395 
4396 /* Evaluate whether or not state_encoder_run can change */
4397 static int state_eval_encoder_run(struct pvr2_hdw *hdw)
4398 {
4399 	if (hdw->state_encoder_run) {
4400 		if (!state_check_disable_encoder_run(hdw)) return 0;
4401 		if (hdw->state_encoder_ok) {
4402 			del_timer_sync(&hdw->encoder_run_timer);
4403 			if (pvr2_encoder_stop(hdw) < 0) return !0;
4404 		}
4405 		hdw->state_encoder_run = 0;
4406 	} else {
4407 		if (!state_check_enable_encoder_run(hdw)) return 0;
4408 		if (pvr2_encoder_start(hdw) < 0) return !0;
4409 		hdw->state_encoder_run = !0;
4410 		if (!hdw->state_encoder_runok) {
4411 			hdw->encoder_run_timer.expires = jiffies +
4412 				 msecs_to_jiffies(TIME_MSEC_ENCODER_OK);
4413 			add_timer(&hdw->encoder_run_timer);
4414 		}
4415 	}
4416 	trace_stbit("state_encoder_run",hdw->state_encoder_run);
4417 	return !0;
4418 }
4419 
4420 
4421 /* Timeout function for quiescent timer. */
4422 static void pvr2_hdw_quiescent_timeout(struct timer_list *t)
4423 {
4424 	struct pvr2_hdw *hdw = from_timer(hdw, t, quiescent_timer);
4425 	hdw->state_decoder_quiescent = !0;
4426 	trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent);
4427 	hdw->state_stale = !0;
4428 	schedule_work(&hdw->workpoll);
4429 }
4430 
4431 
4432 /* Timeout function for decoder stabilization timer. */
4433 static void pvr2_hdw_decoder_stabilization_timeout(struct timer_list *t)
4434 {
4435 	struct pvr2_hdw *hdw = from_timer(hdw, t, decoder_stabilization_timer);
4436 	hdw->state_decoder_ready = !0;
4437 	trace_stbit("state_decoder_ready", hdw->state_decoder_ready);
4438 	hdw->state_stale = !0;
4439 	schedule_work(&hdw->workpoll);
4440 }
4441 
4442 
4443 /* Timeout function for encoder wait timer. */
4444 static void pvr2_hdw_encoder_wait_timeout(struct timer_list *t)
4445 {
4446 	struct pvr2_hdw *hdw = from_timer(hdw, t, encoder_wait_timer);
4447 	hdw->state_encoder_waitok = !0;
4448 	trace_stbit("state_encoder_waitok",hdw->state_encoder_waitok);
4449 	hdw->state_stale = !0;
4450 	schedule_work(&hdw->workpoll);
4451 }
4452 
4453 
4454 /* Timeout function for encoder run timer. */
4455 static void pvr2_hdw_encoder_run_timeout(struct timer_list *t)
4456 {
4457 	struct pvr2_hdw *hdw = from_timer(hdw, t, encoder_run_timer);
4458 	if (!hdw->state_encoder_runok) {
4459 		hdw->state_encoder_runok = !0;
4460 		trace_stbit("state_encoder_runok",hdw->state_encoder_runok);
4461 		hdw->state_stale = !0;
4462 		schedule_work(&hdw->workpoll);
4463 	}
4464 }
4465 
4466 
4467 /* Evaluate whether or not state_decoder_run can change */
4468 static int state_eval_decoder_run(struct pvr2_hdw *hdw)
4469 {
4470 	if (hdw->state_decoder_run) {
4471 		if (hdw->state_encoder_ok) {
4472 			if (hdw->state_pipeline_req &&
4473 			    !hdw->state_pipeline_pause &&
4474 			    hdw->state_pathway_ok) return 0;
4475 		}
4476 		if (!hdw->flag_decoder_missed) {
4477 			pvr2_decoder_enable(hdw,0);
4478 		}
4479 		hdw->state_decoder_quiescent = 0;
4480 		hdw->state_decoder_run = 0;
4481 		/* paranoia - solve race if timer(s) just completed */
4482 		del_timer_sync(&hdw->quiescent_timer);
4483 		/* Kill the stabilization timer, in case we're killing the
4484 		   encoder before the previous stabilization interval has
4485 		   been properly timed. */
4486 		del_timer_sync(&hdw->decoder_stabilization_timer);
4487 		hdw->state_decoder_ready = 0;
4488 	} else {
4489 		if (!hdw->state_decoder_quiescent) {
4490 			if (!timer_pending(&hdw->quiescent_timer)) {
4491 				/* We don't do something about the
4492 				   quiescent timer until right here because
4493 				   we also want to catch cases where the
4494 				   decoder was already not running (like
4495 				   after initialization) as opposed to
4496 				   knowing that we had just stopped it.
4497 				   The second flag check is here to cover a
4498 				   race - the timer could have run and set
4499 				   this flag just after the previous check
4500 				   but before we did the pending check. */
4501 				if (!hdw->state_decoder_quiescent) {
4502 					hdw->quiescent_timer.expires =
4503 						jiffies + msecs_to_jiffies(
4504 						TIME_MSEC_DECODER_WAIT);
4505 					add_timer(&hdw->quiescent_timer);
4506 				}
4507 			}
4508 			/* Don't allow decoder to start again until it has
4509 			   been quiesced first.  This little detail should
4510 			   hopefully further stabilize the encoder. */
4511 			return 0;
4512 		}
4513 		if (!hdw->state_pathway_ok ||
4514 		    (hdw->pathway_state != PVR2_PATHWAY_ANALOG) ||
4515 		    !hdw->state_pipeline_req ||
4516 		    hdw->state_pipeline_pause ||
4517 		    !hdw->state_pipeline_config ||
4518 		    !hdw->state_encoder_config ||
4519 		    !hdw->state_encoder_ok) return 0;
4520 		del_timer_sync(&hdw->quiescent_timer);
4521 		if (hdw->flag_decoder_missed) return 0;
4522 		if (pvr2_decoder_enable(hdw,!0) < 0) return 0;
4523 		hdw->state_decoder_quiescent = 0;
4524 		hdw->state_decoder_ready = 0;
4525 		hdw->state_decoder_run = !0;
4526 		if (hdw->decoder_client_id == PVR2_CLIENT_ID_SAA7115) {
4527 			hdw->decoder_stabilization_timer.expires =
4528 				jiffies + msecs_to_jiffies(
4529 				TIME_MSEC_DECODER_STABILIZATION_WAIT);
4530 			add_timer(&hdw->decoder_stabilization_timer);
4531 		} else {
4532 			hdw->state_decoder_ready = !0;
4533 		}
4534 	}
4535 	trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent);
4536 	trace_stbit("state_decoder_run",hdw->state_decoder_run);
4537 	trace_stbit("state_decoder_ready", hdw->state_decoder_ready);
4538 	return !0;
4539 }
4540 
4541 
4542 /* Evaluate whether or not state_usbstream_run can change */
4543 static int state_eval_usbstream_run(struct pvr2_hdw *hdw)
4544 {
4545 	if (hdw->state_usbstream_run) {
4546 		int fl = !0;
4547 		if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
4548 			fl = (hdw->state_encoder_ok &&
4549 			      hdw->state_encoder_run);
4550 		} else if ((hdw->pathway_state == PVR2_PATHWAY_DIGITAL) &&
4551 			   (hdw->hdw_desc->flag_digital_requires_cx23416)) {
4552 			fl = hdw->state_encoder_ok;
4553 		}
4554 		if (fl &&
4555 		    hdw->state_pipeline_req &&
4556 		    !hdw->state_pipeline_pause &&
4557 		    hdw->state_pathway_ok) {
4558 			return 0;
4559 		}
4560 		pvr2_hdw_cmd_usbstream(hdw,0);
4561 		hdw->state_usbstream_run = 0;
4562 	} else {
4563 		if (!hdw->state_pipeline_req ||
4564 		    hdw->state_pipeline_pause ||
4565 		    !hdw->state_pathway_ok) return 0;
4566 		if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
4567 			if (!hdw->state_encoder_ok ||
4568 			    !hdw->state_encoder_run) return 0;
4569 		} else if ((hdw->pathway_state == PVR2_PATHWAY_DIGITAL) &&
4570 			   (hdw->hdw_desc->flag_digital_requires_cx23416)) {
4571 			if (!hdw->state_encoder_ok) return 0;
4572 			if (hdw->state_encoder_run) return 0;
4573 			if (hdw->hdw_desc->digital_control_scheme ==
4574 			    PVR2_DIGITAL_SCHEME_ONAIR) {
4575 				/* OnAir digital receivers won't stream
4576 				   unless the analog encoder has run first.
4577 				   Why?  I have no idea.  But don't even
4578 				   try until we know the analog side is
4579 				   known to have run. */
4580 				if (!hdw->state_encoder_runok) return 0;
4581 			}
4582 		}
4583 		if (pvr2_hdw_cmd_usbstream(hdw,!0) < 0) return 0;
4584 		hdw->state_usbstream_run = !0;
4585 	}
4586 	trace_stbit("state_usbstream_run",hdw->state_usbstream_run);
4587 	return !0;
4588 }
4589 
4590 
4591 /* Attempt to configure pipeline, if needed */
4592 static int state_eval_pipeline_config(struct pvr2_hdw *hdw)
4593 {
4594 	if (hdw->state_pipeline_config ||
4595 	    hdw->state_pipeline_pause) return 0;
4596 	pvr2_hdw_commit_execute(hdw);
4597 	return !0;
4598 }
4599 
4600 
4601 /* Update pipeline idle and pipeline pause tracking states based on other
4602    inputs.  This must be called whenever the other relevant inputs have
4603    changed. */
4604 static int state_update_pipeline_state(struct pvr2_hdw *hdw)
4605 {
4606 	unsigned int st;
4607 	int updatedFl = 0;
4608 	/* Update pipeline state */
4609 	st = !(hdw->state_encoder_run ||
4610 	       hdw->state_decoder_run ||
4611 	       hdw->state_usbstream_run ||
4612 	       (!hdw->state_decoder_quiescent));
4613 	if (!st != !hdw->state_pipeline_idle) {
4614 		hdw->state_pipeline_idle = st;
4615 		updatedFl = !0;
4616 	}
4617 	if (hdw->state_pipeline_idle && hdw->state_pipeline_pause) {
4618 		hdw->state_pipeline_pause = 0;
4619 		updatedFl = !0;
4620 	}
4621 	return updatedFl;
4622 }
4623 
4624 
4625 typedef int (*state_eval_func)(struct pvr2_hdw *);
4626 
4627 /* Set of functions to be run to evaluate various states in the driver. */
4628 static const state_eval_func eval_funcs[] = {
4629 	state_eval_pathway_ok,
4630 	state_eval_pipeline_config,
4631 	state_eval_encoder_ok,
4632 	state_eval_encoder_config,
4633 	state_eval_decoder_run,
4634 	state_eval_encoder_run,
4635 	state_eval_usbstream_run,
4636 };
4637 
4638 
4639 /* Process various states and return true if we did anything interesting. */
4640 static int pvr2_hdw_state_update(struct pvr2_hdw *hdw)
4641 {
4642 	unsigned int i;
4643 	int state_updated = 0;
4644 	int check_flag;
4645 
4646 	if (!hdw->state_stale) return 0;
4647 	if ((hdw->fw1_state != FW1_STATE_OK) ||
4648 	    !hdw->flag_ok) {
4649 		hdw->state_stale = 0;
4650 		return !0;
4651 	}
4652 	/* This loop is the heart of the entire driver.  It keeps trying to
4653 	   evaluate various bits of driver state until nothing changes for
4654 	   one full iteration.  Each "bit of state" tracks some global
4655 	   aspect of the driver, e.g. whether decoder should run, if
4656 	   pipeline is configured, usb streaming is on, etc.  We separately
4657 	   evaluate each of those questions based on other driver state to
4658 	   arrive at the correct running configuration. */
4659 	do {
4660 		check_flag = 0;
4661 		state_update_pipeline_state(hdw);
4662 		/* Iterate over each bit of state */
4663 		for (i = 0; (i<ARRAY_SIZE(eval_funcs)) && hdw->flag_ok; i++) {
4664 			if ((*eval_funcs[i])(hdw)) {
4665 				check_flag = !0;
4666 				state_updated = !0;
4667 				state_update_pipeline_state(hdw);
4668 			}
4669 		}
4670 	} while (check_flag && hdw->flag_ok);
4671 	hdw->state_stale = 0;
4672 	trace_stbit("state_stale",hdw->state_stale);
4673 	return state_updated;
4674 }
4675 
4676 
4677 static unsigned int print_input_mask(unsigned int msk,
4678 				     char *buf,unsigned int acnt)
4679 {
4680 	unsigned int idx,ccnt;
4681 	unsigned int tcnt = 0;
4682 	for (idx = 0; idx < ARRAY_SIZE(control_values_input); idx++) {
4683 		if (!((1UL << idx) & msk)) continue;
4684 		ccnt = scnprintf(buf+tcnt,
4685 				 acnt-tcnt,
4686 				 "%s%s",
4687 				 (tcnt ? ", " : ""),
4688 				 control_values_input[idx]);
4689 		tcnt += ccnt;
4690 	}
4691 	return tcnt;
4692 }
4693 
4694 
4695 static const char *pvr2_pathway_state_name(int id)
4696 {
4697 	switch (id) {
4698 	case PVR2_PATHWAY_ANALOG: return "analog";
4699 	case PVR2_PATHWAY_DIGITAL: return "digital";
4700 	default: return "unknown";
4701 	}
4702 }
4703 
4704 
4705 static unsigned int pvr2_hdw_report_unlocked(struct pvr2_hdw *hdw,int which,
4706 					     char *buf,unsigned int acnt)
4707 {
4708 	switch (which) {
4709 	case 0:
4710 		return scnprintf(
4711 			buf,acnt,
4712 			"driver:%s%s%s%s%s <mode=%s>",
4713 			(hdw->flag_ok ? " <ok>" : " <fail>"),
4714 			(hdw->flag_init_ok ? " <init>" : " <uninitialized>"),
4715 			(hdw->flag_disconnected ? " <disconnected>" :
4716 			 " <connected>"),
4717 			(hdw->flag_tripped ? " <tripped>" : ""),
4718 			(hdw->flag_decoder_missed ? " <no decoder>" : ""),
4719 			pvr2_pathway_state_name(hdw->pathway_state));
4720 
4721 	case 1:
4722 		return scnprintf(
4723 			buf,acnt,
4724 			"pipeline:%s%s%s%s",
4725 			(hdw->state_pipeline_idle ? " <idle>" : ""),
4726 			(hdw->state_pipeline_config ?
4727 			 " <configok>" : " <stale>"),
4728 			(hdw->state_pipeline_req ? " <req>" : ""),
4729 			(hdw->state_pipeline_pause ? " <pause>" : ""));
4730 	case 2:
4731 		return scnprintf(
4732 			buf,acnt,
4733 			"worker:%s%s%s%s%s%s%s",
4734 			(hdw->state_decoder_run ?
4735 			 (hdw->state_decoder_ready ?
4736 			  "<decode:run>" : " <decode:start>") :
4737 			 (hdw->state_decoder_quiescent ?
4738 			  "" : " <decode:stop>")),
4739 			(hdw->state_decoder_quiescent ?
4740 			 " <decode:quiescent>" : ""),
4741 			(hdw->state_encoder_ok ?
4742 			 "" : " <encode:init>"),
4743 			(hdw->state_encoder_run ?
4744 			 (hdw->state_encoder_runok ?
4745 			  " <encode:run>" :
4746 			  " <encode:firstrun>") :
4747 			 (hdw->state_encoder_runok ?
4748 			  " <encode:stop>" :
4749 			  " <encode:virgin>")),
4750 			(hdw->state_encoder_config ?
4751 			 " <encode:configok>" :
4752 			 (hdw->state_encoder_waitok ?
4753 			  "" : " <encode:waitok>")),
4754 			(hdw->state_usbstream_run ?
4755 			 " <usb:run>" : " <usb:stop>"),
4756 			(hdw->state_pathway_ok ?
4757 			 " <pathway:ok>" : ""));
4758 	case 3:
4759 		return scnprintf(
4760 			buf,acnt,
4761 			"state: %s",
4762 			pvr2_get_state_name(hdw->master_state));
4763 	case 4: {
4764 		unsigned int tcnt = 0;
4765 		unsigned int ccnt;
4766 
4767 		ccnt = scnprintf(buf,
4768 				 acnt,
4769 				 "Hardware supported inputs: ");
4770 		tcnt += ccnt;
4771 		tcnt += print_input_mask(hdw->input_avail_mask,
4772 					 buf+tcnt,
4773 					 acnt-tcnt);
4774 		if (hdw->input_avail_mask != hdw->input_allowed_mask) {
4775 			ccnt = scnprintf(buf+tcnt,
4776 					 acnt-tcnt,
4777 					 "; allowed inputs: ");
4778 			tcnt += ccnt;
4779 			tcnt += print_input_mask(hdw->input_allowed_mask,
4780 						 buf+tcnt,
4781 						 acnt-tcnt);
4782 		}
4783 		return tcnt;
4784 	}
4785 	case 5: {
4786 		struct pvr2_stream_stats stats;
4787 		if (!hdw->vid_stream) break;
4788 		pvr2_stream_get_stats(hdw->vid_stream,
4789 				      &stats,
4790 				      0);
4791 		return scnprintf(
4792 			buf,acnt,
4793 			"Bytes streamed=%u URBs: queued=%u idle=%u ready=%u processed=%u failed=%u",
4794 			stats.bytes_processed,
4795 			stats.buffers_in_queue,
4796 			stats.buffers_in_idle,
4797 			stats.buffers_in_ready,
4798 			stats.buffers_processed,
4799 			stats.buffers_failed);
4800 	}
4801 	case 6: {
4802 		unsigned int id = hdw->ir_scheme_active;
4803 		return scnprintf(buf, acnt, "ir scheme: id=%d %s", id,
4804 				 (id >= ARRAY_SIZE(ir_scheme_names) ?
4805 				  "?" : ir_scheme_names[id]));
4806 	}
4807 	default: break;
4808 	}
4809 	return 0;
4810 }
4811 
4812 
4813 /* Generate report containing info about attached sub-devices and attached
4814    i2c clients, including an indication of which attached i2c clients are
4815    actually sub-devices. */
4816 static unsigned int pvr2_hdw_report_clients(struct pvr2_hdw *hdw,
4817 					    char *buf, unsigned int acnt)
4818 {
4819 	struct v4l2_subdev *sd;
4820 	unsigned int tcnt = 0;
4821 	unsigned int ccnt;
4822 	struct i2c_client *client;
4823 	const char *p;
4824 	unsigned int id;
4825 
4826 	ccnt = scnprintf(buf, acnt, "Associated v4l2-subdev drivers and I2C clients:\n");
4827 	tcnt += ccnt;
4828 	v4l2_device_for_each_subdev(sd, &hdw->v4l2_dev) {
4829 		id = sd->grp_id;
4830 		p = NULL;
4831 		if (id < ARRAY_SIZE(module_names)) p = module_names[id];
4832 		if (p) {
4833 			ccnt = scnprintf(buf + tcnt, acnt - tcnt, "  %s:", p);
4834 			tcnt += ccnt;
4835 		} else {
4836 			ccnt = scnprintf(buf + tcnt, acnt - tcnt,
4837 					 "  (unknown id=%u):", id);
4838 			tcnt += ccnt;
4839 		}
4840 		client = v4l2_get_subdevdata(sd);
4841 		if (client) {
4842 			ccnt = scnprintf(buf + tcnt, acnt - tcnt,
4843 					 " %s @ %02x\n", client->name,
4844 					 client->addr);
4845 			tcnt += ccnt;
4846 		} else {
4847 			ccnt = scnprintf(buf + tcnt, acnt - tcnt,
4848 					 " no i2c client\n");
4849 			tcnt += ccnt;
4850 		}
4851 	}
4852 	return tcnt;
4853 }
4854 
4855 
4856 unsigned int pvr2_hdw_state_report(struct pvr2_hdw *hdw,
4857 				   char *buf,unsigned int acnt)
4858 {
4859 	unsigned int bcnt,ccnt,idx;
4860 	bcnt = 0;
4861 	LOCK_TAKE(hdw->big_lock);
4862 	for (idx = 0; ; idx++) {
4863 		ccnt = pvr2_hdw_report_unlocked(hdw,idx,buf,acnt);
4864 		if (!ccnt) break;
4865 		bcnt += ccnt; acnt -= ccnt; buf += ccnt;
4866 		if (!acnt) break;
4867 		buf[0] = '\n'; ccnt = 1;
4868 		bcnt += ccnt; acnt -= ccnt; buf += ccnt;
4869 	}
4870 	ccnt = pvr2_hdw_report_clients(hdw, buf, acnt);
4871 	bcnt += ccnt; acnt -= ccnt; buf += ccnt;
4872 	LOCK_GIVE(hdw->big_lock);
4873 	return bcnt;
4874 }
4875 
4876 
4877 static void pvr2_hdw_state_log_state(struct pvr2_hdw *hdw)
4878 {
4879 	char buf[256];
4880 	unsigned int idx, ccnt;
4881 	unsigned int lcnt, ucnt;
4882 
4883 	for (idx = 0; ; idx++) {
4884 		ccnt = pvr2_hdw_report_unlocked(hdw,idx,buf,sizeof(buf));
4885 		if (!ccnt) break;
4886 		pr_info("%s %.*s\n", hdw->name, ccnt, buf);
4887 	}
4888 	ccnt = pvr2_hdw_report_clients(hdw, buf, sizeof(buf));
4889 	if (ccnt >= sizeof(buf))
4890 		ccnt = sizeof(buf);
4891 
4892 	ucnt = 0;
4893 	while (ucnt < ccnt) {
4894 		lcnt = 0;
4895 		while ((lcnt + ucnt < ccnt) && (buf[lcnt + ucnt] != '\n')) {
4896 			lcnt++;
4897 		}
4898 		pr_info("%s %.*s\n", hdw->name, lcnt, buf + ucnt);
4899 		ucnt += lcnt + 1;
4900 	}
4901 }
4902 
4903 
4904 /* Evaluate and update the driver's current state, taking various actions
4905    as appropriate for the update. */
4906 static int pvr2_hdw_state_eval(struct pvr2_hdw *hdw)
4907 {
4908 	unsigned int st;
4909 	int state_updated = 0;
4910 	int callback_flag = 0;
4911 	int analog_mode;
4912 
4913 	pvr2_trace(PVR2_TRACE_STBITS,
4914 		   "Drive state check START");
4915 	if (pvrusb2_debug & PVR2_TRACE_STBITS) {
4916 		pvr2_hdw_state_log_state(hdw);
4917 	}
4918 
4919 	/* Process all state and get back over disposition */
4920 	state_updated = pvr2_hdw_state_update(hdw);
4921 
4922 	analog_mode = (hdw->pathway_state != PVR2_PATHWAY_DIGITAL);
4923 
4924 	/* Update master state based upon all other states. */
4925 	if (!hdw->flag_ok) {
4926 		st = PVR2_STATE_DEAD;
4927 	} else if (hdw->fw1_state != FW1_STATE_OK) {
4928 		st = PVR2_STATE_COLD;
4929 	} else if ((analog_mode ||
4930 		    hdw->hdw_desc->flag_digital_requires_cx23416) &&
4931 		   !hdw->state_encoder_ok) {
4932 		st = PVR2_STATE_WARM;
4933 	} else if (hdw->flag_tripped ||
4934 		   (analog_mode && hdw->flag_decoder_missed)) {
4935 		st = PVR2_STATE_ERROR;
4936 	} else if (hdw->state_usbstream_run &&
4937 		   (!analog_mode ||
4938 		    (hdw->state_encoder_run && hdw->state_decoder_run))) {
4939 		st = PVR2_STATE_RUN;
4940 	} else {
4941 		st = PVR2_STATE_READY;
4942 	}
4943 	if (hdw->master_state != st) {
4944 		pvr2_trace(PVR2_TRACE_STATE,
4945 			   "Device state change from %s to %s",
4946 			   pvr2_get_state_name(hdw->master_state),
4947 			   pvr2_get_state_name(st));
4948 		pvr2_led_ctrl(hdw,st == PVR2_STATE_RUN);
4949 		hdw->master_state = st;
4950 		state_updated = !0;
4951 		callback_flag = !0;
4952 	}
4953 	if (state_updated) {
4954 		/* Trigger anyone waiting on any state changes here. */
4955 		wake_up(&hdw->state_wait_data);
4956 	}
4957 
4958 	if (pvrusb2_debug & PVR2_TRACE_STBITS) {
4959 		pvr2_hdw_state_log_state(hdw);
4960 	}
4961 	pvr2_trace(PVR2_TRACE_STBITS,
4962 		   "Drive state check DONE callback=%d",callback_flag);
4963 
4964 	return callback_flag;
4965 }
4966 
4967 
4968 /* Cause kernel thread to check / update driver state */
4969 static void pvr2_hdw_state_sched(struct pvr2_hdw *hdw)
4970 {
4971 	if (hdw->state_stale) return;
4972 	hdw->state_stale = !0;
4973 	trace_stbit("state_stale",hdw->state_stale);
4974 	schedule_work(&hdw->workpoll);
4975 }
4976 
4977 
4978 int pvr2_hdw_gpio_get_dir(struct pvr2_hdw *hdw,u32 *dp)
4979 {
4980 	return pvr2_read_register(hdw,PVR2_GPIO_DIR,dp);
4981 }
4982 
4983 
4984 int pvr2_hdw_gpio_get_out(struct pvr2_hdw *hdw,u32 *dp)
4985 {
4986 	return pvr2_read_register(hdw,PVR2_GPIO_OUT,dp);
4987 }
4988 
4989 
4990 int pvr2_hdw_gpio_get_in(struct pvr2_hdw *hdw,u32 *dp)
4991 {
4992 	return pvr2_read_register(hdw,PVR2_GPIO_IN,dp);
4993 }
4994 
4995 
4996 int pvr2_hdw_gpio_chg_dir(struct pvr2_hdw *hdw,u32 msk,u32 val)
4997 {
4998 	u32 cval,nval;
4999 	int ret;
5000 	if (~msk) {
5001 		ret = pvr2_read_register(hdw,PVR2_GPIO_DIR,&cval);
5002 		if (ret) return ret;
5003 		nval = (cval & ~msk) | (val & msk);
5004 		pvr2_trace(PVR2_TRACE_GPIO,
5005 			   "GPIO direction changing 0x%x:0x%x from 0x%x to 0x%x",
5006 			   msk,val,cval,nval);
5007 	} else {
5008 		nval = val;
5009 		pvr2_trace(PVR2_TRACE_GPIO,
5010 			   "GPIO direction changing to 0x%x",nval);
5011 	}
5012 	return pvr2_write_register(hdw,PVR2_GPIO_DIR,nval);
5013 }
5014 
5015 
5016 int pvr2_hdw_gpio_chg_out(struct pvr2_hdw *hdw,u32 msk,u32 val)
5017 {
5018 	u32 cval,nval;
5019 	int ret;
5020 	if (~msk) {
5021 		ret = pvr2_read_register(hdw,PVR2_GPIO_OUT,&cval);
5022 		if (ret) return ret;
5023 		nval = (cval & ~msk) | (val & msk);
5024 		pvr2_trace(PVR2_TRACE_GPIO,
5025 			   "GPIO output changing 0x%x:0x%x from 0x%x to 0x%x",
5026 			   msk,val,cval,nval);
5027 	} else {
5028 		nval = val;
5029 		pvr2_trace(PVR2_TRACE_GPIO,
5030 			   "GPIO output changing to 0x%x",nval);
5031 	}
5032 	return pvr2_write_register(hdw,PVR2_GPIO_OUT,nval);
5033 }
5034 
5035 
5036 void pvr2_hdw_status_poll(struct pvr2_hdw *hdw)
5037 {
5038 	struct v4l2_tuner *vtp = &hdw->tuner_signal_info;
5039 	memset(vtp, 0, sizeof(*vtp));
5040 	vtp->type = (hdw->input_val == PVR2_CVAL_INPUT_RADIO) ?
5041 		V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
5042 	hdw->tuner_signal_stale = 0;
5043 	/* Note: There apparently is no replacement for VIDIOC_CROPCAP
5044 	   using v4l2-subdev - therefore we can't support that AT ALL right
5045 	   now.  (Of course, no sub-drivers seem to implement it either.
5046 	   But now it's a chicken and egg problem...) */
5047 	v4l2_device_call_all(&hdw->v4l2_dev, 0, tuner, g_tuner, vtp);
5048 	pvr2_trace(PVR2_TRACE_CHIPS, "subdev status poll type=%u strength=%u audio=0x%x cap=0x%x low=%u hi=%u",
5049 		   vtp->type,
5050 		   vtp->signal, vtp->rxsubchans, vtp->capability,
5051 		   vtp->rangelow, vtp->rangehigh);
5052 
5053 	/* We have to do this to avoid getting into constant polling if
5054 	   there's nobody to answer a poll of cropcap info. */
5055 	hdw->cropcap_stale = 0;
5056 }
5057 
5058 
5059 unsigned int pvr2_hdw_get_input_available(struct pvr2_hdw *hdw)
5060 {
5061 	return hdw->input_avail_mask;
5062 }
5063 
5064 
5065 unsigned int pvr2_hdw_get_input_allowed(struct pvr2_hdw *hdw)
5066 {
5067 	return hdw->input_allowed_mask;
5068 }
5069 
5070 
5071 static int pvr2_hdw_set_input(struct pvr2_hdw *hdw,int v)
5072 {
5073 	if (hdw->input_val != v) {
5074 		hdw->input_val = v;
5075 		hdw->input_dirty = !0;
5076 	}
5077 
5078 	/* Handle side effects - if we switch to a mode that needs the RF
5079 	   tuner, then select the right frequency choice as well and mark
5080 	   it dirty. */
5081 	if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
5082 		hdw->freqSelector = 0;
5083 		hdw->freqDirty = !0;
5084 	} else if ((hdw->input_val == PVR2_CVAL_INPUT_TV) ||
5085 		   (hdw->input_val == PVR2_CVAL_INPUT_DTV)) {
5086 		hdw->freqSelector = 1;
5087 		hdw->freqDirty = !0;
5088 	}
5089 	return 0;
5090 }
5091 
5092 
5093 int pvr2_hdw_set_input_allowed(struct pvr2_hdw *hdw,
5094 			       unsigned int change_mask,
5095 			       unsigned int change_val)
5096 {
5097 	int ret = 0;
5098 	unsigned int nv,m,idx;
5099 	LOCK_TAKE(hdw->big_lock);
5100 	do {
5101 		nv = hdw->input_allowed_mask & ~change_mask;
5102 		nv |= (change_val & change_mask);
5103 		nv &= hdw->input_avail_mask;
5104 		if (!nv) {
5105 			/* No legal modes left; return error instead. */
5106 			ret = -EPERM;
5107 			break;
5108 		}
5109 		hdw->input_allowed_mask = nv;
5110 		if ((1UL << hdw->input_val) & hdw->input_allowed_mask) {
5111 			/* Current mode is still in the allowed mask, so
5112 			   we're done. */
5113 			break;
5114 		}
5115 		/* Select and switch to a mode that is still in the allowed
5116 		   mask */
5117 		if (!hdw->input_allowed_mask) {
5118 			/* Nothing legal; give up */
5119 			break;
5120 		}
5121 		m = hdw->input_allowed_mask;
5122 		for (idx = 0; idx < (sizeof(m) << 3); idx++) {
5123 			if (!((1UL << idx) & m)) continue;
5124 			pvr2_hdw_set_input(hdw,idx);
5125 			break;
5126 		}
5127 	} while (0);
5128 	LOCK_GIVE(hdw->big_lock);
5129 	return ret;
5130 }
5131 
5132 
5133 /* Find I2C address of eeprom */
5134 static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw)
5135 {
5136 	int result;
5137 	LOCK_TAKE(hdw->ctl_lock); do {
5138 		hdw->cmd_buffer[0] = FX2CMD_GET_EEPROM_ADDR;
5139 		result = pvr2_send_request(hdw,
5140 					   hdw->cmd_buffer,1,
5141 					   hdw->cmd_buffer,1);
5142 		if (result < 0) break;
5143 		result = hdw->cmd_buffer[0];
5144 	} while(0); LOCK_GIVE(hdw->ctl_lock);
5145 	return result;
5146 }
5147