4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/errno.h>
22 #include <linux/string.h>
23 #include <linux/slab.h>
24 #include <linux/firmware.h>
25 #include <linux/videodev2.h>
26 #include <media/v4l2-common.h>
28 #include "pvrusb2-std.h"
29 #include "pvrusb2-util.h"
30 #include "pvrusb2-hdw.h"
31 #include "pvrusb2-i2c-core.h"
32 #include "pvrusb2-i2c-track.h"
33 #include "pvrusb2-tuner.h"
34 #include "pvrusb2-eeprom.h"
35 #include "pvrusb2-hdw-internal.h"
36 #include "pvrusb2-encoder.h"
37 #include "pvrusb2-debug.h"
38 #include "pvrusb2-fx2-cmd.h"
40 #define TV_MIN_FREQ 55250000L
41 #define TV_MAX_FREQ 850000000L
43 /* This defines a minimum interval that the decoder must remain quiet
44 before we are allowed to start it running. */
45 #define TIME_MSEC_DECODER_WAIT 50
47 /* This defines a minimum interval that the encoder must remain quiet
48 before we are allowed to configure it. I had this originally set to
49 50msec, but Martin Dauskardt <martin.dauskardt@gmx.de> reports that
50 things work better when it's set to 100msec. */
51 #define TIME_MSEC_ENCODER_WAIT 100
53 /* This defines the minimum interval that the encoder must successfully run
54 before we consider that the encoder has run at least once since its
55 firmware has been loaded. This measurement is in important for cases
56 where we can't do something until we know that the encoder has been run
58 #define TIME_MSEC_ENCODER_OK 250
60 static struct pvr2_hdw *unit_pointers[PVR_NUM] = {[ 0 ... PVR_NUM-1 ] = NULL};
61 static DEFINE_MUTEX(pvr2_unit_mtx);
64 static int procreload;
65 static int tuner[PVR_NUM] = { [0 ... PVR_NUM-1] = -1 };
66 static int tolerance[PVR_NUM] = { [0 ... PVR_NUM-1] = 0 };
67 static int video_std[PVR_NUM] = { [0 ... PVR_NUM-1] = 0 };
68 static int init_pause_msec;
70 module_param(ctlchg, int, S_IRUGO|S_IWUSR);
71 MODULE_PARM_DESC(ctlchg, "0=optimize ctl change 1=always accept new ctl value");
72 module_param(init_pause_msec, int, S_IRUGO|S_IWUSR);
73 MODULE_PARM_DESC(init_pause_msec, "hardware initialization settling delay");
74 module_param(procreload, int, S_IRUGO|S_IWUSR);
75 MODULE_PARM_DESC(procreload,
76 "Attempt init failure recovery with firmware reload");
77 module_param_array(tuner, int, NULL, 0444);
78 MODULE_PARM_DESC(tuner,"specify installed tuner type");
79 module_param_array(video_std, int, NULL, 0444);
80 MODULE_PARM_DESC(video_std,"specify initial video standard");
81 module_param_array(tolerance, int, NULL, 0444);
82 MODULE_PARM_DESC(tolerance,"specify stream error tolerance");
84 /* US Broadcast channel 7 (175.25 MHz) */
85 static int default_tv_freq = 175250000L;
86 /* 104.3 MHz, a usable FM station for my area */
87 static int default_radio_freq = 104300000L;
89 module_param_named(tv_freq, default_tv_freq, int, 0444);
90 MODULE_PARM_DESC(tv_freq, "specify initial television frequency");
91 module_param_named(radio_freq, default_radio_freq, int, 0444);
92 MODULE_PARM_DESC(radio_freq, "specify initial radio frequency");
94 #define PVR2_CTL_WRITE_ENDPOINT 0x01
95 #define PVR2_CTL_READ_ENDPOINT 0x81
97 #define PVR2_GPIO_IN 0x9008
98 #define PVR2_GPIO_OUT 0x900c
99 #define PVR2_GPIO_DIR 0x9020
101 #define trace_firmware(...) pvr2_trace(PVR2_TRACE_FIRMWARE,__VA_ARGS__)
103 #define PVR2_FIRMWARE_ENDPOINT 0x02
105 /* size of a firmware chunk */
106 #define FIRMWARE_CHUNK_SIZE 0x2000
108 /* Define the list of additional controls we'll dynamically construct based
109 on query of the cx2341x module. */
110 struct pvr2_mpeg_ids {
114 static const struct pvr2_mpeg_ids mpeg_ids[] = {
116 .strid = "audio_layer",
117 .id = V4L2_CID_MPEG_AUDIO_ENCODING,
119 .strid = "audio_bitrate",
120 .id = V4L2_CID_MPEG_AUDIO_L2_BITRATE,
122 /* Already using audio_mode elsewhere :-( */
123 .strid = "mpeg_audio_mode",
124 .id = V4L2_CID_MPEG_AUDIO_MODE,
126 .strid = "mpeg_audio_mode_extension",
127 .id = V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
129 .strid = "audio_emphasis",
130 .id = V4L2_CID_MPEG_AUDIO_EMPHASIS,
132 .strid = "audio_crc",
133 .id = V4L2_CID_MPEG_AUDIO_CRC,
135 .strid = "video_aspect",
136 .id = V4L2_CID_MPEG_VIDEO_ASPECT,
138 .strid = "video_b_frames",
139 .id = V4L2_CID_MPEG_VIDEO_B_FRAMES,
141 .strid = "video_gop_size",
142 .id = V4L2_CID_MPEG_VIDEO_GOP_SIZE,
144 .strid = "video_gop_closure",
145 .id = V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
147 .strid = "video_bitrate_mode",
148 .id = V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
150 .strid = "video_bitrate",
151 .id = V4L2_CID_MPEG_VIDEO_BITRATE,
153 .strid = "video_bitrate_peak",
154 .id = V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
156 .strid = "video_temporal_decimation",
157 .id = V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
159 .strid = "stream_type",
160 .id = V4L2_CID_MPEG_STREAM_TYPE,
162 .strid = "video_spatial_filter_mode",
163 .id = V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
165 .strid = "video_spatial_filter",
166 .id = V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
168 .strid = "video_luma_spatial_filter_type",
169 .id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
171 .strid = "video_chroma_spatial_filter_type",
172 .id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
174 .strid = "video_temporal_filter_mode",
175 .id = V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
177 .strid = "video_temporal_filter",
178 .id = V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
180 .strid = "video_median_filter_type",
181 .id = V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
183 .strid = "video_luma_median_filter_top",
184 .id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
186 .strid = "video_luma_median_filter_bottom",
187 .id = V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
189 .strid = "video_chroma_median_filter_top",
190 .id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
192 .strid = "video_chroma_median_filter_bottom",
193 .id = V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
196 #define MPEGDEF_COUNT ARRAY_SIZE(mpeg_ids)
199 static const char *control_values_srate[] = {
200 [V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100] = "44.1 kHz",
201 [V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000] = "48 kHz",
202 [V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000] = "32 kHz",
207 static const char *control_values_input[] = {
208 [PVR2_CVAL_INPUT_TV] = "television", /*xawtv needs this name*/
209 [PVR2_CVAL_INPUT_DTV] = "dtv",
210 [PVR2_CVAL_INPUT_RADIO] = "radio",
211 [PVR2_CVAL_INPUT_SVIDEO] = "s-video",
212 [PVR2_CVAL_INPUT_COMPOSITE] = "composite",
216 static const char *control_values_audiomode[] = {
217 [V4L2_TUNER_MODE_MONO] = "Mono",
218 [V4L2_TUNER_MODE_STEREO] = "Stereo",
219 [V4L2_TUNER_MODE_LANG1] = "Lang1",
220 [V4L2_TUNER_MODE_LANG2] = "Lang2",
221 [V4L2_TUNER_MODE_LANG1_LANG2] = "Lang1+Lang2",
225 static const char *control_values_hsm[] = {
226 [PVR2_CVAL_HSM_FAIL] = "Fail",
227 [PVR2_CVAL_HSM_HIGH] = "High",
228 [PVR2_CVAL_HSM_FULL] = "Full",
232 static const char *pvr2_state_names[] = {
233 [PVR2_STATE_NONE] = "none",
234 [PVR2_STATE_DEAD] = "dead",
235 [PVR2_STATE_COLD] = "cold",
236 [PVR2_STATE_WARM] = "warm",
237 [PVR2_STATE_ERROR] = "error",
238 [PVR2_STATE_READY] = "ready",
239 [PVR2_STATE_RUN] = "run",
243 struct pvr2_fx2cmd_descdef {
248 static const struct pvr2_fx2cmd_descdef pvr2_fx2cmd_desc[] = {
249 {FX2CMD_MEM_WRITE_DWORD, "write encoder dword"},
250 {FX2CMD_MEM_READ_DWORD, "read encoder dword"},
251 {FX2CMD_HCW_ZILOG_RESET, "zilog IR reset control"},
252 {FX2CMD_MEM_READ_64BYTES, "read encoder 64bytes"},
253 {FX2CMD_REG_WRITE, "write encoder register"},
254 {FX2CMD_REG_READ, "read encoder register"},
255 {FX2CMD_MEMSEL, "encoder memsel"},
256 {FX2CMD_I2C_WRITE, "i2c write"},
257 {FX2CMD_I2C_READ, "i2c read"},
258 {FX2CMD_GET_USB_SPEED, "get USB speed"},
259 {FX2CMD_STREAMING_ON, "stream on"},
260 {FX2CMD_STREAMING_OFF, "stream off"},
261 {FX2CMD_FWPOST1, "fwpost1"},
262 {FX2CMD_POWER_OFF, "power off"},
263 {FX2CMD_POWER_ON, "power on"},
264 {FX2CMD_DEEP_RESET, "deep reset"},
265 {FX2CMD_GET_EEPROM_ADDR, "get rom addr"},
266 {FX2CMD_GET_IR_CODE, "get IR code"},
267 {FX2CMD_HCW_DEMOD_RESETIN, "hcw demod resetin"},
268 {FX2CMD_HCW_DTV_STREAMING_ON, "hcw dtv stream on"},
269 {FX2CMD_HCW_DTV_STREAMING_OFF, "hcw dtv stream off"},
270 {FX2CMD_ONAIR_DTV_STREAMING_ON, "onair dtv stream on"},
271 {FX2CMD_ONAIR_DTV_STREAMING_OFF, "onair dtv stream off"},
272 {FX2CMD_ONAIR_DTV_POWER_ON, "onair dtv power on"},
273 {FX2CMD_ONAIR_DTV_POWER_OFF, "onair dtv power off"},
277 static int pvr2_hdw_set_input(struct pvr2_hdw *hdw,int v);
278 static void pvr2_hdw_state_sched(struct pvr2_hdw *);
279 static int pvr2_hdw_state_eval(struct pvr2_hdw *);
280 static void pvr2_hdw_set_cur_freq(struct pvr2_hdw *,unsigned long);
281 static void pvr2_hdw_worker_i2c(struct work_struct *work);
282 static void pvr2_hdw_worker_poll(struct work_struct *work);
283 static int pvr2_hdw_wait(struct pvr2_hdw *,int state);
284 static int pvr2_hdw_untrip_unlocked(struct pvr2_hdw *);
285 static void pvr2_hdw_state_log_state(struct pvr2_hdw *);
286 static int pvr2_hdw_cmd_usbstream(struct pvr2_hdw *hdw,int runFl);
287 static int pvr2_hdw_commit_setup(struct pvr2_hdw *hdw);
288 static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw);
289 static void pvr2_hdw_internal_find_stdenum(struct pvr2_hdw *hdw);
290 static void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw);
291 static void pvr2_hdw_quiescent_timeout(unsigned long);
292 static void pvr2_hdw_encoder_wait_timeout(unsigned long);
293 static void pvr2_hdw_encoder_run_timeout(unsigned long);
294 static int pvr2_issue_simple_cmd(struct pvr2_hdw *,u32);
295 static int pvr2_send_request_ex(struct pvr2_hdw *hdw,
296 unsigned int timeout,int probe_fl,
297 void *write_data,unsigned int write_len,
298 void *read_data,unsigned int read_len);
299 static int pvr2_hdw_check_cropcap(struct pvr2_hdw *hdw);
302 static void trace_stbit(const char *name,int val)
304 pvr2_trace(PVR2_TRACE_STBITS,
305 "State bit %s <-- %s",
306 name,(val ? "true" : "false"));
309 static int ctrl_channelfreq_get(struct pvr2_ctrl *cptr,int *vp)
311 struct pvr2_hdw *hdw = cptr->hdw;
312 if ((hdw->freqProgSlot > 0) && (hdw->freqProgSlot <= FREQTABLE_SIZE)) {
313 *vp = hdw->freqTable[hdw->freqProgSlot-1];
320 static int ctrl_channelfreq_set(struct pvr2_ctrl *cptr,int m,int v)
322 struct pvr2_hdw *hdw = cptr->hdw;
323 unsigned int slotId = hdw->freqProgSlot;
324 if ((slotId > 0) && (slotId <= FREQTABLE_SIZE)) {
325 hdw->freqTable[slotId-1] = v;
326 /* Handle side effects correctly - if we're tuned to this
327 slot, then forgot the slot id relation since the stored
328 frequency has been changed. */
329 if (hdw->freqSelector) {
330 if (hdw->freqSlotRadio == slotId) {
331 hdw->freqSlotRadio = 0;
334 if (hdw->freqSlotTelevision == slotId) {
335 hdw->freqSlotTelevision = 0;
342 static int ctrl_channelprog_get(struct pvr2_ctrl *cptr,int *vp)
344 *vp = cptr->hdw->freqProgSlot;
348 static int ctrl_channelprog_set(struct pvr2_ctrl *cptr,int m,int v)
350 struct pvr2_hdw *hdw = cptr->hdw;
351 if ((v >= 0) && (v <= FREQTABLE_SIZE)) {
352 hdw->freqProgSlot = v;
357 static int ctrl_channel_get(struct pvr2_ctrl *cptr,int *vp)
359 struct pvr2_hdw *hdw = cptr->hdw;
360 *vp = hdw->freqSelector ? hdw->freqSlotRadio : hdw->freqSlotTelevision;
364 static int ctrl_channel_set(struct pvr2_ctrl *cptr,int m,int slotId)
367 struct pvr2_hdw *hdw = cptr->hdw;
368 if ((slotId < 0) || (slotId > FREQTABLE_SIZE)) return 0;
370 freq = hdw->freqTable[slotId-1];
372 pvr2_hdw_set_cur_freq(hdw,freq);
374 if (hdw->freqSelector) {
375 hdw->freqSlotRadio = slotId;
377 hdw->freqSlotTelevision = slotId;
382 static int ctrl_freq_get(struct pvr2_ctrl *cptr,int *vp)
384 *vp = pvr2_hdw_get_cur_freq(cptr->hdw);
388 static int ctrl_freq_is_dirty(struct pvr2_ctrl *cptr)
390 return cptr->hdw->freqDirty != 0;
393 static void ctrl_freq_clear_dirty(struct pvr2_ctrl *cptr)
395 cptr->hdw->freqDirty = 0;
398 static int ctrl_freq_set(struct pvr2_ctrl *cptr,int m,int v)
400 pvr2_hdw_set_cur_freq(cptr->hdw,v);
404 static int ctrl_cropl_min_get(struct pvr2_ctrl *cptr, int *left)
406 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
407 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
411 *left = cap->bounds.left;
415 static int ctrl_cropl_max_get(struct pvr2_ctrl *cptr, int *left)
417 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
418 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
422 *left = cap->bounds.left;
423 if (cap->bounds.width > cptr->hdw->cropw_val) {
424 *left += cap->bounds.width - cptr->hdw->cropw_val;
429 static int ctrl_cropt_min_get(struct pvr2_ctrl *cptr, int *top)
431 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
432 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
436 *top = cap->bounds.top;
440 static int ctrl_cropt_max_get(struct pvr2_ctrl *cptr, int *top)
442 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
443 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
447 *top = cap->bounds.top;
448 if (cap->bounds.height > cptr->hdw->croph_val) {
449 *top += cap->bounds.height - cptr->hdw->croph_val;
454 static int ctrl_cropw_max_get(struct pvr2_ctrl *cptr, int *val)
456 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
457 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
462 if (cap->bounds.width > cptr->hdw->cropl_val) {
463 *val = cap->bounds.width - cptr->hdw->cropl_val;
468 static int ctrl_croph_max_get(struct pvr2_ctrl *cptr, int *val)
470 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
471 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
476 if (cap->bounds.height > cptr->hdw->cropt_val) {
477 *val = cap->bounds.height - cptr->hdw->cropt_val;
482 static int ctrl_get_cropcapbl(struct pvr2_ctrl *cptr, int *val)
484 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
485 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
489 *val = cap->bounds.left;
493 static int ctrl_get_cropcapbt(struct pvr2_ctrl *cptr, int *val)
495 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
496 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
500 *val = cap->bounds.top;
504 static int ctrl_get_cropcapbw(struct pvr2_ctrl *cptr, int *val)
506 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
507 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
511 *val = cap->bounds.width;
515 static int ctrl_get_cropcapbh(struct pvr2_ctrl *cptr, int *val)
517 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
518 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
522 *val = cap->bounds.height;
526 static int ctrl_get_cropcapdl(struct pvr2_ctrl *cptr, int *val)
528 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
529 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
533 *val = cap->defrect.left;
537 static int ctrl_get_cropcapdt(struct pvr2_ctrl *cptr, int *val)
539 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
540 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
544 *val = cap->defrect.top;
548 static int ctrl_get_cropcapdw(struct pvr2_ctrl *cptr, int *val)
550 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
551 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
555 *val = cap->defrect.width;
559 static int ctrl_get_cropcapdh(struct pvr2_ctrl *cptr, int *val)
561 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
562 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
566 *val = cap->defrect.height;
570 static int ctrl_get_cropcappan(struct pvr2_ctrl *cptr, int *val)
572 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
573 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
577 *val = cap->pixelaspect.numerator;
581 static int ctrl_get_cropcappad(struct pvr2_ctrl *cptr, int *val)
583 struct v4l2_cropcap *cap = &cptr->hdw->cropcap_info;
584 int stat = pvr2_hdw_check_cropcap(cptr->hdw);
588 *val = cap->pixelaspect.denominator;
592 static int ctrl_vres_max_get(struct pvr2_ctrl *cptr,int *vp)
594 /* Actual maximum depends on the video standard in effect. */
595 if (cptr->hdw->std_mask_cur & V4L2_STD_525_60) {
603 static int ctrl_vres_min_get(struct pvr2_ctrl *cptr,int *vp)
605 /* Actual minimum depends on device digitizer type. */
606 if (cptr->hdw->hdw_desc->flag_has_cx25840) {
614 static int ctrl_get_input(struct pvr2_ctrl *cptr,int *vp)
616 *vp = cptr->hdw->input_val;
620 static int ctrl_check_input(struct pvr2_ctrl *cptr,int v)
622 return ((1 << v) & cptr->hdw->input_allowed_mask) != 0;
625 static int ctrl_set_input(struct pvr2_ctrl *cptr,int m,int v)
627 return pvr2_hdw_set_input(cptr->hdw,v);
630 static int ctrl_isdirty_input(struct pvr2_ctrl *cptr)
632 return cptr->hdw->input_dirty != 0;
635 static void ctrl_cleardirty_input(struct pvr2_ctrl *cptr)
637 cptr->hdw->input_dirty = 0;
641 static int ctrl_freq_max_get(struct pvr2_ctrl *cptr, int *vp)
644 struct pvr2_hdw *hdw = cptr->hdw;
645 if (hdw->tuner_signal_stale) {
646 pvr2_hdw_status_poll(hdw);
648 fv = hdw->tuner_signal_info.rangehigh;
650 /* Safety fallback */
654 if (hdw->tuner_signal_info.capability & V4L2_TUNER_CAP_LOW) {
663 static int ctrl_freq_min_get(struct pvr2_ctrl *cptr, int *vp)
666 struct pvr2_hdw *hdw = cptr->hdw;
667 if (hdw->tuner_signal_stale) {
668 pvr2_hdw_status_poll(hdw);
670 fv = hdw->tuner_signal_info.rangelow;
672 /* Safety fallback */
676 if (hdw->tuner_signal_info.capability & V4L2_TUNER_CAP_LOW) {
685 static int ctrl_cx2341x_is_dirty(struct pvr2_ctrl *cptr)
687 return cptr->hdw->enc_stale != 0;
690 static void ctrl_cx2341x_clear_dirty(struct pvr2_ctrl *cptr)
692 cptr->hdw->enc_stale = 0;
693 cptr->hdw->enc_unsafe_stale = 0;
696 static int ctrl_cx2341x_get(struct pvr2_ctrl *cptr,int *vp)
699 struct v4l2_ext_controls cs;
700 struct v4l2_ext_control c1;
701 memset(&cs,0,sizeof(cs));
702 memset(&c1,0,sizeof(c1));
705 c1.id = cptr->info->v4l_id;
706 ret = cx2341x_ext_ctrls(&cptr->hdw->enc_ctl_state, 0, &cs,
713 static int ctrl_cx2341x_set(struct pvr2_ctrl *cptr,int m,int v)
716 struct pvr2_hdw *hdw = cptr->hdw;
717 struct v4l2_ext_controls cs;
718 struct v4l2_ext_control c1;
719 memset(&cs,0,sizeof(cs));
720 memset(&c1,0,sizeof(c1));
723 c1.id = cptr->info->v4l_id;
725 ret = cx2341x_ext_ctrls(&hdw->enc_ctl_state,
726 hdw->state_encoder_run, &cs,
729 /* Oops. cx2341x is telling us it's not safe to change
730 this control while we're capturing. Make a note of this
731 fact so that the pipeline will be stopped the next time
732 controls are committed. Then go on ahead and store this
734 ret = cx2341x_ext_ctrls(&hdw->enc_ctl_state,
737 if (!ret) hdw->enc_unsafe_stale = !0;
744 static unsigned int ctrl_cx2341x_getv4lflags(struct pvr2_ctrl *cptr)
746 struct v4l2_queryctrl qctrl;
747 struct pvr2_ctl_info *info;
748 qctrl.id = cptr->info->v4l_id;
749 cx2341x_ctrl_query(&cptr->hdw->enc_ctl_state,&qctrl);
750 /* Strip out the const so we can adjust a function pointer. It's
751 OK to do this here because we know this is a dynamically created
752 control, so the underlying storage for the info pointer is (a)
753 private to us, and (b) not in read-only storage. Either we do
754 this or we significantly complicate the underlying control
756 info = (struct pvr2_ctl_info *)(cptr->info);
757 if (qctrl.flags & V4L2_CTRL_FLAG_READ_ONLY) {
758 if (info->set_value) {
759 info->set_value = NULL;
762 if (!(info->set_value)) {
763 info->set_value = ctrl_cx2341x_set;
769 static int ctrl_streamingenabled_get(struct pvr2_ctrl *cptr,int *vp)
771 *vp = cptr->hdw->state_pipeline_req;
775 static int ctrl_masterstate_get(struct pvr2_ctrl *cptr,int *vp)
777 *vp = cptr->hdw->master_state;
781 static int ctrl_hsm_get(struct pvr2_ctrl *cptr,int *vp)
783 int result = pvr2_hdw_is_hsm(cptr->hdw);
784 *vp = PVR2_CVAL_HSM_FULL;
785 if (result < 0) *vp = PVR2_CVAL_HSM_FAIL;
786 if (result) *vp = PVR2_CVAL_HSM_HIGH;
790 static int ctrl_stdavail_get(struct pvr2_ctrl *cptr,int *vp)
792 *vp = cptr->hdw->std_mask_avail;
796 static int ctrl_stdavail_set(struct pvr2_ctrl *cptr,int m,int v)
798 struct pvr2_hdw *hdw = cptr->hdw;
800 ns = hdw->std_mask_avail;
801 ns = (ns & ~m) | (v & m);
802 if (ns == hdw->std_mask_avail) return 0;
803 hdw->std_mask_avail = ns;
804 pvr2_hdw_internal_set_std_avail(hdw);
805 pvr2_hdw_internal_find_stdenum(hdw);
809 static int ctrl_std_val_to_sym(struct pvr2_ctrl *cptr,int msk,int val,
810 char *bufPtr,unsigned int bufSize,
813 *len = pvr2_std_id_to_str(bufPtr,bufSize,msk & val);
817 static int ctrl_std_sym_to_val(struct pvr2_ctrl *cptr,
818 const char *bufPtr,unsigned int bufSize,
823 ret = pvr2_std_str_to_id(&id,bufPtr,bufSize);
824 if (ret < 0) return ret;
825 if (mskp) *mskp = id;
826 if (valp) *valp = id;
830 static int ctrl_stdcur_get(struct pvr2_ctrl *cptr,int *vp)
832 *vp = cptr->hdw->std_mask_cur;
836 static int ctrl_stdcur_set(struct pvr2_ctrl *cptr,int m,int v)
838 struct pvr2_hdw *hdw = cptr->hdw;
840 ns = hdw->std_mask_cur;
841 ns = (ns & ~m) | (v & m);
842 if (ns == hdw->std_mask_cur) return 0;
843 hdw->std_mask_cur = ns;
845 pvr2_hdw_internal_find_stdenum(hdw);
849 static int ctrl_stdcur_is_dirty(struct pvr2_ctrl *cptr)
851 return cptr->hdw->std_dirty != 0;
854 static void ctrl_stdcur_clear_dirty(struct pvr2_ctrl *cptr)
856 cptr->hdw->std_dirty = 0;
859 static int ctrl_signal_get(struct pvr2_ctrl *cptr,int *vp)
861 struct pvr2_hdw *hdw = cptr->hdw;
862 pvr2_hdw_status_poll(hdw);
863 *vp = hdw->tuner_signal_info.signal;
867 static int ctrl_audio_modes_present_get(struct pvr2_ctrl *cptr,int *vp)
870 unsigned int subchan;
871 struct pvr2_hdw *hdw = cptr->hdw;
872 pvr2_hdw_status_poll(hdw);
873 subchan = hdw->tuner_signal_info.rxsubchans;
874 if (subchan & V4L2_TUNER_SUB_MONO) {
875 val |= (1 << V4L2_TUNER_MODE_MONO);
877 if (subchan & V4L2_TUNER_SUB_STEREO) {
878 val |= (1 << V4L2_TUNER_MODE_STEREO);
880 if (subchan & V4L2_TUNER_SUB_LANG1) {
881 val |= (1 << V4L2_TUNER_MODE_LANG1);
883 if (subchan & V4L2_TUNER_SUB_LANG2) {
884 val |= (1 << V4L2_TUNER_MODE_LANG2);
891 static int ctrl_stdenumcur_set(struct pvr2_ctrl *cptr,int m,int v)
893 struct pvr2_hdw *hdw = cptr->hdw;
894 if (v < 0) return -EINVAL;
895 if (v > hdw->std_enum_cnt) return -EINVAL;
896 hdw->std_enum_cur = v;
899 if (hdw->std_mask_cur == hdw->std_defs[v].id) return 0;
900 hdw->std_mask_cur = hdw->std_defs[v].id;
906 static int ctrl_stdenumcur_get(struct pvr2_ctrl *cptr,int *vp)
908 *vp = cptr->hdw->std_enum_cur;
913 static int ctrl_stdenumcur_is_dirty(struct pvr2_ctrl *cptr)
915 return cptr->hdw->std_dirty != 0;
919 static void ctrl_stdenumcur_clear_dirty(struct pvr2_ctrl *cptr)
921 cptr->hdw->std_dirty = 0;
925 #define DEFINT(vmin,vmax) \
926 .type = pvr2_ctl_int, \
927 .def.type_int.min_value = vmin, \
928 .def.type_int.max_value = vmax
930 #define DEFENUM(tab) \
931 .type = pvr2_ctl_enum, \
932 .def.type_enum.count = ARRAY_SIZE(tab), \
933 .def.type_enum.value_names = tab
936 .type = pvr2_ctl_bool
938 #define DEFMASK(msk,tab) \
939 .type = pvr2_ctl_bitmask, \
940 .def.type_bitmask.valid_bits = msk, \
941 .def.type_bitmask.bit_names = tab
943 #define DEFREF(vname) \
944 .set_value = ctrl_set_##vname, \
945 .get_value = ctrl_get_##vname, \
946 .is_dirty = ctrl_isdirty_##vname, \
947 .clear_dirty = ctrl_cleardirty_##vname
950 #define VCREATE_FUNCS(vname) \
951 static int ctrl_get_##vname(struct pvr2_ctrl *cptr,int *vp) \
952 {*vp = cptr->hdw->vname##_val; return 0;} \
953 static int ctrl_set_##vname(struct pvr2_ctrl *cptr,int m,int v) \
954 {cptr->hdw->vname##_val = v; cptr->hdw->vname##_dirty = !0; return 0;} \
955 static int ctrl_isdirty_##vname(struct pvr2_ctrl *cptr) \
956 {return cptr->hdw->vname##_dirty != 0;} \
957 static void ctrl_cleardirty_##vname(struct pvr2_ctrl *cptr) \
958 {cptr->hdw->vname##_dirty = 0;}
960 VCREATE_FUNCS(brightness)
961 VCREATE_FUNCS(contrast)
962 VCREATE_FUNCS(saturation)
964 VCREATE_FUNCS(volume)
965 VCREATE_FUNCS(balance)
967 VCREATE_FUNCS(treble)
973 VCREATE_FUNCS(audiomode)
974 VCREATE_FUNCS(res_hor)
975 VCREATE_FUNCS(res_ver)
978 /* Table definition of all controls which can be manipulated */
979 static const struct pvr2_ctl_info control_defs[] = {
981 .v4l_id = V4L2_CID_BRIGHTNESS,
982 .desc = "Brightness",
983 .name = "brightness",
984 .default_value = 128,
988 .v4l_id = V4L2_CID_CONTRAST,
995 .v4l_id = V4L2_CID_SATURATION,
996 .desc = "Saturation",
997 .name = "saturation",
1002 .v4l_id = V4L2_CID_HUE,
1009 .v4l_id = V4L2_CID_AUDIO_VOLUME,
1012 .default_value = 62000,
1016 .v4l_id = V4L2_CID_AUDIO_BALANCE,
1021 DEFINT(-32768,32767),
1023 .v4l_id = V4L2_CID_AUDIO_BASS,
1028 DEFINT(-32768,32767),
1030 .v4l_id = V4L2_CID_AUDIO_TREBLE,
1035 DEFINT(-32768,32767),
1037 .v4l_id = V4L2_CID_AUDIO_MUTE,
1044 .desc = "Capture crop left margin",
1045 .name = "crop_left",
1046 .internal_id = PVR2_CID_CROPL,
1050 .get_min_value = ctrl_cropl_min_get,
1051 .get_max_value = ctrl_cropl_max_get,
1052 .get_def_value = ctrl_get_cropcapdl,
1054 .desc = "Capture crop top margin",
1056 .internal_id = PVR2_CID_CROPT,
1060 .get_min_value = ctrl_cropt_min_get,
1061 .get_max_value = ctrl_cropt_max_get,
1062 .get_def_value = ctrl_get_cropcapdt,
1064 .desc = "Capture crop width",
1065 .name = "crop_width",
1066 .internal_id = PVR2_CID_CROPW,
1067 .default_value = 720,
1069 .get_max_value = ctrl_cropw_max_get,
1070 .get_def_value = ctrl_get_cropcapdw,
1072 .desc = "Capture crop height",
1073 .name = "crop_height",
1074 .internal_id = PVR2_CID_CROPH,
1075 .default_value = 480,
1077 .get_max_value = ctrl_croph_max_get,
1078 .get_def_value = ctrl_get_cropcapdh,
1080 .desc = "Capture capability pixel aspect numerator",
1081 .name = "cropcap_pixel_numerator",
1082 .internal_id = PVR2_CID_CROPCAPPAN,
1083 .get_value = ctrl_get_cropcappan,
1085 .desc = "Capture capability pixel aspect denominator",
1086 .name = "cropcap_pixel_denominator",
1087 .internal_id = PVR2_CID_CROPCAPPAD,
1088 .get_value = ctrl_get_cropcappad,
1090 .desc = "Capture capability bounds top",
1091 .name = "cropcap_bounds_top",
1092 .internal_id = PVR2_CID_CROPCAPBT,
1093 .get_value = ctrl_get_cropcapbt,
1095 .desc = "Capture capability bounds left",
1096 .name = "cropcap_bounds_left",
1097 .internal_id = PVR2_CID_CROPCAPBL,
1098 .get_value = ctrl_get_cropcapbl,
1100 .desc = "Capture capability bounds width",
1101 .name = "cropcap_bounds_width",
1102 .internal_id = PVR2_CID_CROPCAPBW,
1103 .get_value = ctrl_get_cropcapbw,
1105 .desc = "Capture capability bounds height",
1106 .name = "cropcap_bounds_height",
1107 .internal_id = PVR2_CID_CROPCAPBH,
1108 .get_value = ctrl_get_cropcapbh,
1110 .desc = "Video Source",
1112 .internal_id = PVR2_CID_INPUT,
1113 .default_value = PVR2_CVAL_INPUT_TV,
1114 .check_value = ctrl_check_input,
1116 DEFENUM(control_values_input),
1118 .desc = "Audio Mode",
1119 .name = "audio_mode",
1120 .internal_id = PVR2_CID_AUDIOMODE,
1121 .default_value = V4L2_TUNER_MODE_STEREO,
1123 DEFENUM(control_values_audiomode),
1125 .desc = "Horizontal capture resolution",
1126 .name = "resolution_hor",
1127 .internal_id = PVR2_CID_HRES,
1128 .default_value = 720,
1132 .desc = "Vertical capture resolution",
1133 .name = "resolution_ver",
1134 .internal_id = PVR2_CID_VRES,
1135 .default_value = 480,
1138 /* Hook in check for video standard and adjust maximum
1139 depending on the standard. */
1140 .get_max_value = ctrl_vres_max_get,
1141 .get_min_value = ctrl_vres_min_get,
1143 .v4l_id = V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
1144 .default_value = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
1145 .desc = "Audio Sampling Frequency",
1148 DEFENUM(control_values_srate),
1150 .desc = "Tuner Frequency (Hz)",
1151 .name = "frequency",
1152 .internal_id = PVR2_CID_FREQUENCY,
1154 .set_value = ctrl_freq_set,
1155 .get_value = ctrl_freq_get,
1156 .is_dirty = ctrl_freq_is_dirty,
1157 .clear_dirty = ctrl_freq_clear_dirty,
1159 /* Hook in check for input value (tv/radio) and adjust
1160 max/min values accordingly */
1161 .get_max_value = ctrl_freq_max_get,
1162 .get_min_value = ctrl_freq_min_get,
1166 .set_value = ctrl_channel_set,
1167 .get_value = ctrl_channel_get,
1168 DEFINT(0,FREQTABLE_SIZE),
1170 .desc = "Channel Program Frequency",
1171 .name = "freq_table_value",
1172 .set_value = ctrl_channelfreq_set,
1173 .get_value = ctrl_channelfreq_get,
1175 /* Hook in check for input value (tv/radio) and adjust
1176 max/min values accordingly */
1177 .get_max_value = ctrl_freq_max_get,
1178 .get_min_value = ctrl_freq_min_get,
1180 .desc = "Channel Program ID",
1181 .name = "freq_table_channel",
1182 .set_value = ctrl_channelprog_set,
1183 .get_value = ctrl_channelprog_get,
1184 DEFINT(0,FREQTABLE_SIZE),
1186 .desc = "Streaming Enabled",
1187 .name = "streaming_enabled",
1188 .get_value = ctrl_streamingenabled_get,
1191 .desc = "USB Speed",
1192 .name = "usb_speed",
1193 .get_value = ctrl_hsm_get,
1194 DEFENUM(control_values_hsm),
1196 .desc = "Master State",
1197 .name = "master_state",
1198 .get_value = ctrl_masterstate_get,
1199 DEFENUM(pvr2_state_names),
1201 .desc = "Signal Present",
1202 .name = "signal_present",
1203 .get_value = ctrl_signal_get,
1206 .desc = "Audio Modes Present",
1207 .name = "audio_modes_present",
1208 .get_value = ctrl_audio_modes_present_get,
1209 /* For this type we "borrow" the V4L2_TUNER_MODE enum from
1210 v4l. Nothing outside of this module cares about this,
1211 but I reuse it in order to also reuse the
1212 control_values_audiomode string table. */
1213 DEFMASK(((1 << V4L2_TUNER_MODE_MONO)|
1214 (1 << V4L2_TUNER_MODE_STEREO)|
1215 (1 << V4L2_TUNER_MODE_LANG1)|
1216 (1 << V4L2_TUNER_MODE_LANG2)),
1217 control_values_audiomode),
1219 .desc = "Video Standards Available Mask",
1220 .name = "video_standard_mask_available",
1221 .internal_id = PVR2_CID_STDAVAIL,
1223 .get_value = ctrl_stdavail_get,
1224 .set_value = ctrl_stdavail_set,
1225 .val_to_sym = ctrl_std_val_to_sym,
1226 .sym_to_val = ctrl_std_sym_to_val,
1227 .type = pvr2_ctl_bitmask,
1229 .desc = "Video Standards In Use Mask",
1230 .name = "video_standard_mask_active",
1231 .internal_id = PVR2_CID_STDCUR,
1233 .get_value = ctrl_stdcur_get,
1234 .set_value = ctrl_stdcur_set,
1235 .is_dirty = ctrl_stdcur_is_dirty,
1236 .clear_dirty = ctrl_stdcur_clear_dirty,
1237 .val_to_sym = ctrl_std_val_to_sym,
1238 .sym_to_val = ctrl_std_sym_to_val,
1239 .type = pvr2_ctl_bitmask,
1241 .desc = "Video Standard Name",
1242 .name = "video_standard",
1243 .internal_id = PVR2_CID_STDENUM,
1245 .get_value = ctrl_stdenumcur_get,
1246 .set_value = ctrl_stdenumcur_set,
1247 .is_dirty = ctrl_stdenumcur_is_dirty,
1248 .clear_dirty = ctrl_stdenumcur_clear_dirty,
1249 .type = pvr2_ctl_enum,
1253 #define CTRLDEF_COUNT ARRAY_SIZE(control_defs)
1256 const char *pvr2_config_get_name(enum pvr2_config cfg)
1259 case pvr2_config_empty: return "empty";
1260 case pvr2_config_mpeg: return "mpeg";
1261 case pvr2_config_vbi: return "vbi";
1262 case pvr2_config_pcm: return "pcm";
1263 case pvr2_config_rawvideo: return "raw video";
1269 struct usb_device *pvr2_hdw_get_dev(struct pvr2_hdw *hdw)
1271 return hdw->usb_dev;
1275 unsigned long pvr2_hdw_get_sn(struct pvr2_hdw *hdw)
1277 return hdw->serial_number;
1281 const char *pvr2_hdw_get_bus_info(struct pvr2_hdw *hdw)
1283 return hdw->bus_info;
1287 const char *pvr2_hdw_get_device_identifier(struct pvr2_hdw *hdw)
1289 return hdw->identifier;
1293 unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *hdw)
1295 return hdw->freqSelector ? hdw->freqValTelevision : hdw->freqValRadio;
1298 /* Set the currently tuned frequency and account for all possible
1299 driver-core side effects of this action. */
1300 static void pvr2_hdw_set_cur_freq(struct pvr2_hdw *hdw,unsigned long val)
1302 if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
1303 if (hdw->freqSelector) {
1304 /* Swing over to radio frequency selection */
1305 hdw->freqSelector = 0;
1306 hdw->freqDirty = !0;
1308 if (hdw->freqValRadio != val) {
1309 hdw->freqValRadio = val;
1310 hdw->freqSlotRadio = 0;
1311 hdw->freqDirty = !0;
1314 if (!(hdw->freqSelector)) {
1315 /* Swing over to television frequency selection */
1316 hdw->freqSelector = 1;
1317 hdw->freqDirty = !0;
1319 if (hdw->freqValTelevision != val) {
1320 hdw->freqValTelevision = val;
1321 hdw->freqSlotTelevision = 0;
1322 hdw->freqDirty = !0;
1327 int pvr2_hdw_get_unit_number(struct pvr2_hdw *hdw)
1329 return hdw->unit_number;
1333 /* Attempt to locate one of the given set of files. Messages are logged
1334 appropriate to what has been found. The return value will be 0 or
1335 greater on success (it will be the index of the file name found) and
1336 fw_entry will be filled in. Otherwise a negative error is returned on
1337 failure. If the return value is -ENOENT then no viable firmware file
1338 could be located. */
1339 static int pvr2_locate_firmware(struct pvr2_hdw *hdw,
1340 const struct firmware **fw_entry,
1341 const char *fwtypename,
1342 unsigned int fwcount,
1343 const char *fwnames[])
1347 for (idx = 0; idx < fwcount; idx++) {
1348 ret = request_firmware(fw_entry,
1350 &hdw->usb_dev->dev);
1352 trace_firmware("Located %s firmware: %s;"
1358 if (ret == -ENOENT) continue;
1359 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1360 "request_firmware fatal error with code=%d",ret);
1363 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1365 " Device %s firmware"
1366 " seems to be missing.",
1368 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1369 "Did you install the pvrusb2 firmware files"
1370 " in their proper location?");
1372 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1373 "request_firmware unable to locate %s file %s",
1374 fwtypename,fwnames[0]);
1376 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1377 "request_firmware unable to locate"
1378 " one of the following %s files:",
1380 for (idx = 0; idx < fwcount; idx++) {
1381 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1382 "request_firmware: Failed to find %s",
1391 * pvr2_upload_firmware1().
1393 * Send the 8051 firmware to the device. After the upload, arrange for
1394 * device to re-enumerate.
1396 * NOTE : the pointer to the firmware data given by request_firmware()
1397 * is not suitable for an usb transaction.
1400 static int pvr2_upload_firmware1(struct pvr2_hdw *hdw)
1402 const struct firmware *fw_entry = NULL;
1408 if (!hdw->hdw_desc->fx2_firmware.cnt) {
1409 hdw->fw1_state = FW1_STATE_OK;
1410 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1411 "Connected device type defines"
1412 " no firmware to upload; ignoring firmware");
1416 hdw->fw1_state = FW1_STATE_FAILED; // default result
1418 trace_firmware("pvr2_upload_firmware1");
1420 ret = pvr2_locate_firmware(hdw,&fw_entry,"fx2 controller",
1421 hdw->hdw_desc->fx2_firmware.cnt,
1422 hdw->hdw_desc->fx2_firmware.lst);
1424 if (ret == -ENOENT) hdw->fw1_state = FW1_STATE_MISSING;
1428 usb_settoggle(hdw->usb_dev, 0 & 0xf, !(0 & USB_DIR_IN), 0);
1429 usb_clear_halt(hdw->usb_dev, usb_sndbulkpipe(hdw->usb_dev, 0 & 0x7f));
1431 pipe = usb_sndctrlpipe(hdw->usb_dev, 0);
1433 if (fw_entry->size != 0x2000){
1434 pvr2_trace(PVR2_TRACE_ERROR_LEGS,"wrong fx2 firmware size");
1435 release_firmware(fw_entry);
1439 fw_ptr = kmalloc(0x800, GFP_KERNEL);
1440 if (fw_ptr == NULL){
1441 release_firmware(fw_entry);
1445 /* We have to hold the CPU during firmware upload. */
1446 pvr2_hdw_cpureset_assert(hdw,1);
1448 /* upload the firmware to address 0000-1fff in 2048 (=0x800) bytes
1452 for(address = 0; address < fw_entry->size; address += 0x800) {
1453 memcpy(fw_ptr, fw_entry->data + address, 0x800);
1454 ret += usb_control_msg(hdw->usb_dev, pipe, 0xa0, 0x40, address,
1455 0, fw_ptr, 0x800, HZ);
1458 trace_firmware("Upload done, releasing device's CPU");
1460 /* Now release the CPU. It will disconnect and reconnect later. */
1461 pvr2_hdw_cpureset_assert(hdw,0);
1464 release_firmware(fw_entry);
1466 trace_firmware("Upload done (%d bytes sent)",ret);
1468 /* We should have written 8192 bytes */
1470 hdw->fw1_state = FW1_STATE_RELOAD;
1479 * pvr2_upload_firmware2()
1481 * This uploads encoder firmware on endpoint 2.
1485 int pvr2_upload_firmware2(struct pvr2_hdw *hdw)
1487 const struct firmware *fw_entry = NULL;
1489 unsigned int pipe, fw_len, fw_done, bcnt, icnt;
1493 static const char *fw_files[] = {
1494 CX2341X_FIRM_ENC_FILENAME,
1497 if (hdw->hdw_desc->flag_skip_cx23416_firmware) {
1501 trace_firmware("pvr2_upload_firmware2");
1503 ret = pvr2_locate_firmware(hdw,&fw_entry,"encoder",
1504 ARRAY_SIZE(fw_files), fw_files);
1505 if (ret < 0) return ret;
1508 /* Since we're about to completely reinitialize the encoder,
1509 invalidate our cached copy of its configuration state. Next
1510 time we configure the encoder, then we'll fully configure it. */
1511 hdw->enc_cur_valid = 0;
1513 /* Encoder is about to be reset so note that as far as we're
1514 concerned now, the encoder has never been run. */
1515 del_timer_sync(&hdw->encoder_run_timer);
1516 if (hdw->state_encoder_runok) {
1517 hdw->state_encoder_runok = 0;
1518 trace_stbit("state_encoder_runok",hdw->state_encoder_runok);
1521 /* First prepare firmware loading */
1522 ret |= pvr2_write_register(hdw, 0x0048, 0xffffffff); /*interrupt mask*/
1523 ret |= pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000088); /*gpio dir*/
1524 ret |= pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000008); /*gpio output state*/
1525 ret |= pvr2_hdw_cmd_deep_reset(hdw);
1526 ret |= pvr2_write_register(hdw, 0xa064, 0x00000000); /*APU command*/
1527 ret |= pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000408); /*gpio dir*/
1528 ret |= pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000008); /*gpio output state*/
1529 ret |= pvr2_write_register(hdw, 0x9058, 0xffffffed); /*VPU ctrl*/
1530 ret |= pvr2_write_register(hdw, 0x9054, 0xfffffffd); /*reset hw blocks*/
1531 ret |= pvr2_write_register(hdw, 0x07f8, 0x80000800); /*encoder SDRAM refresh*/
1532 ret |= pvr2_write_register(hdw, 0x07fc, 0x0000001a); /*encoder SDRAM pre-charge*/
1533 ret |= pvr2_write_register(hdw, 0x0700, 0x00000000); /*I2C clock*/
1534 ret |= pvr2_write_register(hdw, 0xaa00, 0x00000000); /*unknown*/
1535 ret |= pvr2_write_register(hdw, 0xaa04, 0x00057810); /*unknown*/
1536 ret |= pvr2_write_register(hdw, 0xaa10, 0x00148500); /*unknown*/
1537 ret |= pvr2_write_register(hdw, 0xaa18, 0x00840000); /*unknown*/
1538 ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_FWPOST1);
1539 ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_MEMSEL | (1 << 8) | (0 << 16));
1542 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1543 "firmware2 upload prep failed, ret=%d",ret);
1544 release_firmware(fw_entry);
1548 /* Now send firmware */
1550 fw_len = fw_entry->size;
1552 if (fw_len % sizeof(u32)) {
1553 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1554 "size of %s firmware"
1555 " must be a multiple of %zu bytes",
1556 fw_files[fwidx],sizeof(u32));
1557 release_firmware(fw_entry);
1562 fw_ptr = kmalloc(FIRMWARE_CHUNK_SIZE, GFP_KERNEL);
1563 if (fw_ptr == NULL){
1564 release_firmware(fw_entry);
1565 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1566 "failed to allocate memory for firmware2 upload");
1571 pipe = usb_sndbulkpipe(hdw->usb_dev, PVR2_FIRMWARE_ENDPOINT);
1574 for (fw_done = 0; fw_done < fw_len;) {
1575 bcnt = fw_len - fw_done;
1576 if (bcnt > FIRMWARE_CHUNK_SIZE) bcnt = FIRMWARE_CHUNK_SIZE;
1577 memcpy(fw_ptr, fw_entry->data + fw_done, bcnt);
1578 /* Usbsnoop log shows that we must swap bytes... */
1579 /* Some background info: The data being swapped here is a
1580 firmware image destined for the mpeg encoder chip that
1581 lives at the other end of a USB endpoint. The encoder
1582 chip always talks in 32 bit chunks and its storage is
1583 organized into 32 bit words. However from the file
1584 system to the encoder chip everything is purely a byte
1585 stream. The firmware file's contents are always 32 bit
1586 swapped from what the encoder expects. Thus the need
1587 always exists to swap the bytes regardless of the endian
1588 type of the host processor and therefore swab32() makes
1590 for (icnt = 0; icnt < bcnt/4 ; icnt++)
1591 ((u32 *)fw_ptr)[icnt] = swab32(((u32 *)fw_ptr)[icnt]);
1593 ret |= usb_bulk_msg(hdw->usb_dev, pipe, fw_ptr,bcnt,
1594 &actual_length, HZ);
1595 ret |= (actual_length != bcnt);
1600 trace_firmware("upload of %s : %i / %i ",
1601 fw_files[fwidx],fw_done,fw_len);
1604 release_firmware(fw_entry);
1607 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1608 "firmware2 upload transfer failure");
1614 ret |= pvr2_write_register(hdw, 0x9054, 0xffffffff); /*reset hw blocks*/
1615 ret |= pvr2_write_register(hdw, 0x9058, 0xffffffe8); /*VPU ctrl*/
1616 ret |= pvr2_issue_simple_cmd(hdw,FX2CMD_MEMSEL | (1 << 8) | (0 << 16));
1619 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1620 "firmware2 upload post-proc failure");
1624 if (hdw->hdw_desc->signal_routing_scheme ==
1625 PVR2_ROUTING_SCHEME_GOTVIEW) {
1626 /* Ensure that GPIO 11 is set to output for GOTVIEW
1628 pvr2_hdw_gpio_chg_dir(hdw,(1 << 11),~0);
1634 static const char *pvr2_get_state_name(unsigned int st)
1636 if (st < ARRAY_SIZE(pvr2_state_names)) {
1637 return pvr2_state_names[st];
1642 static int pvr2_decoder_enable(struct pvr2_hdw *hdw,int enablefl)
1644 if (!hdw->decoder_ctrl) {
1645 if (!hdw->flag_decoder_missed) {
1646 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1647 "WARNING: No decoder present");
1648 hdw->flag_decoder_missed = !0;
1649 trace_stbit("flag_decoder_missed",
1650 hdw->flag_decoder_missed);
1654 hdw->decoder_ctrl->enable(hdw->decoder_ctrl->ctxt,enablefl);
1659 void pvr2_hdw_set_decoder(struct pvr2_hdw *hdw,struct pvr2_decoder_ctrl *ptr)
1661 if (hdw->decoder_ctrl == ptr) return;
1662 hdw->decoder_ctrl = ptr;
1663 if (hdw->decoder_ctrl && hdw->flag_decoder_missed) {
1664 hdw->flag_decoder_missed = 0;
1665 trace_stbit("flag_decoder_missed",
1666 hdw->flag_decoder_missed);
1667 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1668 "Decoder has appeared");
1669 pvr2_hdw_state_sched(hdw);
1674 int pvr2_hdw_get_state(struct pvr2_hdw *hdw)
1676 return hdw->master_state;
1680 static int pvr2_hdw_untrip_unlocked(struct pvr2_hdw *hdw)
1682 if (!hdw->flag_tripped) return 0;
1683 hdw->flag_tripped = 0;
1684 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1685 "Clearing driver error statuss");
1690 int pvr2_hdw_untrip(struct pvr2_hdw *hdw)
1693 LOCK_TAKE(hdw->big_lock); do {
1694 fl = pvr2_hdw_untrip_unlocked(hdw);
1695 } while (0); LOCK_GIVE(hdw->big_lock);
1696 if (fl) pvr2_hdw_state_sched(hdw);
1703 int pvr2_hdw_get_streaming(struct pvr2_hdw *hdw)
1705 return hdw->state_pipeline_req != 0;
1709 int pvr2_hdw_set_streaming(struct pvr2_hdw *hdw,int enable_flag)
1712 LOCK_TAKE(hdw->big_lock); do {
1713 pvr2_hdw_untrip_unlocked(hdw);
1714 if ((!enable_flag) != !(hdw->state_pipeline_req)) {
1715 hdw->state_pipeline_req = enable_flag != 0;
1716 pvr2_trace(PVR2_TRACE_START_STOP,
1717 "/*--TRACE_STREAM--*/ %s",
1718 enable_flag ? "enable" : "disable");
1720 pvr2_hdw_state_sched(hdw);
1721 } while (0); LOCK_GIVE(hdw->big_lock);
1722 if ((ret = pvr2_hdw_wait(hdw,0)) < 0) return ret;
1724 while ((st = hdw->master_state) != PVR2_STATE_RUN) {
1725 if (st != PVR2_STATE_READY) return -EIO;
1726 if ((ret = pvr2_hdw_wait(hdw,st)) < 0) return ret;
1733 int pvr2_hdw_set_stream_type(struct pvr2_hdw *hdw,enum pvr2_config config)
1736 LOCK_TAKE(hdw->big_lock);
1737 if ((fl = (hdw->desired_stream_type != config)) != 0) {
1738 hdw->desired_stream_type = config;
1739 hdw->state_pipeline_config = 0;
1740 trace_stbit("state_pipeline_config",
1741 hdw->state_pipeline_config);
1742 pvr2_hdw_state_sched(hdw);
1744 LOCK_GIVE(hdw->big_lock);
1746 return pvr2_hdw_wait(hdw,0);
1750 static int get_default_tuner_type(struct pvr2_hdw *hdw)
1752 int unit_number = hdw->unit_number;
1754 if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1755 tp = tuner[unit_number];
1757 if (tp < 0) return -EINVAL;
1758 hdw->tuner_type = tp;
1759 hdw->tuner_updated = !0;
1764 static v4l2_std_id get_default_standard(struct pvr2_hdw *hdw)
1766 int unit_number = hdw->unit_number;
1768 if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1769 tp = video_std[unit_number];
1776 static unsigned int get_default_error_tolerance(struct pvr2_hdw *hdw)
1778 int unit_number = hdw->unit_number;
1780 if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1781 tp = tolerance[unit_number];
1787 static int pvr2_hdw_check_firmware(struct pvr2_hdw *hdw)
1789 /* Try a harmless request to fetch the eeprom's address over
1790 endpoint 1. See what happens. Only the full FX2 image can
1791 respond to this. If this probe fails then likely the FX2
1792 firmware needs be loaded. */
1794 LOCK_TAKE(hdw->ctl_lock); do {
1795 hdw->cmd_buffer[0] = FX2CMD_GET_EEPROM_ADDR;
1796 result = pvr2_send_request_ex(hdw,HZ*1,!0,
1799 if (result < 0) break;
1800 } while(0); LOCK_GIVE(hdw->ctl_lock);
1802 pvr2_trace(PVR2_TRACE_INIT,
1803 "Probe of device endpoint 1 result status %d",
1806 pvr2_trace(PVR2_TRACE_INIT,
1807 "Probe of device endpoint 1 succeeded");
1812 struct pvr2_std_hack {
1813 v4l2_std_id pat; /* Pattern to match */
1814 v4l2_std_id msk; /* Which bits we care about */
1815 v4l2_std_id std; /* What additional standards or default to set */
1818 /* This data structure labels specific combinations of standards from
1819 tveeprom that we'll try to recognize. If we recognize one, then assume
1820 a specified default standard to use. This is here because tveeprom only
1821 tells us about available standards not the intended default standard (if
1822 any) for the device in question. We guess the default based on what has
1823 been reported as available. Note that this is only for guessing a
1824 default - which can always be overridden explicitly - and if the user
1825 has otherwise named a default then that default will always be used in
1826 place of this table. */
1827 static const struct pvr2_std_hack std_eeprom_maps[] = {
1829 .pat = V4L2_STD_B|V4L2_STD_GH,
1830 .std = V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_PAL_G,
1834 .std = V4L2_STD_NTSC_M,
1837 .pat = V4L2_STD_PAL_I,
1838 .std = V4L2_STD_PAL_I,
1841 .pat = V4L2_STD_SECAM_L|V4L2_STD_SECAM_LC,
1842 .std = V4L2_STD_SECAM_L|V4L2_STD_SECAM_LC,
1846 .std = V4L2_STD_PAL_D|V4L2_STD_PAL_D1|V4L2_STD_PAL_K,
1850 static void pvr2_hdw_setup_std(struct pvr2_hdw *hdw)
1854 v4l2_std_id std1,std2,std3;
1856 std1 = get_default_standard(hdw);
1857 std3 = std1 ? 0 : hdw->hdw_desc->default_std_mask;
1859 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),hdw->std_mask_eeprom);
1860 pvr2_trace(PVR2_TRACE_STD,
1861 "Supported video standard(s) reported available"
1862 " in hardware: %.*s",
1865 hdw->std_mask_avail = hdw->std_mask_eeprom;
1867 std2 = (std1|std3) & ~hdw->std_mask_avail;
1869 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std2);
1870 pvr2_trace(PVR2_TRACE_STD,
1871 "Expanding supported video standards"
1872 " to include: %.*s",
1874 hdw->std_mask_avail |= std2;
1877 pvr2_hdw_internal_set_std_avail(hdw);
1880 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std1);
1881 pvr2_trace(PVR2_TRACE_STD,
1882 "Initial video standard forced to %.*s",
1884 hdw->std_mask_cur = std1;
1885 hdw->std_dirty = !0;
1886 pvr2_hdw_internal_find_stdenum(hdw);
1890 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),std3);
1891 pvr2_trace(PVR2_TRACE_STD,
1892 "Initial video standard"
1893 " (determined by device type): %.*s",bcnt,buf);
1894 hdw->std_mask_cur = std3;
1895 hdw->std_dirty = !0;
1896 pvr2_hdw_internal_find_stdenum(hdw);
1902 for (idx = 0; idx < ARRAY_SIZE(std_eeprom_maps); idx++) {
1903 if (std_eeprom_maps[idx].msk ?
1904 ((std_eeprom_maps[idx].pat ^
1905 hdw->std_mask_eeprom) &
1906 std_eeprom_maps[idx].msk) :
1907 (std_eeprom_maps[idx].pat !=
1908 hdw->std_mask_eeprom)) continue;
1909 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),
1910 std_eeprom_maps[idx].std);
1911 pvr2_trace(PVR2_TRACE_STD,
1912 "Initial video standard guessed as %.*s",
1914 hdw->std_mask_cur = std_eeprom_maps[idx].std;
1915 hdw->std_dirty = !0;
1916 pvr2_hdw_internal_find_stdenum(hdw);
1921 if (hdw->std_enum_cnt > 1) {
1922 // Autoselect the first listed standard
1923 hdw->std_enum_cur = 1;
1924 hdw->std_mask_cur = hdw->std_defs[hdw->std_enum_cur-1].id;
1925 hdw->std_dirty = !0;
1926 pvr2_trace(PVR2_TRACE_STD,
1927 "Initial video standard auto-selected to %s",
1928 hdw->std_defs[hdw->std_enum_cur-1].name);
1932 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1933 "Unable to select a viable initial video standard");
1937 static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
1941 struct pvr2_ctrl *cptr;
1943 if (hdw->hdw_desc->fx2_firmware.cnt) {
1946 (hdw->usb_intf->cur_altsetting->desc.bNumEndpoints
1949 pvr2_trace(PVR2_TRACE_INIT,
1950 "USB endpoint config looks strange"
1951 "; possibly firmware needs to be"
1956 reloadFl = !pvr2_hdw_check_firmware(hdw);
1958 pvr2_trace(PVR2_TRACE_INIT,
1959 "Check for FX2 firmware failed"
1960 "; possibly firmware needs to be"
1965 if (pvr2_upload_firmware1(hdw) != 0) {
1966 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
1967 "Failure uploading firmware1");
1972 hdw->fw1_state = FW1_STATE_OK;
1974 if (!pvr2_hdw_dev_ok(hdw)) return;
1976 for (idx = 0; idx < hdw->hdw_desc->client_modules.cnt; idx++) {
1977 request_module(hdw->hdw_desc->client_modules.lst[idx]);
1980 if (!hdw->hdw_desc->flag_no_powerup) {
1981 pvr2_hdw_cmd_powerup(hdw);
1982 if (!pvr2_hdw_dev_ok(hdw)) return;
1985 /* Take the IR chip out of reset, if appropriate */
1986 if (hdw->hdw_desc->ir_scheme == PVR2_IR_SCHEME_ZILOG) {
1987 pvr2_issue_simple_cmd(hdw,
1988 FX2CMD_HCW_ZILOG_RESET |
1993 // This step MUST happen after the earlier powerup step.
1994 pvr2_i2c_track_init(hdw);
1995 pvr2_i2c_core_init(hdw);
1996 if (!pvr2_hdw_dev_ok(hdw)) return;
1998 for (idx = 0; idx < CTRLDEF_COUNT; idx++) {
1999 cptr = hdw->controls + idx;
2000 if (cptr->info->skip_init) continue;
2001 if (!cptr->info->set_value) continue;
2002 cptr->info->set_value(cptr,~0,cptr->info->default_value);
2005 /* Set up special default values for the television and radio
2006 frequencies here. It's not really important what these defaults
2007 are, but I set them to something usable in the Chicago area just
2008 to make driver testing a little easier. */
2010 hdw->freqValTelevision = default_tv_freq;
2011 hdw->freqValRadio = default_radio_freq;
2013 // Do not use pvr2_reset_ctl_endpoints() here. It is not
2014 // thread-safe against the normal pvr2_send_request() mechanism.
2015 // (We should make it thread safe).
2017 if (hdw->hdw_desc->flag_has_hauppauge_rom) {
2018 ret = pvr2_hdw_get_eeprom_addr(hdw);
2019 if (!pvr2_hdw_dev_ok(hdw)) return;
2021 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2022 "Unable to determine location of eeprom,"
2025 hdw->eeprom_addr = ret;
2026 pvr2_eeprom_analyze(hdw);
2027 if (!pvr2_hdw_dev_ok(hdw)) return;
2030 hdw->tuner_type = hdw->hdw_desc->default_tuner_type;
2031 hdw->tuner_updated = !0;
2032 hdw->std_mask_eeprom = V4L2_STD_ALL;
2035 if (hdw->serial_number) {
2036 idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2037 "sn-%lu", hdw->serial_number);
2038 } else if (hdw->unit_number >= 0) {
2039 idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2041 hdw->unit_number + 'a');
2043 idx = scnprintf(hdw->identifier, sizeof(hdw->identifier) - 1,
2046 hdw->identifier[idx] = 0;
2048 pvr2_hdw_setup_std(hdw);
2050 if (!get_default_tuner_type(hdw)) {
2051 pvr2_trace(PVR2_TRACE_INIT,
2052 "pvr2_hdw_setup: Tuner type overridden to %d",
2056 pvr2_i2c_core_check_stale(hdw);
2057 hdw->tuner_updated = 0;
2059 if (!pvr2_hdw_dev_ok(hdw)) return;
2061 if (hdw->hdw_desc->signal_routing_scheme ==
2062 PVR2_ROUTING_SCHEME_GOTVIEW) {
2063 /* Ensure that GPIO 11 is set to output for GOTVIEW
2065 pvr2_hdw_gpio_chg_dir(hdw,(1 << 11),~0);
2068 pvr2_hdw_commit_setup(hdw);
2070 hdw->vid_stream = pvr2_stream_create();
2071 if (!pvr2_hdw_dev_ok(hdw)) return;
2072 pvr2_trace(PVR2_TRACE_INIT,
2073 "pvr2_hdw_setup: video stream is %p",hdw->vid_stream);
2074 if (hdw->vid_stream) {
2075 idx = get_default_error_tolerance(hdw);
2077 pvr2_trace(PVR2_TRACE_INIT,
2078 "pvr2_hdw_setup: video stream %p"
2079 " setting tolerance %u",
2080 hdw->vid_stream,idx);
2082 pvr2_stream_setup(hdw->vid_stream,hdw->usb_dev,
2083 PVR2_VID_ENDPOINT,idx);
2086 if (!pvr2_hdw_dev_ok(hdw)) return;
2088 hdw->flag_init_ok = !0;
2090 pvr2_hdw_state_sched(hdw);
2094 /* Set up the structure and attempt to put the device into a usable state.
2095 This can be a time-consuming operation, which is why it is not done
2096 internally as part of the create() step. */
2097 static void pvr2_hdw_setup(struct pvr2_hdw *hdw)
2099 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_setup(hdw=%p) begin",hdw);
2101 pvr2_hdw_setup_low(hdw);
2102 pvr2_trace(PVR2_TRACE_INIT,
2103 "pvr2_hdw_setup(hdw=%p) done, ok=%d init_ok=%d",
2104 hdw,pvr2_hdw_dev_ok(hdw),hdw->flag_init_ok);
2105 if (pvr2_hdw_dev_ok(hdw)) {
2106 if (hdw->flag_init_ok) {
2109 "Device initialization"
2110 " completed successfully.");
2113 if (hdw->fw1_state == FW1_STATE_RELOAD) {
2116 "Device microcontroller firmware"
2117 " (re)loaded; it should now reset"
2122 PVR2_TRACE_ERROR_LEGS,
2123 "Device initialization was not successful.");
2124 if (hdw->fw1_state == FW1_STATE_MISSING) {
2126 PVR2_TRACE_ERROR_LEGS,
2127 "Giving up since device"
2128 " microcontroller firmware"
2129 " appears to be missing.");
2135 PVR2_TRACE_ERROR_LEGS,
2136 "Attempting pvrusb2 recovery by reloading"
2137 " primary firmware.");
2139 PVR2_TRACE_ERROR_LEGS,
2140 "If this works, device should disconnect"
2141 " and reconnect in a sane state.");
2142 hdw->fw1_state = FW1_STATE_UNKNOWN;
2143 pvr2_upload_firmware1(hdw);
2146 PVR2_TRACE_ERROR_LEGS,
2147 "***WARNING*** pvrusb2 device hardware"
2148 " appears to be jammed"
2149 " and I can't clear it.");
2151 PVR2_TRACE_ERROR_LEGS,
2152 "You might need to power cycle"
2153 " the pvrusb2 device"
2154 " in order to recover.");
2157 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_setup(hdw=%p) end",hdw);
2161 /* Perform second stage initialization. Set callback pointer first so that
2162 we can avoid a possible initialization race (if the kernel thread runs
2163 before the callback has been set). */
2164 int pvr2_hdw_initialize(struct pvr2_hdw *hdw,
2165 void (*callback_func)(void *),
2166 void *callback_data)
2168 LOCK_TAKE(hdw->big_lock); do {
2169 if (hdw->flag_disconnected) {
2170 /* Handle a race here: If we're already
2171 disconnected by this point, then give up. If we
2172 get past this then we'll remain connected for
2173 the duration of initialization since the entire
2174 initialization sequence is now protected by the
2178 hdw->state_data = callback_data;
2179 hdw->state_func = callback_func;
2180 pvr2_hdw_setup(hdw);
2181 } while (0); LOCK_GIVE(hdw->big_lock);
2182 return hdw->flag_init_ok;
2186 /* Create, set up, and return a structure for interacting with the
2187 underlying hardware. */
2188 struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
2189 const struct usb_device_id *devid)
2191 unsigned int idx,cnt1,cnt2,m;
2192 struct pvr2_hdw *hdw = NULL;
2194 struct pvr2_ctrl *cptr;
2195 struct usb_device *usb_dev;
2196 const struct pvr2_device_desc *hdw_desc;
2198 struct v4l2_queryctrl qctrl;
2199 struct pvr2_ctl_info *ciptr;
2201 usb_dev = interface_to_usbdev(intf);
2203 hdw_desc = (const struct pvr2_device_desc *)(devid->driver_info);
2205 if (hdw_desc == NULL) {
2206 pvr2_trace(PVR2_TRACE_INIT, "pvr2_hdw_create:"
2207 " No device description pointer,"
2208 " unable to continue.");
2209 pvr2_trace(PVR2_TRACE_INIT, "If you have a new device type,"
2210 " please contact Mike Isely <isely@pobox.com>"
2211 " to get it included in the driver\n");
2215 hdw = kzalloc(sizeof(*hdw),GFP_KERNEL);
2216 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_create: hdw=%p, type \"%s\"",
2217 hdw,hdw_desc->description);
2218 if (!hdw) goto fail;
2220 init_timer(&hdw->quiescent_timer);
2221 hdw->quiescent_timer.data = (unsigned long)hdw;
2222 hdw->quiescent_timer.function = pvr2_hdw_quiescent_timeout;
2224 init_timer(&hdw->encoder_wait_timer);
2225 hdw->encoder_wait_timer.data = (unsigned long)hdw;
2226 hdw->encoder_wait_timer.function = pvr2_hdw_encoder_wait_timeout;
2228 init_timer(&hdw->encoder_run_timer);
2229 hdw->encoder_run_timer.data = (unsigned long)hdw;
2230 hdw->encoder_run_timer.function = pvr2_hdw_encoder_run_timeout;
2232 hdw->master_state = PVR2_STATE_DEAD;
2234 init_waitqueue_head(&hdw->state_wait_data);
2236 hdw->tuner_signal_stale = !0;
2237 cx2341x_fill_defaults(&hdw->enc_ctl_state);
2239 /* Calculate which inputs are OK */
2241 if (hdw_desc->flag_has_analogtuner) m |= 1 << PVR2_CVAL_INPUT_TV;
2242 if (hdw_desc->digital_control_scheme != PVR2_DIGITAL_SCHEME_NONE) {
2243 m |= 1 << PVR2_CVAL_INPUT_DTV;
2245 if (hdw_desc->flag_has_svideo) m |= 1 << PVR2_CVAL_INPUT_SVIDEO;
2246 if (hdw_desc->flag_has_composite) m |= 1 << PVR2_CVAL_INPUT_COMPOSITE;
2247 if (hdw_desc->flag_has_fmradio) m |= 1 << PVR2_CVAL_INPUT_RADIO;
2248 hdw->input_avail_mask = m;
2249 hdw->input_allowed_mask = hdw->input_avail_mask;
2251 /* If not a hybrid device, pathway_state never changes. So
2252 initialize it here to what it should forever be. */
2253 if (!(hdw->input_avail_mask & (1 << PVR2_CVAL_INPUT_DTV))) {
2254 hdw->pathway_state = PVR2_PATHWAY_ANALOG;
2255 } else if (!(hdw->input_avail_mask & (1 << PVR2_CVAL_INPUT_TV))) {
2256 hdw->pathway_state = PVR2_PATHWAY_DIGITAL;
2259 hdw->control_cnt = CTRLDEF_COUNT;
2260 hdw->control_cnt += MPEGDEF_COUNT;
2261 hdw->controls = kzalloc(sizeof(struct pvr2_ctrl) * hdw->control_cnt,
2263 if (!hdw->controls) goto fail;
2264 hdw->hdw_desc = hdw_desc;
2265 for (idx = 0; idx < hdw->control_cnt; idx++) {
2266 cptr = hdw->controls + idx;
2269 for (idx = 0; idx < 32; idx++) {
2270 hdw->std_mask_ptrs[idx] = hdw->std_mask_names[idx];
2272 for (idx = 0; idx < CTRLDEF_COUNT; idx++) {
2273 cptr = hdw->controls + idx;
2274 cptr->info = control_defs+idx;
2277 /* Ensure that default input choice is a valid one. */
2278 m = hdw->input_avail_mask;
2279 if (m) for (idx = 0; idx < (sizeof(m) << 3); idx++) {
2280 if (!((1 << idx) & m)) continue;
2281 hdw->input_val = idx;
2285 /* Define and configure additional controls from cx2341x module. */
2286 hdw->mpeg_ctrl_info = kzalloc(
2287 sizeof(*(hdw->mpeg_ctrl_info)) * MPEGDEF_COUNT, GFP_KERNEL);
2288 if (!hdw->mpeg_ctrl_info) goto fail;
2289 for (idx = 0; idx < MPEGDEF_COUNT; idx++) {
2290 cptr = hdw->controls + idx + CTRLDEF_COUNT;
2291 ciptr = &(hdw->mpeg_ctrl_info[idx].info);
2292 ciptr->desc = hdw->mpeg_ctrl_info[idx].desc;
2293 ciptr->name = mpeg_ids[idx].strid;
2294 ciptr->v4l_id = mpeg_ids[idx].id;
2295 ciptr->skip_init = !0;
2296 ciptr->get_value = ctrl_cx2341x_get;
2297 ciptr->get_v4lflags = ctrl_cx2341x_getv4lflags;
2298 ciptr->is_dirty = ctrl_cx2341x_is_dirty;
2299 if (!idx) ciptr->clear_dirty = ctrl_cx2341x_clear_dirty;
2300 qctrl.id = ciptr->v4l_id;
2301 cx2341x_ctrl_query(&hdw->enc_ctl_state,&qctrl);
2302 if (!(qctrl.flags & V4L2_CTRL_FLAG_READ_ONLY)) {
2303 ciptr->set_value = ctrl_cx2341x_set;
2305 strncpy(hdw->mpeg_ctrl_info[idx].desc,qctrl.name,
2306 PVR2_CTLD_INFO_DESC_SIZE);
2307 hdw->mpeg_ctrl_info[idx].desc[PVR2_CTLD_INFO_DESC_SIZE-1] = 0;
2308 ciptr->default_value = qctrl.default_value;
2309 switch (qctrl.type) {
2311 case V4L2_CTRL_TYPE_INTEGER:
2312 ciptr->type = pvr2_ctl_int;
2313 ciptr->def.type_int.min_value = qctrl.minimum;
2314 ciptr->def.type_int.max_value = qctrl.maximum;
2316 case V4L2_CTRL_TYPE_BOOLEAN:
2317 ciptr->type = pvr2_ctl_bool;
2319 case V4L2_CTRL_TYPE_MENU:
2320 ciptr->type = pvr2_ctl_enum;
2321 ciptr->def.type_enum.value_names =
2322 cx2341x_ctrl_get_menu(&hdw->enc_ctl_state,
2325 ciptr->def.type_enum.value_names[cnt1] != NULL;
2327 ciptr->def.type_enum.count = cnt1;
2333 // Initialize video standard enum dynamic control
2334 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDENUM);
2336 memcpy(&hdw->std_info_enum,cptr->info,
2337 sizeof(hdw->std_info_enum));
2338 cptr->info = &hdw->std_info_enum;
2341 // Initialize control data regarding video standard masks
2342 valid_std_mask = pvr2_std_get_usable();
2343 for (idx = 0; idx < 32; idx++) {
2344 if (!(valid_std_mask & (1 << idx))) continue;
2345 cnt1 = pvr2_std_id_to_str(
2346 hdw->std_mask_names[idx],
2347 sizeof(hdw->std_mask_names[idx])-1,
2349 hdw->std_mask_names[idx][cnt1] = 0;
2351 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDAVAIL);
2353 memcpy(&hdw->std_info_avail,cptr->info,
2354 sizeof(hdw->std_info_avail));
2355 cptr->info = &hdw->std_info_avail;
2356 hdw->std_info_avail.def.type_bitmask.bit_names =
2358 hdw->std_info_avail.def.type_bitmask.valid_bits =
2361 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR);
2363 memcpy(&hdw->std_info_cur,cptr->info,
2364 sizeof(hdw->std_info_cur));
2365 cptr->info = &hdw->std_info_cur;
2366 hdw->std_info_cur.def.type_bitmask.bit_names =
2368 hdw->std_info_avail.def.type_bitmask.valid_bits =
2372 hdw->cropcap_stale = !0;
2373 hdw->eeprom_addr = -1;
2374 hdw->unit_number = -1;
2375 hdw->v4l_minor_number_video = -1;
2376 hdw->v4l_minor_number_vbi = -1;
2377 hdw->v4l_minor_number_radio = -1;
2378 hdw->ctl_write_buffer = kmalloc(PVR2_CTL_BUFFSIZE,GFP_KERNEL);
2379 if (!hdw->ctl_write_buffer) goto fail;
2380 hdw->ctl_read_buffer = kmalloc(PVR2_CTL_BUFFSIZE,GFP_KERNEL);
2381 if (!hdw->ctl_read_buffer) goto fail;
2382 hdw->ctl_write_urb = usb_alloc_urb(0,GFP_KERNEL);
2383 if (!hdw->ctl_write_urb) goto fail;
2384 hdw->ctl_read_urb = usb_alloc_urb(0,GFP_KERNEL);
2385 if (!hdw->ctl_read_urb) goto fail;
2387 if (v4l2_device_register(&usb_dev->dev, &hdw->v4l2_dev) != 0) {
2388 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
2389 "Error registering with v4l core, giving up");
2392 mutex_lock(&pvr2_unit_mtx); do {
2393 for (idx = 0; idx < PVR_NUM; idx++) {
2394 if (unit_pointers[idx]) continue;
2395 hdw->unit_number = idx;
2396 unit_pointers[idx] = hdw;
2399 } while (0); mutex_unlock(&pvr2_unit_mtx);
2402 cnt2 = scnprintf(hdw->name+cnt1,sizeof(hdw->name)-cnt1,"pvrusb2");
2404 if (hdw->unit_number >= 0) {
2405 cnt2 = scnprintf(hdw->name+cnt1,sizeof(hdw->name)-cnt1,"_%c",
2406 ('a' + hdw->unit_number));
2409 if (cnt1 >= sizeof(hdw->name)) cnt1 = sizeof(hdw->name)-1;
2410 hdw->name[cnt1] = 0;
2412 hdw->workqueue = create_singlethread_workqueue(hdw->name);
2413 INIT_WORK(&hdw->workpoll,pvr2_hdw_worker_poll);
2414 INIT_WORK(&hdw->worki2csync,pvr2_hdw_worker_i2c);
2416 pvr2_trace(PVR2_TRACE_INIT,"Driver unit number is %d, name is %s",
2417 hdw->unit_number,hdw->name);
2419 hdw->tuner_type = -1;
2422 hdw->usb_intf = intf;
2423 hdw->usb_dev = usb_dev;
2425 usb_make_path(hdw->usb_dev, hdw->bus_info, sizeof(hdw->bus_info));
2427 ifnum = hdw->usb_intf->cur_altsetting->desc.bInterfaceNumber;
2428 usb_set_interface(hdw->usb_dev,ifnum,0);
2430 mutex_init(&hdw->ctl_lock_mutex);
2431 mutex_init(&hdw->big_lock_mutex);
2436 del_timer_sync(&hdw->quiescent_timer);
2437 del_timer_sync(&hdw->encoder_run_timer);
2438 del_timer_sync(&hdw->encoder_wait_timer);
2439 if (hdw->workqueue) {
2440 flush_workqueue(hdw->workqueue);
2441 destroy_workqueue(hdw->workqueue);
2442 hdw->workqueue = NULL;
2444 usb_free_urb(hdw->ctl_read_urb);
2445 usb_free_urb(hdw->ctl_write_urb);
2446 kfree(hdw->ctl_read_buffer);
2447 kfree(hdw->ctl_write_buffer);
2448 kfree(hdw->controls);
2449 kfree(hdw->mpeg_ctrl_info);
2450 kfree(hdw->std_defs);
2451 kfree(hdw->std_enum_names);
2458 /* Remove _all_ associations between this driver and the underlying USB
2460 static void pvr2_hdw_remove_usb_stuff(struct pvr2_hdw *hdw)
2462 if (hdw->flag_disconnected) return;
2463 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_remove_usb_stuff: hdw=%p",hdw);
2464 if (hdw->ctl_read_urb) {
2465 usb_kill_urb(hdw->ctl_read_urb);
2466 usb_free_urb(hdw->ctl_read_urb);
2467 hdw->ctl_read_urb = NULL;
2469 if (hdw->ctl_write_urb) {
2470 usb_kill_urb(hdw->ctl_write_urb);
2471 usb_free_urb(hdw->ctl_write_urb);
2472 hdw->ctl_write_urb = NULL;
2474 if (hdw->ctl_read_buffer) {
2475 kfree(hdw->ctl_read_buffer);
2476 hdw->ctl_read_buffer = NULL;
2478 if (hdw->ctl_write_buffer) {
2479 kfree(hdw->ctl_write_buffer);
2480 hdw->ctl_write_buffer = NULL;
2482 hdw->flag_disconnected = !0;
2483 /* If we don't do this, then there will be a dangling struct device
2484 reference to our disappearing device persisting inside the V4L
2486 if (hdw->v4l2_dev.dev) {
2487 dev_set_drvdata(hdw->v4l2_dev.dev, NULL);
2488 hdw->v4l2_dev.dev = NULL;
2490 hdw->usb_dev = NULL;
2491 hdw->usb_intf = NULL;
2492 pvr2_hdw_render_useless(hdw);
2496 /* Destroy hardware interaction structure */
2497 void pvr2_hdw_destroy(struct pvr2_hdw *hdw)
2500 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_destroy: hdw=%p",hdw);
2501 if (hdw->workqueue) {
2502 flush_workqueue(hdw->workqueue);
2503 destroy_workqueue(hdw->workqueue);
2504 hdw->workqueue = NULL;
2506 del_timer_sync(&hdw->quiescent_timer);
2507 del_timer_sync(&hdw->encoder_run_timer);
2508 del_timer_sync(&hdw->encoder_wait_timer);
2509 if (hdw->fw_buffer) {
2510 kfree(hdw->fw_buffer);
2511 hdw->fw_buffer = NULL;
2513 if (hdw->vid_stream) {
2514 pvr2_stream_destroy(hdw->vid_stream);
2515 hdw->vid_stream = NULL;
2517 if (hdw->decoder_ctrl) {
2518 hdw->decoder_ctrl->detach(hdw->decoder_ctrl->ctxt);
2520 pvr2_i2c_core_done(hdw);
2521 pvr2_i2c_track_done(hdw);
2522 v4l2_device_unregister(&hdw->v4l2_dev);
2523 pvr2_hdw_remove_usb_stuff(hdw);
2524 mutex_lock(&pvr2_unit_mtx); do {
2525 if ((hdw->unit_number >= 0) &&
2526 (hdw->unit_number < PVR_NUM) &&
2527 (unit_pointers[hdw->unit_number] == hdw)) {
2528 unit_pointers[hdw->unit_number] = NULL;
2530 } while (0); mutex_unlock(&pvr2_unit_mtx);
2531 kfree(hdw->controls);
2532 kfree(hdw->mpeg_ctrl_info);
2533 kfree(hdw->std_defs);
2534 kfree(hdw->std_enum_names);
2539 int pvr2_hdw_dev_ok(struct pvr2_hdw *hdw)
2541 return (hdw && hdw->flag_ok);
2545 /* Called when hardware has been unplugged */
2546 void pvr2_hdw_disconnect(struct pvr2_hdw *hdw)
2548 pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_disconnect(hdw=%p)",hdw);
2549 LOCK_TAKE(hdw->big_lock);
2550 LOCK_TAKE(hdw->ctl_lock);
2551 pvr2_hdw_remove_usb_stuff(hdw);
2552 LOCK_GIVE(hdw->ctl_lock);
2553 LOCK_GIVE(hdw->big_lock);
2557 // Attempt to autoselect an appropriate value for std_enum_cur given
2558 // whatever is currently in std_mask_cur
2559 static void pvr2_hdw_internal_find_stdenum(struct pvr2_hdw *hdw)
2562 for (idx = 1; idx < hdw->std_enum_cnt; idx++) {
2563 if (hdw->std_defs[idx-1].id == hdw->std_mask_cur) {
2564 hdw->std_enum_cur = idx;
2568 hdw->std_enum_cur = 0;
2572 // Calculate correct set of enumerated standards based on currently known
2573 // set of available standards bits.
2574 static void pvr2_hdw_internal_set_std_avail(struct pvr2_hdw *hdw)
2576 struct v4l2_standard *newstd;
2577 unsigned int std_cnt;
2580 newstd = pvr2_std_create_enum(&std_cnt,hdw->std_mask_avail);
2582 if (hdw->std_defs) {
2583 kfree(hdw->std_defs);
2584 hdw->std_defs = NULL;
2586 hdw->std_enum_cnt = 0;
2587 if (hdw->std_enum_names) {
2588 kfree(hdw->std_enum_names);
2589 hdw->std_enum_names = NULL;
2594 PVR2_TRACE_ERROR_LEGS,
2595 "WARNING: Failed to identify any viable standards");
2597 hdw->std_enum_names = kmalloc(sizeof(char *)*(std_cnt+1),GFP_KERNEL);
2598 hdw->std_enum_names[0] = "none";
2599 for (idx = 0; idx < std_cnt; idx++) {
2600 hdw->std_enum_names[idx+1] =
2603 // Set up the dynamic control for this standard
2604 hdw->std_info_enum.def.type_enum.value_names = hdw->std_enum_names;
2605 hdw->std_info_enum.def.type_enum.count = std_cnt+1;
2606 hdw->std_defs = newstd;
2607 hdw->std_enum_cnt = std_cnt+1;
2608 hdw->std_enum_cur = 0;
2609 hdw->std_info_cur.def.type_bitmask.valid_bits = hdw->std_mask_avail;
2613 int pvr2_hdw_get_stdenum_value(struct pvr2_hdw *hdw,
2614 struct v4l2_standard *std,
2618 if (!idx) return ret;
2619 LOCK_TAKE(hdw->big_lock); do {
2620 if (idx >= hdw->std_enum_cnt) break;
2622 memcpy(std,hdw->std_defs+idx,sizeof(*std));
2624 } while (0); LOCK_GIVE(hdw->big_lock);
2629 /* Get the number of defined controls */
2630 unsigned int pvr2_hdw_get_ctrl_count(struct pvr2_hdw *hdw)
2632 return hdw->control_cnt;
2636 /* Retrieve a control handle given its index (0..count-1) */
2637 struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_index(struct pvr2_hdw *hdw,
2640 if (idx >= hdw->control_cnt) return NULL;
2641 return hdw->controls + idx;
2645 /* Retrieve a control handle given its index (0..count-1) */
2646 struct pvr2_ctrl *pvr2_hdw_get_ctrl_by_id(struct pvr2_hdw *hdw,
2647 unsigned int ctl_id)
2649 struct pvr2_ctrl *cptr;
2653 /* This could be made a lot more efficient, but for now... */
2654 for (idx = 0; idx < hdw->control_cnt; idx++) {
2655 cptr = hdw->controls + idx;
2656 i = cptr->info->internal_id;
2657 if (i && (i == ctl_id)) return cptr;
2663 /* Given a V4L ID, retrieve the control structure associated with it. */
2664 struct pvr2_ctrl *pvr2_hdw_get_ctrl_v4l(struct pvr2_hdw *hdw,unsigned int ctl_id)
2666 struct pvr2_ctrl *cptr;
2670 /* This could be made a lot more efficient, but for now... */
2671 for (idx = 0; idx < hdw->control_cnt; idx++) {
2672 cptr = hdw->controls + idx;
2673 i = cptr->info->v4l_id;
2674 if (i && (i == ctl_id)) return cptr;
2680 /* Given a V4L ID for its immediate predecessor, retrieve the control
2681 structure associated with it. */
2682 struct pvr2_ctrl *pvr2_hdw_get_ctrl_nextv4l(struct pvr2_hdw *hdw,
2683 unsigned int ctl_id)
2685 struct pvr2_ctrl *cptr,*cp2;
2689 /* This could be made a lot more efficient, but for now... */
2691 for (idx = 0; idx < hdw->control_cnt; idx++) {
2692 cptr = hdw->controls + idx;
2693 i = cptr->info->v4l_id;
2695 if (i <= ctl_id) continue;
2696 if (cp2 && (cp2->info->v4l_id < i)) continue;
2704 static const char *get_ctrl_typename(enum pvr2_ctl_type tp)
2707 case pvr2_ctl_int: return "integer";
2708 case pvr2_ctl_enum: return "enum";
2709 case pvr2_ctl_bool: return "boolean";
2710 case pvr2_ctl_bitmask: return "bitmask";
2716 /* Figure out if we need to commit control changes. If so, mark internal
2717 state flags to indicate this fact and return true. Otherwise do nothing
2718 else and return false. */
2719 static int pvr2_hdw_commit_setup(struct pvr2_hdw *hdw)
2722 struct pvr2_ctrl *cptr;
2724 int commit_flag = 0;
2726 unsigned int bcnt,ccnt;
2728 for (idx = 0; idx < hdw->control_cnt; idx++) {
2729 cptr = hdw->controls + idx;
2730 if (!cptr->info->is_dirty) continue;
2731 if (!cptr->info->is_dirty(cptr)) continue;
2734 if (!(pvrusb2_debug & PVR2_TRACE_CTL)) continue;
2735 bcnt = scnprintf(buf,sizeof(buf),"\"%s\" <-- ",
2738 cptr->info->get_value(cptr,&value);
2739 pvr2_ctrl_value_to_sym_internal(cptr,~0,value,
2741 sizeof(buf)-bcnt,&ccnt);
2743 bcnt += scnprintf(buf+bcnt,sizeof(buf)-bcnt," <%s>",
2744 get_ctrl_typename(cptr->info->type));
2745 pvr2_trace(PVR2_TRACE_CTL,
2746 "/*--TRACE_COMMIT--*/ %.*s",
2751 /* Nothing has changed */
2755 hdw->state_pipeline_config = 0;
2756 trace_stbit("state_pipeline_config",hdw->state_pipeline_config);
2757 pvr2_hdw_state_sched(hdw);
2763 /* Perform all operations needed to commit all control changes. This must
2764 be performed in synchronization with the pipeline state and is thus
2765 expected to be called as part of the driver's worker thread. Return
2766 true if commit successful, otherwise return false to indicate that
2767 commit isn't possible at this time. */
2768 static int pvr2_hdw_commit_execute(struct pvr2_hdw *hdw)
2771 struct pvr2_ctrl *cptr;
2772 int disruptive_change;
2774 /* Handle some required side effects when the video standard is
2776 if (hdw->std_dirty) {
2779 if (hdw->std_mask_cur & V4L2_STD_525_60) {
2786 /* Rewrite the vertical resolution to be appropriate to the
2787 video standard that has been selected. */
2788 if (nvres != hdw->res_ver_val) {
2789 hdw->res_ver_val = nvres;
2790 hdw->res_ver_dirty = !0;
2792 /* Rewrite the GOP size to be appropriate to the video
2793 standard that has been selected. */
2794 if (gop_size != hdw->enc_ctl_state.video_gop_size) {
2795 struct v4l2_ext_controls cs;
2796 struct v4l2_ext_control c1;
2797 memset(&cs, 0, sizeof(cs));
2798 memset(&c1, 0, sizeof(c1));
2801 c1.id = V4L2_CID_MPEG_VIDEO_GOP_SIZE;
2802 c1.value = gop_size;
2803 cx2341x_ext_ctrls(&hdw->enc_ctl_state, 0, &cs,
2804 VIDIOC_S_EXT_CTRLS);
2808 if (hdw->input_dirty && hdw->state_pathway_ok &&
2809 (((hdw->input_val == PVR2_CVAL_INPUT_DTV) ?
2810 PVR2_PATHWAY_DIGITAL : PVR2_PATHWAY_ANALOG) !=
2811 hdw->pathway_state)) {
2812 /* Change of mode being asked for... */
2813 hdw->state_pathway_ok = 0;
2814 trace_stbit("state_pathway_ok",hdw->state_pathway_ok);
2816 if (!hdw->state_pathway_ok) {
2817 /* Can't commit anything until pathway is ok. */
2820 /* The broadcast decoder can only scale down, so if
2821 * res_*_dirty && crop window < output format ==> enlarge crop.
2823 * The mpeg encoder receives fields of res_hor_val dots and
2824 * res_ver_val halflines. Limits: hor<=720, ver<=576.
2826 if (hdw->res_hor_dirty && hdw->cropw_val < hdw->res_hor_val) {
2827 hdw->cropw_val = hdw->res_hor_val;
2828 hdw->cropw_dirty = !0;
2829 } else if (hdw->cropw_dirty) {
2830 hdw->res_hor_dirty = !0; /* must rescale */
2831 hdw->res_hor_val = min(720, hdw->cropw_val);
2833 if (hdw->res_ver_dirty && hdw->croph_val < hdw->res_ver_val) {
2834 hdw->croph_val = hdw->res_ver_val;
2835 hdw->croph_dirty = !0;
2836 } else if (hdw->croph_dirty) {
2837 int nvres = hdw->std_mask_cur & V4L2_STD_525_60 ? 480 : 576;
2838 hdw->res_ver_dirty = !0;
2839 hdw->res_ver_val = min(nvres, hdw->croph_val);
2842 /* If any of the below has changed, then we can't do the update
2843 while the pipeline is running. Pipeline must be paused first
2844 and decoder -> encoder connection be made quiescent before we
2848 hdw->enc_unsafe_stale ||
2850 hdw->res_ver_dirty ||
2851 hdw->res_hor_dirty ||
2855 (hdw->active_stream_type != hdw->desired_stream_type));
2856 if (disruptive_change && !hdw->state_pipeline_idle) {
2857 /* Pipeline is not idle; we can't proceed. Arrange to
2858 cause pipeline to stop so that we can try this again
2860 hdw->state_pipeline_pause = !0;
2864 if (hdw->srate_dirty) {
2865 /* Write new sample rate into control structure since
2866 * the master copy is stale. We must track srate
2867 * separate from the mpeg control structure because
2868 * other logic also uses this value. */
2869 struct v4l2_ext_controls cs;
2870 struct v4l2_ext_control c1;
2871 memset(&cs,0,sizeof(cs));
2872 memset(&c1,0,sizeof(c1));
2875 c1.id = V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ;
2876 c1.value = hdw->srate_val;
2877 cx2341x_ext_ctrls(&hdw->enc_ctl_state, 0, &cs,VIDIOC_S_EXT_CTRLS);
2880 /* Scan i2c core at this point - before we clear all the dirty
2881 bits. Various parts of the i2c core will notice dirty bits as
2882 appropriate and arrange to broadcast or directly send updates to
2883 the client drivers in order to keep everything in sync */
2884 pvr2_i2c_core_check_stale(hdw);
2886 for (idx = 0; idx < hdw->control_cnt; idx++) {
2887 cptr = hdw->controls + idx;
2888 if (!cptr->info->clear_dirty) continue;
2889 cptr->info->clear_dirty(cptr);
2892 if (hdw->active_stream_type != hdw->desired_stream_type) {
2893 /* Handle any side effects of stream config here */
2894 hdw->active_stream_type = hdw->desired_stream_type;
2897 if (hdw->hdw_desc->signal_routing_scheme ==
2898 PVR2_ROUTING_SCHEME_GOTVIEW) {
2900 /* Handle GOTVIEW audio switching */
2901 pvr2_hdw_gpio_get_out(hdw,&b);
2902 if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
2904 pvr2_hdw_gpio_chg_out(hdw,(1 << 11),~0);
2907 pvr2_hdw_gpio_chg_out(hdw,(1 << 11),0);
2911 /* Now execute i2c core update */
2912 pvr2_i2c_core_sync(hdw);
2914 if ((hdw->pathway_state == PVR2_PATHWAY_ANALOG) &&
2915 hdw->state_encoder_run) {
2916 /* If encoder isn't running or it can't be touched, then
2917 this will get worked out later when we start the
2919 if (pvr2_encoder_adjust(hdw) < 0) return !0;
2922 hdw->state_pipeline_config = !0;
2923 /* Hardware state may have changed in a way to cause the cropping
2924 capabilities to have changed. So mark it stale, which will
2925 cause a later re-fetch. */
2926 trace_stbit("state_pipeline_config",hdw->state_pipeline_config);
2931 int pvr2_hdw_commit_ctl(struct pvr2_hdw *hdw)
2934 LOCK_TAKE(hdw->big_lock);
2935 fl = pvr2_hdw_commit_setup(hdw);
2936 LOCK_GIVE(hdw->big_lock);
2938 return pvr2_hdw_wait(hdw,0);
2942 static void pvr2_hdw_worker_i2c(struct work_struct *work)
2944 struct pvr2_hdw *hdw = container_of(work,struct pvr2_hdw,worki2csync);
2945 LOCK_TAKE(hdw->big_lock); do {
2946 pvr2_i2c_core_sync(hdw);
2947 } while (0); LOCK_GIVE(hdw->big_lock);
2951 static void pvr2_hdw_worker_poll(struct work_struct *work)
2954 struct pvr2_hdw *hdw = container_of(work,struct pvr2_hdw,workpoll);
2955 LOCK_TAKE(hdw->big_lock); do {
2956 fl = pvr2_hdw_state_eval(hdw);
2957 } while (0); LOCK_GIVE(hdw->big_lock);
2958 if (fl && hdw->state_func) {
2959 hdw->state_func(hdw->state_data);
2964 static int pvr2_hdw_wait(struct pvr2_hdw *hdw,int state)
2966 return wait_event_interruptible(
2967 hdw->state_wait_data,
2968 (hdw->state_stale == 0) &&
2969 (!state || (hdw->master_state != state)));
2973 /* Return name for this driver instance */
2974 const char *pvr2_hdw_get_driver_name(struct pvr2_hdw *hdw)
2980 const char *pvr2_hdw_get_desc(struct pvr2_hdw *hdw)
2982 return hdw->hdw_desc->description;
2986 const char *pvr2_hdw_get_type(struct pvr2_hdw *hdw)
2988 return hdw->hdw_desc->shortname;
2992 int pvr2_hdw_is_hsm(struct pvr2_hdw *hdw)
2995 LOCK_TAKE(hdw->ctl_lock); do {
2996 hdw->cmd_buffer[0] = FX2CMD_GET_USB_SPEED;
2997 result = pvr2_send_request(hdw,
3000 if (result < 0) break;
3001 result = (hdw->cmd_buffer[0] != 0);
3002 } while(0); LOCK_GIVE(hdw->ctl_lock);
3007 /* Execute poll of tuner status */
3008 void pvr2_hdw_execute_tuner_poll(struct pvr2_hdw *hdw)
3010 LOCK_TAKE(hdw->big_lock); do {
3011 pvr2_hdw_status_poll(hdw);
3012 } while (0); LOCK_GIVE(hdw->big_lock);
3016 static int pvr2_hdw_check_cropcap(struct pvr2_hdw *hdw)
3018 if (!hdw->cropcap_stale) {
3021 pvr2_hdw_status_poll(hdw);
3022 if (hdw->cropcap_stale) {
3029 /* Return information about cropping capabilities */
3030 int pvr2_hdw_get_cropcap(struct pvr2_hdw *hdw, struct v4l2_cropcap *pp)
3033 LOCK_TAKE(hdw->big_lock);
3034 stat = pvr2_hdw_check_cropcap(hdw);
3036 memcpy(pp, &hdw->cropcap_info, sizeof(hdw->cropcap_info));
3038 LOCK_GIVE(hdw->big_lock);
3043 /* Return information about the tuner */
3044 int pvr2_hdw_get_tuner_status(struct pvr2_hdw *hdw,struct v4l2_tuner *vtp)
3046 LOCK_TAKE(hdw->big_lock); do {
3047 if (hdw->tuner_signal_stale) {
3048 pvr2_hdw_status_poll(hdw);
3050 memcpy(vtp,&hdw->tuner_signal_info,sizeof(struct v4l2_tuner));
3051 } while (0); LOCK_GIVE(hdw->big_lock);
3056 /* Get handle to video output stream */
3057 struct pvr2_stream *pvr2_hdw_get_video_stream(struct pvr2_hdw *hp)
3059 return hp->vid_stream;
3063 void pvr2_hdw_trigger_module_log(struct pvr2_hdw *hdw)
3065 int nr = pvr2_hdw_get_unit_number(hdw);
3066 LOCK_TAKE(hdw->big_lock); do {
3067 hdw->log_requested = !0;
3068 printk(KERN_INFO "pvrusb2: ================= START STATUS CARD #%d =================\n", nr);
3069 pvr2_i2c_core_check_stale(hdw);
3070 pvr2_i2c_core_sync(hdw);
3071 hdw->log_requested = 0;
3072 pvr2_trace(PVR2_TRACE_INFO,"cx2341x config:");
3073 cx2341x_log_status(&hdw->enc_ctl_state, "pvrusb2");
3074 pvr2_hdw_state_log_state(hdw);
3075 printk(KERN_INFO "pvrusb2: ================== END STATUS CARD #%d ==================\n", nr);
3076 } while (0); LOCK_GIVE(hdw->big_lock);
3080 /* Grab EEPROM contents, needed for direct method. */
3081 #define EEPROM_SIZE 8192
3082 #define trace_eeprom(...) pvr2_trace(PVR2_TRACE_EEPROM,__VA_ARGS__)
3083 static u8 *pvr2_full_eeprom_fetch(struct pvr2_hdw *hdw)
3085 struct i2c_msg msg[2];
3094 eeprom = kmalloc(EEPROM_SIZE,GFP_KERNEL);
3096 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3097 "Failed to allocate memory"
3098 " required to read eeprom");
3102 trace_eeprom("Value for eeprom addr from controller was 0x%x",
3104 addr = hdw->eeprom_addr;
3105 /* Seems that if the high bit is set, then the *real* eeprom
3106 address is shifted right now bit position (noticed this in
3107 newer PVR USB2 hardware) */
3108 if (addr & 0x80) addr >>= 1;
3110 /* FX2 documentation states that a 16bit-addressed eeprom is
3111 expected if the I2C address is an odd number (yeah, this is
3112 strange but it's what they do) */
3113 mode16 = (addr & 1);
3114 eepromSize = (mode16 ? EEPROM_SIZE : 256);
3115 trace_eeprom("Examining %d byte eeprom at location 0x%x"
3116 " using %d bit addressing",eepromSize,addr,
3121 msg[0].len = mode16 ? 2 : 1;
3124 msg[1].flags = I2C_M_RD;
3126 /* We have to do the actual eeprom data fetch ourselves, because
3127 (1) we're only fetching part of the eeprom, and (2) if we were
3128 getting the whole thing our I2C driver can't grab it in one
3129 pass - which is what tveeprom is otherwise going to attempt */
3130 memset(eeprom,0,EEPROM_SIZE);
3131 for (tcnt = 0; tcnt < EEPROM_SIZE; tcnt += pcnt) {
3133 if (pcnt + tcnt > EEPROM_SIZE) pcnt = EEPROM_SIZE-tcnt;
3134 offs = tcnt + (eepromSize - EEPROM_SIZE);
3136 iadd[0] = offs >> 8;
3142 msg[1].buf = eeprom+tcnt;
3143 if ((ret = i2c_transfer(&hdw->i2c_adap,
3144 msg,ARRAY_SIZE(msg))) != 2) {
3145 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3146 "eeprom fetch set offs err=%d",ret);
3155 void pvr2_hdw_cpufw_set_enabled(struct pvr2_hdw *hdw,
3162 LOCK_TAKE(hdw->big_lock); do {
3163 if ((hdw->fw_buffer == NULL) == !enable_flag) break;
3166 pvr2_trace(PVR2_TRACE_FIRMWARE,
3167 "Cleaning up after CPU firmware fetch");
3168 kfree(hdw->fw_buffer);
3169 hdw->fw_buffer = NULL;
3171 if (hdw->fw_cpu_flag) {
3172 /* Now release the CPU. It will disconnect
3173 and reconnect later. */
3174 pvr2_hdw_cpureset_assert(hdw,0);
3179 hdw->fw_cpu_flag = (prom_flag == 0);
3180 if (hdw->fw_cpu_flag) {
3181 pvr2_trace(PVR2_TRACE_FIRMWARE,
3182 "Preparing to suck out CPU firmware");
3183 hdw->fw_size = 0x2000;
3184 hdw->fw_buffer = kzalloc(hdw->fw_size,GFP_KERNEL);
3185 if (!hdw->fw_buffer) {
3190 /* We have to hold the CPU during firmware upload. */
3191 pvr2_hdw_cpureset_assert(hdw,1);
3193 /* download the firmware from address 0000-1fff in 2048
3194 (=0x800) bytes chunk. */
3196 pvr2_trace(PVR2_TRACE_FIRMWARE,
3197 "Grabbing CPU firmware");
3198 pipe = usb_rcvctrlpipe(hdw->usb_dev, 0);
3199 for(address = 0; address < hdw->fw_size;
3201 ret = usb_control_msg(hdw->usb_dev,pipe,
3204 hdw->fw_buffer+address,
3209 pvr2_trace(PVR2_TRACE_FIRMWARE,
3210 "Done grabbing CPU firmware");
3212 pvr2_trace(PVR2_TRACE_FIRMWARE,
3213 "Sucking down EEPROM contents");
3214 hdw->fw_buffer = pvr2_full_eeprom_fetch(hdw);
3215 if (!hdw->fw_buffer) {
3216 pvr2_trace(PVR2_TRACE_FIRMWARE,
3217 "EEPROM content suck failed.");
3220 hdw->fw_size = EEPROM_SIZE;
3221 pvr2_trace(PVR2_TRACE_FIRMWARE,
3222 "Done sucking down EEPROM contents");
3225 } while (0); LOCK_GIVE(hdw->big_lock);
3229 /* Return true if we're in a mode for retrieval CPU firmware */
3230 int pvr2_hdw_cpufw_get_enabled(struct pvr2_hdw *hdw)
3232 return hdw->fw_buffer != NULL;
3236 int pvr2_hdw_cpufw_get(struct pvr2_hdw *hdw,unsigned int offs,
3237 char *buf,unsigned int cnt)
3240 LOCK_TAKE(hdw->big_lock); do {
3244 if (!hdw->fw_buffer) {
3249 if (offs >= hdw->fw_size) {
3250 pvr2_trace(PVR2_TRACE_FIRMWARE,
3251 "Read firmware data offs=%d EOF",
3257 if (offs + cnt > hdw->fw_size) cnt = hdw->fw_size - offs;
3259 memcpy(buf,hdw->fw_buffer+offs,cnt);
3261 pvr2_trace(PVR2_TRACE_FIRMWARE,
3262 "Read firmware data offs=%d cnt=%d",
3265 } while (0); LOCK_GIVE(hdw->big_lock);
3271 int pvr2_hdw_v4l_get_minor_number(struct pvr2_hdw *hdw,
3272 enum pvr2_v4l_type index)
3275 case pvr2_v4l_type_video: return hdw->v4l_minor_number_video;
3276 case pvr2_v4l_type_vbi: return hdw->v4l_minor_number_vbi;
3277 case pvr2_v4l_type_radio: return hdw->v4l_minor_number_radio;
3283 /* Store a v4l minor device number */
3284 void pvr2_hdw_v4l_store_minor_number(struct pvr2_hdw *hdw,
3285 enum pvr2_v4l_type index,int v)
3288 case pvr2_v4l_type_video: hdw->v4l_minor_number_video = v;
3289 case pvr2_v4l_type_vbi: hdw->v4l_minor_number_vbi = v;
3290 case pvr2_v4l_type_radio: hdw->v4l_minor_number_radio = v;
3296 static void pvr2_ctl_write_complete(struct urb *urb)
3298 struct pvr2_hdw *hdw = urb->context;
3299 hdw->ctl_write_pend_flag = 0;
3300 if (hdw->ctl_read_pend_flag) return;
3301 complete(&hdw->ctl_done);
3305 static void pvr2_ctl_read_complete(struct urb *urb)
3307 struct pvr2_hdw *hdw = urb->context;
3308 hdw->ctl_read_pend_flag = 0;
3309 if (hdw->ctl_write_pend_flag) return;
3310 complete(&hdw->ctl_done);
3314 static void pvr2_ctl_timeout(unsigned long data)
3316 struct pvr2_hdw *hdw = (struct pvr2_hdw *)data;
3317 if (hdw->ctl_write_pend_flag || hdw->ctl_read_pend_flag) {
3318 hdw->ctl_timeout_flag = !0;
3319 if (hdw->ctl_write_pend_flag)
3320 usb_unlink_urb(hdw->ctl_write_urb);
3321 if (hdw->ctl_read_pend_flag)
3322 usb_unlink_urb(hdw->ctl_read_urb);
3327 /* Issue a command and get a response from the device. This extended
3328 version includes a probe flag (which if set means that device errors
3329 should not be logged or treated as fatal) and a timeout in jiffies.
3330 This can be used to non-lethally probe the health of endpoint 1. */
3331 static int pvr2_send_request_ex(struct pvr2_hdw *hdw,
3332 unsigned int timeout,int probe_fl,
3333 void *write_data,unsigned int write_len,
3334 void *read_data,unsigned int read_len)
3338 struct timer_list timer;
3339 if (!hdw->ctl_lock_held) {
3340 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3341 "Attempted to execute control transfer"
3345 if (!hdw->flag_ok && !probe_fl) {
3346 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3347 "Attempted to execute control transfer"
3348 " when device not ok");
3351 if (!(hdw->ctl_read_urb && hdw->ctl_write_urb)) {
3353 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3354 "Attempted to execute control transfer"
3355 " when USB is disconnected");
3360 /* Ensure that we have sane parameters */
3361 if (!write_data) write_len = 0;
3362 if (!read_data) read_len = 0;
3363 if (write_len > PVR2_CTL_BUFFSIZE) {
3365 PVR2_TRACE_ERROR_LEGS,
3366 "Attempted to execute %d byte"
3367 " control-write transfer (limit=%d)",
3368 write_len,PVR2_CTL_BUFFSIZE);
3371 if (read_len > PVR2_CTL_BUFFSIZE) {
3373 PVR2_TRACE_ERROR_LEGS,
3374 "Attempted to execute %d byte"
3375 " control-read transfer (limit=%d)",
3376 write_len,PVR2_CTL_BUFFSIZE);
3379 if ((!write_len) && (!read_len)) {
3381 PVR2_TRACE_ERROR_LEGS,
3382 "Attempted to execute null control transfer?");
3387 hdw->cmd_debug_state = 1;
3389 hdw->cmd_debug_code = ((unsigned char *)write_data)[0];
3391 hdw->cmd_debug_code = 0;
3393 hdw->cmd_debug_write_len = write_len;
3394 hdw->cmd_debug_read_len = read_len;
3396 /* Initialize common stuff */
3397 init_completion(&hdw->ctl_done);
3398 hdw->ctl_timeout_flag = 0;
3399 hdw->ctl_write_pend_flag = 0;
3400 hdw->ctl_read_pend_flag = 0;
3402 timer.expires = jiffies + timeout;
3403 timer.data = (unsigned long)hdw;
3404 timer.function = pvr2_ctl_timeout;
3407 hdw->cmd_debug_state = 2;
3408 /* Transfer write data to internal buffer */
3409 for (idx = 0; idx < write_len; idx++) {
3410 hdw->ctl_write_buffer[idx] =
3411 ((unsigned char *)write_data)[idx];
3413 /* Initiate a write request */
3414 usb_fill_bulk_urb(hdw->ctl_write_urb,
3416 usb_sndbulkpipe(hdw->usb_dev,
3417 PVR2_CTL_WRITE_ENDPOINT),
3418 hdw->ctl_write_buffer,
3420 pvr2_ctl_write_complete,
3422 hdw->ctl_write_urb->actual_length = 0;
3423 hdw->ctl_write_pend_flag = !0;
3424 status = usb_submit_urb(hdw->ctl_write_urb,GFP_KERNEL);
3426 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3427 "Failed to submit write-control"
3428 " URB status=%d",status);
3429 hdw->ctl_write_pend_flag = 0;
3435 hdw->cmd_debug_state = 3;
3436 memset(hdw->ctl_read_buffer,0x43,read_len);
3437 /* Initiate a read request */
3438 usb_fill_bulk_urb(hdw->ctl_read_urb,
3440 usb_rcvbulkpipe(hdw->usb_dev,
3441 PVR2_CTL_READ_ENDPOINT),
3442 hdw->ctl_read_buffer,
3444 pvr2_ctl_read_complete,
3446 hdw->ctl_read_urb->actual_length = 0;
3447 hdw->ctl_read_pend_flag = !0;
3448 status = usb_submit_urb(hdw->ctl_read_urb,GFP_KERNEL);
3450 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3451 "Failed to submit read-control"
3452 " URB status=%d",status);
3453 hdw->ctl_read_pend_flag = 0;
3461 /* Now wait for all I/O to complete */
3462 hdw->cmd_debug_state = 4;
3463 while (hdw->ctl_write_pend_flag || hdw->ctl_read_pend_flag) {
3464 wait_for_completion(&hdw->ctl_done);
3466 hdw->cmd_debug_state = 5;
3469 del_timer_sync(&timer);
3471 hdw->cmd_debug_state = 6;
3474 if (hdw->ctl_timeout_flag) {
3475 status = -ETIMEDOUT;
3477 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3478 "Timed out control-write");
3484 /* Validate results of write request */
3485 if ((hdw->ctl_write_urb->status != 0) &&
3486 (hdw->ctl_write_urb->status != -ENOENT) &&
3487 (hdw->ctl_write_urb->status != -ESHUTDOWN) &&
3488 (hdw->ctl_write_urb->status != -ECONNRESET)) {
3489 /* USB subsystem is reporting some kind of failure
3491 status = hdw->ctl_write_urb->status;
3493 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3494 "control-write URB failure,"
3500 if (hdw->ctl_write_urb->actual_length < write_len) {
3501 /* Failed to write enough data */
3504 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3505 "control-write URB short,"
3506 " expected=%d got=%d",
3508 hdw->ctl_write_urb->actual_length);
3514 /* Validate results of read request */
3515 if ((hdw->ctl_read_urb->status != 0) &&
3516 (hdw->ctl_read_urb->status != -ENOENT) &&
3517 (hdw->ctl_read_urb->status != -ESHUTDOWN) &&
3518 (hdw->ctl_read_urb->status != -ECONNRESET)) {
3519 /* USB subsystem is reporting some kind of failure
3521 status = hdw->ctl_read_urb->status;
3523 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3524 "control-read URB failure,"
3530 if (hdw->ctl_read_urb->actual_length < read_len) {
3531 /* Failed to read enough data */
3534 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3535 "control-read URB short,"
3536 " expected=%d got=%d",
3538 hdw->ctl_read_urb->actual_length);
3542 /* Transfer retrieved data out from internal buffer */
3543 for (idx = 0; idx < read_len; idx++) {
3544 ((unsigned char *)read_data)[idx] =
3545 hdw->ctl_read_buffer[idx];
3551 hdw->cmd_debug_state = 0;
3552 if ((status < 0) && (!probe_fl)) {
3553 pvr2_hdw_render_useless(hdw);
3559 int pvr2_send_request(struct pvr2_hdw *hdw,
3560 void *write_data,unsigned int write_len,
3561 void *read_data,unsigned int read_len)
3563 return pvr2_send_request_ex(hdw,HZ*4,0,
3564 write_data,write_len,
3565 read_data,read_len);
3569 static int pvr2_issue_simple_cmd(struct pvr2_hdw *hdw,u32 cmdcode)
3572 unsigned int cnt = 1;
3573 unsigned int args = 0;
3574 LOCK_TAKE(hdw->ctl_lock);
3575 hdw->cmd_buffer[0] = cmdcode & 0xffu;
3576 args = (cmdcode >> 8) & 0xffu;
3577 args = (args > 2) ? 2 : args;
3580 hdw->cmd_buffer[1] = (cmdcode >> 16) & 0xffu;
3582 hdw->cmd_buffer[2] = (cmdcode >> 24) & 0xffu;
3585 if (pvrusb2_debug & PVR2_TRACE_INIT) {
3587 unsigned int ccnt,bcnt;
3591 ccnt = scnprintf(tbuf+bcnt,
3593 "Sending FX2 command 0x%x",cmdcode);
3595 for (idx = 0; idx < ARRAY_SIZE(pvr2_fx2cmd_desc); idx++) {
3596 if (pvr2_fx2cmd_desc[idx].id == cmdcode) {
3597 ccnt = scnprintf(tbuf+bcnt,
3600 pvr2_fx2cmd_desc[idx].desc);
3606 ccnt = scnprintf(tbuf+bcnt,
3608 " (%u",hdw->cmd_buffer[1]);
3611 ccnt = scnprintf(tbuf+bcnt,
3613 ",%u",hdw->cmd_buffer[2]);
3616 ccnt = scnprintf(tbuf+bcnt,
3621 pvr2_trace(PVR2_TRACE_INIT,"%.*s",bcnt,tbuf);
3623 ret = pvr2_send_request(hdw,hdw->cmd_buffer,cnt,NULL,0);
3624 LOCK_GIVE(hdw->ctl_lock);
3629 int pvr2_write_register(struct pvr2_hdw *hdw, u16 reg, u32 data)
3633 LOCK_TAKE(hdw->ctl_lock);
3635 hdw->cmd_buffer[0] = FX2CMD_REG_WRITE; /* write register prefix */
3636 PVR2_DECOMPOSE_LE(hdw->cmd_buffer,1,data);
3637 hdw->cmd_buffer[5] = 0;
3638 hdw->cmd_buffer[6] = (reg >> 8) & 0xff;
3639 hdw->cmd_buffer[7] = reg & 0xff;
3642 ret = pvr2_send_request(hdw, hdw->cmd_buffer, 8, hdw->cmd_buffer, 0);
3644 LOCK_GIVE(hdw->ctl_lock);
3650 static int pvr2_read_register(struct pvr2_hdw *hdw, u16 reg, u32 *data)
3654 LOCK_TAKE(hdw->ctl_lock);
3656 hdw->cmd_buffer[0] = FX2CMD_REG_READ; /* read register prefix */
3657 hdw->cmd_buffer[1] = 0;
3658 hdw->cmd_buffer[2] = 0;
3659 hdw->cmd_buffer[3] = 0;
3660 hdw->cmd_buffer[4] = 0;
3661 hdw->cmd_buffer[5] = 0;
3662 hdw->cmd_buffer[6] = (reg >> 8) & 0xff;
3663 hdw->cmd_buffer[7] = reg & 0xff;
3665 ret |= pvr2_send_request(hdw, hdw->cmd_buffer, 8, hdw->cmd_buffer, 4);
3666 *data = PVR2_COMPOSE_LE(hdw->cmd_buffer,0);
3668 LOCK_GIVE(hdw->ctl_lock);
3674 void pvr2_hdw_render_useless(struct pvr2_hdw *hdw)
3676 if (!hdw->flag_ok) return;
3677 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3678 "Device being rendered inoperable");
3679 if (hdw->vid_stream) {
3680 pvr2_stream_setup(hdw->vid_stream,NULL,0,0);
3683 trace_stbit("flag_ok",hdw->flag_ok);
3684 pvr2_hdw_state_sched(hdw);
3688 void pvr2_hdw_device_reset(struct pvr2_hdw *hdw)
3691 pvr2_trace(PVR2_TRACE_INIT,"Performing a device reset...");
3692 ret = usb_lock_device_for_reset(hdw->usb_dev,NULL);
3694 ret = usb_reset_device(hdw->usb_dev);
3695 usb_unlock_device(hdw->usb_dev);
3697 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3698 "Failed to lock USB device ret=%d",ret);
3700 if (init_pause_msec) {
3701 pvr2_trace(PVR2_TRACE_INFO,
3702 "Waiting %u msec for hardware to settle",
3704 msleep(init_pause_msec);
3710 void pvr2_hdw_cpureset_assert(struct pvr2_hdw *hdw,int val)
3716 if (!hdw->usb_dev) return;
3718 pvr2_trace(PVR2_TRACE_INIT,"cpureset_assert(%d)",val);
3720 da[0] = val ? 0x01 : 0x00;
3722 /* Write the CPUCS register on the 8051. The lsb of the register
3723 is the reset bit; a 1 asserts reset while a 0 clears it. */
3724 pipe = usb_sndctrlpipe(hdw->usb_dev, 0);
3725 ret = usb_control_msg(hdw->usb_dev,pipe,0xa0,0x40,0xe600,0,da,1,HZ);
3727 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
3728 "cpureset_assert(%d) error=%d",val,ret);
3729 pvr2_hdw_render_useless(hdw);
3734 int pvr2_hdw_cmd_deep_reset(struct pvr2_hdw *hdw)
3736 return pvr2_issue_simple_cmd(hdw,FX2CMD_DEEP_RESET);
3740 int pvr2_hdw_cmd_powerup(struct pvr2_hdw *hdw)
3742 return pvr2_issue_simple_cmd(hdw,FX2CMD_POWER_ON);
3746 int pvr2_hdw_cmd_powerdown(struct pvr2_hdw *hdw)
3748 return pvr2_issue_simple_cmd(hdw,FX2CMD_POWER_OFF);
3752 int pvr2_hdw_cmd_decoder_reset(struct pvr2_hdw *hdw)
3754 if (!hdw->decoder_ctrl) {
3755 pvr2_trace(PVR2_TRACE_INIT,
3756 "Unable to reset decoder: nothing attached");
3760 if (!hdw->decoder_ctrl->force_reset) {
3761 pvr2_trace(PVR2_TRACE_INIT,
3762 "Unable to reset decoder: not implemented");
3766 pvr2_trace(PVR2_TRACE_INIT,
3767 "Requesting decoder reset");
3768 hdw->decoder_ctrl->force_reset(hdw->decoder_ctrl->ctxt);
3773 static int pvr2_hdw_cmd_hcw_demod_reset(struct pvr2_hdw *hdw, int onoff)
3776 return pvr2_issue_simple_cmd(hdw,
3777 FX2CMD_HCW_DEMOD_RESETIN |
3779 ((onoff ? 1 : 0) << 16));
3783 static int pvr2_hdw_cmd_onair_fe_power_ctrl(struct pvr2_hdw *hdw, int onoff)
3786 return pvr2_issue_simple_cmd(hdw,(onoff ?
3787 FX2CMD_ONAIR_DTV_POWER_ON :
3788 FX2CMD_ONAIR_DTV_POWER_OFF));
3792 static int pvr2_hdw_cmd_onair_digital_path_ctrl(struct pvr2_hdw *hdw,
3795 return pvr2_issue_simple_cmd(hdw,(onoff ?
3796 FX2CMD_ONAIR_DTV_STREAMING_ON :
3797 FX2CMD_ONAIR_DTV_STREAMING_OFF));
3801 static void pvr2_hdw_cmd_modeswitch(struct pvr2_hdw *hdw,int digitalFl)
3804 /* Compare digital/analog desired setting with current setting. If
3805 they don't match, fix it... */
3806 cmode = (digitalFl ? PVR2_PATHWAY_DIGITAL : PVR2_PATHWAY_ANALOG);
3807 if (cmode == hdw->pathway_state) {
3808 /* They match; nothing to do */
3812 switch (hdw->hdw_desc->digital_control_scheme) {
3813 case PVR2_DIGITAL_SCHEME_HAUPPAUGE:
3814 pvr2_hdw_cmd_hcw_demod_reset(hdw,digitalFl);
3815 if (cmode == PVR2_PATHWAY_ANALOG) {
3816 /* If moving to analog mode, also force the decoder
3817 to reset. If no decoder is attached, then it's
3818 ok to ignore this because if/when the decoder
3819 attaches, it will reset itself at that time. */
3820 pvr2_hdw_cmd_decoder_reset(hdw);
3823 case PVR2_DIGITAL_SCHEME_ONAIR:
3824 /* Supposedly we should always have the power on whether in
3825 digital or analog mode. But for now do what appears to
3827 pvr2_hdw_cmd_onair_fe_power_ctrl(hdw,digitalFl);
3832 pvr2_hdw_untrip_unlocked(hdw);
3833 hdw->pathway_state = cmode;
3837 static void pvr2_led_ctrl_hauppauge(struct pvr2_hdw *hdw, int onoff)
3839 /* change some GPIO data
3841 * note: bit d7 of dir appears to control the LED,
3842 * so we shut it off here.
3846 pvr2_hdw_gpio_chg_dir(hdw, 0xffffffff, 0x00000481);
3848 pvr2_hdw_gpio_chg_dir(hdw, 0xffffffff, 0x00000401);
3850 pvr2_hdw_gpio_chg_out(hdw, 0xffffffff, 0x00000000);
3854 typedef void (*led_method_func)(struct pvr2_hdw *,int);
3856 static led_method_func led_methods[] = {
3857 [PVR2_LED_SCHEME_HAUPPAUGE] = pvr2_led_ctrl_hauppauge,
3862 static void pvr2_led_ctrl(struct pvr2_hdw *hdw,int onoff)
3864 unsigned int scheme_id;
3867 if ((!onoff) == (!hdw->led_on)) return;
3869 hdw->led_on = onoff != 0;
3871 scheme_id = hdw->hdw_desc->led_scheme;
3872 if (scheme_id < ARRAY_SIZE(led_methods)) {
3873 fp = led_methods[scheme_id];
3878 if (fp) (*fp)(hdw,onoff);
3882 /* Stop / start video stream transport */
3883 static int pvr2_hdw_cmd_usbstream(struct pvr2_hdw *hdw,int runFl)
3887 /* If we're in analog mode, then just issue the usual analog
3889 if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
3890 return pvr2_issue_simple_cmd(hdw,
3892 FX2CMD_STREAMING_ON :
3893 FX2CMD_STREAMING_OFF));
3894 /*Note: Not reached */
3897 if (hdw->pathway_state != PVR2_PATHWAY_DIGITAL) {
3898 /* Whoops, we don't know what mode we're in... */
3902 /* To get here we have to be in digital mode. The mechanism here
3903 is unfortunately different for different vendors. So we switch
3904 on the device's digital scheme attribute in order to figure out
3906 switch (hdw->hdw_desc->digital_control_scheme) {
3907 case PVR2_DIGITAL_SCHEME_HAUPPAUGE:
3908 return pvr2_issue_simple_cmd(hdw,
3910 FX2CMD_HCW_DTV_STREAMING_ON :
3911 FX2CMD_HCW_DTV_STREAMING_OFF));
3912 case PVR2_DIGITAL_SCHEME_ONAIR:
3913 ret = pvr2_issue_simple_cmd(hdw,
3915 FX2CMD_STREAMING_ON :
3916 FX2CMD_STREAMING_OFF));
3917 if (ret) return ret;
3918 return pvr2_hdw_cmd_onair_digital_path_ctrl(hdw,runFl);
3925 /* Evaluate whether or not state_pathway_ok can change */
3926 static int state_eval_pathway_ok(struct pvr2_hdw *hdw)
3928 if (hdw->state_pathway_ok) {
3929 /* Nothing to do if pathway is already ok */
3932 if (!hdw->state_pipeline_idle) {
3933 /* Not allowed to change anything if pipeline is not idle */
3936 pvr2_hdw_cmd_modeswitch(hdw,hdw->input_val == PVR2_CVAL_INPUT_DTV);
3937 hdw->state_pathway_ok = !0;
3938 trace_stbit("state_pathway_ok",hdw->state_pathway_ok);
3943 /* Evaluate whether or not state_encoder_ok can change */
3944 static int state_eval_encoder_ok(struct pvr2_hdw *hdw)
3946 if (hdw->state_encoder_ok) return 0;
3947 if (hdw->flag_tripped) return 0;
3948 if (hdw->state_encoder_run) return 0;
3949 if (hdw->state_encoder_config) return 0;
3950 if (hdw->state_decoder_run) return 0;
3951 if (hdw->state_usbstream_run) return 0;
3952 if (hdw->pathway_state == PVR2_PATHWAY_DIGITAL) {
3953 if (!hdw->hdw_desc->flag_digital_requires_cx23416) return 0;
3954 } else if (hdw->pathway_state != PVR2_PATHWAY_ANALOG) {
3958 if (pvr2_upload_firmware2(hdw) < 0) {
3959 hdw->flag_tripped = !0;
3960 trace_stbit("flag_tripped",hdw->flag_tripped);
3963 hdw->state_encoder_ok = !0;
3964 trace_stbit("state_encoder_ok",hdw->state_encoder_ok);
3969 /* Evaluate whether or not state_encoder_config can change */
3970 static int state_eval_encoder_config(struct pvr2_hdw *hdw)
3972 if (hdw->state_encoder_config) {
3973 if (hdw->state_encoder_ok) {
3974 if (hdw->state_pipeline_req &&
3975 !hdw->state_pipeline_pause) return 0;
3977 hdw->state_encoder_config = 0;
3978 hdw->state_encoder_waitok = 0;
3979 trace_stbit("state_encoder_waitok",hdw->state_encoder_waitok);
3980 /* paranoia - solve race if timer just completed */
3981 del_timer_sync(&hdw->encoder_wait_timer);
3983 if (!hdw->state_pathway_ok ||
3984 (hdw->pathway_state != PVR2_PATHWAY_ANALOG) ||
3985 !hdw->state_encoder_ok ||
3986 !hdw->state_pipeline_idle ||
3987 hdw->state_pipeline_pause ||
3988 !hdw->state_pipeline_req ||
3989 !hdw->state_pipeline_config) {
3990 /* We must reset the enforced wait interval if
3991 anything has happened that might have disturbed
3992 the encoder. This should be a rare case. */
3993 if (timer_pending(&hdw->encoder_wait_timer)) {
3994 del_timer_sync(&hdw->encoder_wait_timer);
3996 if (hdw->state_encoder_waitok) {
3997 /* Must clear the state - therefore we did
3998 something to a state bit and must also
4000 hdw->state_encoder_waitok = 0;
4001 trace_stbit("state_encoder_waitok",
4002 hdw->state_encoder_waitok);
4007 if (!hdw->state_encoder_waitok) {
4008 if (!timer_pending(&hdw->encoder_wait_timer)) {
4009 /* waitok flag wasn't set and timer isn't
4010 running. Check flag once more to avoid
4011 a race then start the timer. This is
4012 the point when we measure out a minimal
4013 quiet interval before doing something to
4015 if (!hdw->state_encoder_waitok) {
4016 hdw->encoder_wait_timer.expires =
4018 (HZ * TIME_MSEC_ENCODER_WAIT
4020 add_timer(&hdw->encoder_wait_timer);
4023 /* We can't continue until we know we have been
4024 quiet for the interval measured by this
4028 pvr2_encoder_configure(hdw);
4029 if (hdw->state_encoder_ok) hdw->state_encoder_config = !0;
4031 trace_stbit("state_encoder_config",hdw->state_encoder_config);
4036 /* Return true if the encoder should not be running. */
4037 static int state_check_disable_encoder_run(struct pvr2_hdw *hdw)
4039 if (!hdw->state_encoder_ok) {
4040 /* Encoder isn't healthy at the moment, so stop it. */
4043 if (!hdw->state_pathway_ok) {
4044 /* Mode is not understood at the moment (i.e. it wants to
4045 change), so encoder must be stopped. */
4049 switch (hdw->pathway_state) {
4050 case PVR2_PATHWAY_ANALOG:
4051 if (!hdw->state_decoder_run) {
4052 /* We're in analog mode and the decoder is not
4053 running; thus the encoder should be stopped as
4058 case PVR2_PATHWAY_DIGITAL:
4059 if (hdw->state_encoder_runok) {
4060 /* This is a funny case. We're in digital mode so
4061 really the encoder should be stopped. However
4062 if it really is running, only kill it after
4063 runok has been set. This gives a chance for the
4064 onair quirk to function (encoder must run
4065 briefly first, at least once, before onair
4066 digital streaming can work). */
4071 /* Unknown mode; so encoder should be stopped. */
4075 /* If we get here, we haven't found a reason to stop the
4081 /* Return true if the encoder should be running. */
4082 static int state_check_enable_encoder_run(struct pvr2_hdw *hdw)
4084 if (!hdw->state_encoder_ok) {
4085 /* Don't run the encoder if it isn't healthy... */
4088 if (!hdw->state_pathway_ok) {
4089 /* Don't run the encoder if we don't (yet) know what mode
4090 we need to be in... */
4094 switch (hdw->pathway_state) {
4095 case PVR2_PATHWAY_ANALOG:
4096 if (hdw->state_decoder_run) {
4097 /* In analog mode, if the decoder is running, then
4102 case PVR2_PATHWAY_DIGITAL:
4103 if ((hdw->hdw_desc->digital_control_scheme ==
4104 PVR2_DIGITAL_SCHEME_ONAIR) &&
4105 !hdw->state_encoder_runok) {
4106 /* This is a quirk. OnAir hardware won't stream
4107 digital until the encoder has been run at least
4108 once, for a minimal period of time (empiricially
4109 measured to be 1/4 second). So if we're on
4110 OnAir hardware and the encoder has never been
4111 run at all, then start the encoder. Normal
4112 state machine logic in the driver will
4113 automatically handle the remaining bits. */
4118 /* For completeness (unknown mode; encoder won't run ever) */
4121 /* If we get here, then we haven't found any reason to run the
4122 encoder, so don't run it. */
4127 /* Evaluate whether or not state_encoder_run can change */
4128 static int state_eval_encoder_run(struct pvr2_hdw *hdw)
4130 if (hdw->state_encoder_run) {
4131 if (!state_check_disable_encoder_run(hdw)) return 0;
4132 if (hdw->state_encoder_ok) {
4133 del_timer_sync(&hdw->encoder_run_timer);
4134 if (pvr2_encoder_stop(hdw) < 0) return !0;
4136 hdw->state_encoder_run = 0;
4138 if (!state_check_enable_encoder_run(hdw)) return 0;
4139 if (pvr2_encoder_start(hdw) < 0) return !0;
4140 hdw->state_encoder_run = !0;
4141 if (!hdw->state_encoder_runok) {
4142 hdw->encoder_run_timer.expires =
4143 jiffies + (HZ * TIME_MSEC_ENCODER_OK / 1000);
4144 add_timer(&hdw->encoder_run_timer);
4147 trace_stbit("state_encoder_run",hdw->state_encoder_run);
4152 /* Timeout function for quiescent timer. */
4153 static void pvr2_hdw_quiescent_timeout(unsigned long data)
4155 struct pvr2_hdw *hdw = (struct pvr2_hdw *)data;
4156 hdw->state_decoder_quiescent = !0;
4157 trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent);
4158 hdw->state_stale = !0;
4159 queue_work(hdw->workqueue,&hdw->workpoll);
4163 /* Timeout function for encoder wait timer. */
4164 static void pvr2_hdw_encoder_wait_timeout(unsigned long data)
4166 struct pvr2_hdw *hdw = (struct pvr2_hdw *)data;
4167 hdw->state_encoder_waitok = !0;
4168 trace_stbit("state_encoder_waitok",hdw->state_encoder_waitok);
4169 hdw->state_stale = !0;
4170 queue_work(hdw->workqueue,&hdw->workpoll);
4174 /* Timeout function for encoder run timer. */
4175 static void pvr2_hdw_encoder_run_timeout(unsigned long data)
4177 struct pvr2_hdw *hdw = (struct pvr2_hdw *)data;
4178 if (!hdw->state_encoder_runok) {
4179 hdw->state_encoder_runok = !0;
4180 trace_stbit("state_encoder_runok",hdw->state_encoder_runok);
4181 hdw->state_stale = !0;
4182 queue_work(hdw->workqueue,&hdw->workpoll);
4187 /* Evaluate whether or not state_decoder_run can change */
4188 static int state_eval_decoder_run(struct pvr2_hdw *hdw)
4190 if (hdw->state_decoder_run) {
4191 if (hdw->state_encoder_ok) {
4192 if (hdw->state_pipeline_req &&
4193 !hdw->state_pipeline_pause &&
4194 hdw->state_pathway_ok) return 0;
4196 if (!hdw->flag_decoder_missed) {
4197 pvr2_decoder_enable(hdw,0);
4199 hdw->state_decoder_quiescent = 0;
4200 hdw->state_decoder_run = 0;
4201 /* paranoia - solve race if timer just completed */
4202 del_timer_sync(&hdw->quiescent_timer);
4204 if (!hdw->state_decoder_quiescent) {
4205 if (!timer_pending(&hdw->quiescent_timer)) {
4206 /* We don't do something about the
4207 quiescent timer until right here because
4208 we also want to catch cases where the
4209 decoder was already not running (like
4210 after initialization) as opposed to
4211 knowing that we had just stopped it.
4212 The second flag check is here to cover a
4213 race - the timer could have run and set
4214 this flag just after the previous check
4215 but before we did the pending check. */
4216 if (!hdw->state_decoder_quiescent) {
4217 hdw->quiescent_timer.expires =
4219 (HZ * TIME_MSEC_DECODER_WAIT
4221 add_timer(&hdw->quiescent_timer);
4224 /* Don't allow decoder to start again until it has
4225 been quiesced first. This little detail should
4226 hopefully further stabilize the encoder. */
4229 if (!hdw->state_pathway_ok ||
4230 (hdw->pathway_state != PVR2_PATHWAY_ANALOG) ||
4231 !hdw->state_pipeline_req ||
4232 hdw->state_pipeline_pause ||
4233 !hdw->state_pipeline_config ||
4234 !hdw->state_encoder_config ||
4235 !hdw->state_encoder_ok) return 0;
4236 del_timer_sync(&hdw->quiescent_timer);
4237 if (hdw->flag_decoder_missed) return 0;
4238 if (pvr2_decoder_enable(hdw,!0) < 0) return 0;
4239 hdw->state_decoder_quiescent = 0;
4240 hdw->state_decoder_run = !0;
4242 trace_stbit("state_decoder_quiescent",hdw->state_decoder_quiescent);
4243 trace_stbit("state_decoder_run",hdw->state_decoder_run);
4248 /* Evaluate whether or not state_usbstream_run can change */
4249 static int state_eval_usbstream_run(struct pvr2_hdw *hdw)
4251 if (hdw->state_usbstream_run) {
4253 if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
4254 fl = (hdw->state_encoder_ok &&
4255 hdw->state_encoder_run);
4256 } else if ((hdw->pathway_state == PVR2_PATHWAY_DIGITAL) &&
4257 (hdw->hdw_desc->flag_digital_requires_cx23416)) {
4258 fl = hdw->state_encoder_ok;
4261 hdw->state_pipeline_req &&
4262 !hdw->state_pipeline_pause &&
4263 hdw->state_pathway_ok) {
4266 pvr2_hdw_cmd_usbstream(hdw,0);
4267 hdw->state_usbstream_run = 0;
4269 if (!hdw->state_pipeline_req ||
4270 hdw->state_pipeline_pause ||
4271 !hdw->state_pathway_ok) return 0;
4272 if (hdw->pathway_state == PVR2_PATHWAY_ANALOG) {
4273 if (!hdw->state_encoder_ok ||
4274 !hdw->state_encoder_run) return 0;
4275 } else if ((hdw->pathway_state == PVR2_PATHWAY_DIGITAL) &&
4276 (hdw->hdw_desc->flag_digital_requires_cx23416)) {
4277 if (!hdw->state_encoder_ok) return 0;
4278 if (hdw->state_encoder_run) return 0;
4279 if (hdw->hdw_desc->digital_control_scheme ==
4280 PVR2_DIGITAL_SCHEME_ONAIR) {
4281 /* OnAir digital receivers won't stream
4282 unless the analog encoder has run first.
4283 Why? I have no idea. But don't even
4284 try until we know the analog side is
4285 known to have run. */
4286 if (!hdw->state_encoder_runok) return 0;
4289 if (pvr2_hdw_cmd_usbstream(hdw,!0) < 0) return 0;
4290 hdw->state_usbstream_run = !0;
4292 trace_stbit("state_usbstream_run",hdw->state_usbstream_run);
4297 /* Attempt to configure pipeline, if needed */
4298 static int state_eval_pipeline_config(struct pvr2_hdw *hdw)
4300 if (hdw->state_pipeline_config ||
4301 hdw->state_pipeline_pause) return 0;
4302 pvr2_hdw_commit_execute(hdw);
4307 /* Update pipeline idle and pipeline pause tracking states based on other
4308 inputs. This must be called whenever the other relevant inputs have
4310 static int state_update_pipeline_state(struct pvr2_hdw *hdw)
4314 /* Update pipeline state */
4315 st = !(hdw->state_encoder_run ||
4316 hdw->state_decoder_run ||
4317 hdw->state_usbstream_run ||
4318 (!hdw->state_decoder_quiescent));
4319 if (!st != !hdw->state_pipeline_idle) {
4320 hdw->state_pipeline_idle = st;
4323 if (hdw->state_pipeline_idle && hdw->state_pipeline_pause) {
4324 hdw->state_pipeline_pause = 0;
4331 typedef int (*state_eval_func)(struct pvr2_hdw *);
4333 /* Set of functions to be run to evaluate various states in the driver. */
4334 static const state_eval_func eval_funcs[] = {
4335 state_eval_pathway_ok,
4336 state_eval_pipeline_config,
4337 state_eval_encoder_ok,
4338 state_eval_encoder_config,
4339 state_eval_decoder_run,
4340 state_eval_encoder_run,
4341 state_eval_usbstream_run,
4345 /* Process various states and return true if we did anything interesting. */
4346 static int pvr2_hdw_state_update(struct pvr2_hdw *hdw)
4349 int state_updated = 0;
4352 if (!hdw->state_stale) return 0;
4353 if ((hdw->fw1_state != FW1_STATE_OK) ||
4355 hdw->state_stale = 0;
4358 /* This loop is the heart of the entire driver. It keeps trying to
4359 evaluate various bits of driver state until nothing changes for
4360 one full iteration. Each "bit of state" tracks some global
4361 aspect of the driver, e.g. whether decoder should run, if
4362 pipeline is configured, usb streaming is on, etc. We separately
4363 evaluate each of those questions based on other driver state to
4364 arrive at the correct running configuration. */
4367 state_update_pipeline_state(hdw);
4368 /* Iterate over each bit of state */
4369 for (i = 0; (i<ARRAY_SIZE(eval_funcs)) && hdw->flag_ok; i++) {
4370 if ((*eval_funcs[i])(hdw)) {
4373 state_update_pipeline_state(hdw);
4376 } while (check_flag && hdw->flag_ok);
4377 hdw->state_stale = 0;
4378 trace_stbit("state_stale",hdw->state_stale);
4379 return state_updated;
4383 static unsigned int print_input_mask(unsigned int msk,
4384 char *buf,unsigned int acnt)
4386 unsigned int idx,ccnt;
4387 unsigned int tcnt = 0;
4388 for (idx = 0; idx < ARRAY_SIZE(control_values_input); idx++) {
4389 if (!((1 << idx) & msk)) continue;
4390 ccnt = scnprintf(buf+tcnt,
4394 control_values_input[idx]);
4401 static const char *pvr2_pathway_state_name(int id)
4404 case PVR2_PATHWAY_ANALOG: return "analog";
4405 case PVR2_PATHWAY_DIGITAL: return "digital";
4406 default: return "unknown";
4411 static unsigned int pvr2_hdw_report_unlocked(struct pvr2_hdw *hdw,int which,
4412 char *buf,unsigned int acnt)
4418 "driver:%s%s%s%s%s <mode=%s>",
4419 (hdw->flag_ok ? " <ok>" : " <fail>"),
4420 (hdw->flag_init_ok ? " <init>" : " <uninitialized>"),
4421 (hdw->flag_disconnected ? " <disconnected>" :
4423 (hdw->flag_tripped ? " <tripped>" : ""),
4424 (hdw->flag_decoder_missed ? " <no decoder>" : ""),
4425 pvr2_pathway_state_name(hdw->pathway_state));
4430 "pipeline:%s%s%s%s",
4431 (hdw->state_pipeline_idle ? " <idle>" : ""),
4432 (hdw->state_pipeline_config ?
4433 " <configok>" : " <stale>"),
4434 (hdw->state_pipeline_req ? " <req>" : ""),
4435 (hdw->state_pipeline_pause ? " <pause>" : ""));
4439 "worker:%s%s%s%s%s%s%s",
4440 (hdw->state_decoder_run ?
4442 (hdw->state_decoder_quiescent ?
4443 "" : " <decode:stop>")),
4444 (hdw->state_decoder_quiescent ?
4445 " <decode:quiescent>" : ""),
4446 (hdw->state_encoder_ok ?
4447 "" : " <encode:init>"),
4448 (hdw->state_encoder_run ?
4449 (hdw->state_encoder_runok ?
4451 " <encode:firstrun>") :
4452 (hdw->state_encoder_runok ?
4454 " <encode:virgin>")),
4455 (hdw->state_encoder_config ?
4456 " <encode:configok>" :
4457 (hdw->state_encoder_waitok ?
4458 "" : " <encode:waitok>")),
4459 (hdw->state_usbstream_run ?
4460 " <usb:run>" : " <usb:stop>"),
4461 (hdw->state_pathway_ok ?
4462 " <pathway:ok>" : ""));
4467 pvr2_get_state_name(hdw->master_state));
4469 unsigned int tcnt = 0;
4472 ccnt = scnprintf(buf,
4474 "Hardware supported inputs: ");
4476 tcnt += print_input_mask(hdw->input_avail_mask,
4479 if (hdw->input_avail_mask != hdw->input_allowed_mask) {
4480 ccnt = scnprintf(buf+tcnt,
4482 "; allowed inputs: ");
4484 tcnt += print_input_mask(hdw->input_allowed_mask,
4491 struct pvr2_stream_stats stats;
4492 if (!hdw->vid_stream) break;
4493 pvr2_stream_get_stats(hdw->vid_stream,
4499 " URBs: queued=%u idle=%u ready=%u"
4500 " processed=%u failed=%u",
4501 stats.bytes_processed,
4502 stats.buffers_in_queue,
4503 stats.buffers_in_idle,
4504 stats.buffers_in_ready,
4505 stats.buffers_processed,
4506 stats.buffers_failed);
4514 unsigned int pvr2_hdw_state_report(struct pvr2_hdw *hdw,
4515 char *buf,unsigned int acnt)
4517 unsigned int bcnt,ccnt,idx;
4519 LOCK_TAKE(hdw->big_lock);
4520 for (idx = 0; ; idx++) {
4521 ccnt = pvr2_hdw_report_unlocked(hdw,idx,buf,acnt);
4523 bcnt += ccnt; acnt -= ccnt; buf += ccnt;
4525 buf[0] = '\n'; ccnt = 1;
4526 bcnt += ccnt; acnt -= ccnt; buf += ccnt;
4528 LOCK_GIVE(hdw->big_lock);
4533 static void pvr2_hdw_state_log_state(struct pvr2_hdw *hdw)
4536 unsigned int idx,ccnt;
4538 for (idx = 0; ; idx++) {
4539 ccnt = pvr2_hdw_report_unlocked(hdw,idx,buf,sizeof(buf));
4541 printk(KERN_INFO "%s %.*s\n",hdw->name,ccnt,buf);
4546 /* Evaluate and update the driver's current state, taking various actions
4547 as appropriate for the update. */
4548 static int pvr2_hdw_state_eval(struct pvr2_hdw *hdw)
4551 int state_updated = 0;
4552 int callback_flag = 0;
4555 pvr2_trace(PVR2_TRACE_STBITS,
4556 "Drive state check START");
4557 if (pvrusb2_debug & PVR2_TRACE_STBITS) {
4558 pvr2_hdw_state_log_state(hdw);
4561 /* Process all state and get back over disposition */
4562 state_updated = pvr2_hdw_state_update(hdw);
4564 analog_mode = (hdw->pathway_state != PVR2_PATHWAY_DIGITAL);
4566 /* Update master state based upon all other states. */
4567 if (!hdw->flag_ok) {
4568 st = PVR2_STATE_DEAD;
4569 } else if (hdw->fw1_state != FW1_STATE_OK) {
4570 st = PVR2_STATE_COLD;
4571 } else if ((analog_mode ||
4572 hdw->hdw_desc->flag_digital_requires_cx23416) &&
4573 !hdw->state_encoder_ok) {
4574 st = PVR2_STATE_WARM;
4575 } else if (hdw->flag_tripped ||
4576 (analog_mode && hdw->flag_decoder_missed)) {
4577 st = PVR2_STATE_ERROR;
4578 } else if (hdw->state_usbstream_run &&
4580 (hdw->state_encoder_run && hdw->state_decoder_run))) {
4581 st = PVR2_STATE_RUN;
4583 st = PVR2_STATE_READY;
4585 if (hdw->master_state != st) {
4586 pvr2_trace(PVR2_TRACE_STATE,
4587 "Device state change from %s to %s",
4588 pvr2_get_state_name(hdw->master_state),
4589 pvr2_get_state_name(st));
4590 pvr2_led_ctrl(hdw,st == PVR2_STATE_RUN);
4591 hdw->master_state = st;
4595 if (state_updated) {
4596 /* Trigger anyone waiting on any state changes here. */
4597 wake_up(&hdw->state_wait_data);
4600 if (pvrusb2_debug & PVR2_TRACE_STBITS) {
4601 pvr2_hdw_state_log_state(hdw);
4603 pvr2_trace(PVR2_TRACE_STBITS,
4604 "Drive state check DONE callback=%d",callback_flag);
4606 return callback_flag;
4610 /* Cause kernel thread to check / update driver state */
4611 static void pvr2_hdw_state_sched(struct pvr2_hdw *hdw)
4613 if (hdw->state_stale) return;
4614 hdw->state_stale = !0;
4615 trace_stbit("state_stale",hdw->state_stale);
4616 queue_work(hdw->workqueue,&hdw->workpoll);
4620 int pvr2_hdw_gpio_get_dir(struct pvr2_hdw *hdw,u32 *dp)
4622 return pvr2_read_register(hdw,PVR2_GPIO_DIR,dp);
4626 int pvr2_hdw_gpio_get_out(struct pvr2_hdw *hdw,u32 *dp)
4628 return pvr2_read_register(hdw,PVR2_GPIO_OUT,dp);
4632 int pvr2_hdw_gpio_get_in(struct pvr2_hdw *hdw,u32 *dp)
4634 return pvr2_read_register(hdw,PVR2_GPIO_IN,dp);
4638 int pvr2_hdw_gpio_chg_dir(struct pvr2_hdw *hdw,u32 msk,u32 val)
4643 ret = pvr2_read_register(hdw,PVR2_GPIO_DIR,&cval);
4644 if (ret) return ret;
4645 nval = (cval & ~msk) | (val & msk);
4646 pvr2_trace(PVR2_TRACE_GPIO,
4647 "GPIO direction changing 0x%x:0x%x"
4648 " from 0x%x to 0x%x",
4652 pvr2_trace(PVR2_TRACE_GPIO,
4653 "GPIO direction changing to 0x%x",nval);
4655 return pvr2_write_register(hdw,PVR2_GPIO_DIR,nval);
4659 int pvr2_hdw_gpio_chg_out(struct pvr2_hdw *hdw,u32 msk,u32 val)
4664 ret = pvr2_read_register(hdw,PVR2_GPIO_OUT,&cval);
4665 if (ret) return ret;
4666 nval = (cval & ~msk) | (val & msk);
4667 pvr2_trace(PVR2_TRACE_GPIO,
4668 "GPIO output changing 0x%x:0x%x from 0x%x to 0x%x",
4672 pvr2_trace(PVR2_TRACE_GPIO,
4673 "GPIO output changing to 0x%x",nval);
4675 return pvr2_write_register(hdw,PVR2_GPIO_OUT,nval);
4679 void pvr2_hdw_status_poll(struct pvr2_hdw *hdw)
4681 pvr2_i2c_core_status_poll(hdw);
4685 unsigned int pvr2_hdw_get_input_available(struct pvr2_hdw *hdw)
4687 return hdw->input_avail_mask;
4691 unsigned int pvr2_hdw_get_input_allowed(struct pvr2_hdw *hdw)
4693 return hdw->input_allowed_mask;
4697 static int pvr2_hdw_set_input(struct pvr2_hdw *hdw,int v)
4699 if (hdw->input_val != v) {
4701 hdw->input_dirty = !0;
4704 /* Handle side effects - if we switch to a mode that needs the RF
4705 tuner, then select the right frequency choice as well and mark
4707 if (hdw->input_val == PVR2_CVAL_INPUT_RADIO) {
4708 hdw->freqSelector = 0;
4709 hdw->freqDirty = !0;
4710 } else if ((hdw->input_val == PVR2_CVAL_INPUT_TV) ||
4711 (hdw->input_val == PVR2_CVAL_INPUT_DTV)) {
4712 hdw->freqSelector = 1;
4713 hdw->freqDirty = !0;
4719 int pvr2_hdw_set_input_allowed(struct pvr2_hdw *hdw,
4720 unsigned int change_mask,
4721 unsigned int change_val)
4724 unsigned int nv,m,idx;
4725 LOCK_TAKE(hdw->big_lock);
4727 nv = hdw->input_allowed_mask & ~change_mask;
4728 nv |= (change_val & change_mask);
4729 nv &= hdw->input_avail_mask;
4731 /* No legal modes left; return error instead. */
4735 hdw->input_allowed_mask = nv;
4736 if ((1 << hdw->input_val) & hdw->input_allowed_mask) {
4737 /* Current mode is still in the allowed mask, so
4741 /* Select and switch to a mode that is still in the allowed
4743 if (!hdw->input_allowed_mask) {
4744 /* Nothing legal; give up */
4747 m = hdw->input_allowed_mask;
4748 for (idx = 0; idx < (sizeof(m) << 3); idx++) {
4749 if (!((1 << idx) & m)) continue;
4750 pvr2_hdw_set_input(hdw,idx);
4754 LOCK_GIVE(hdw->big_lock);
4759 /* Find I2C address of eeprom */
4760 static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw)
4763 LOCK_TAKE(hdw->ctl_lock); do {
4764 hdw->cmd_buffer[0] = FX2CMD_GET_EEPROM_ADDR;
4765 result = pvr2_send_request(hdw,
4768 if (result < 0) break;
4769 result = hdw->cmd_buffer[0];
4770 } while(0); LOCK_GIVE(hdw->ctl_lock);
4775 int pvr2_hdw_register_access(struct pvr2_hdw *hdw,
4776 struct v4l2_dbg_match *match, u64 reg_id,
4777 int setFl, u64 *val_ptr)
4779 #ifdef CONFIG_VIDEO_ADV_DEBUG
4780 struct pvr2_i2c_client *cp;
4781 struct v4l2_dbg_register req;
4785 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
4789 if (setFl) req.val = *val_ptr;
4790 mutex_lock(&hdw->i2c_list_lock); do {
4791 list_for_each_entry(cp, &hdw->i2c_clients, list) {
4792 if (!v4l2_chip_match_i2c_client(
4797 stat = pvr2_i2c_client_cmd(
4798 cp,(setFl ? VIDIOC_DBG_S_REGISTER :
4799 VIDIOC_DBG_G_REGISTER),&req);
4800 if (!setFl) *val_ptr = req.val;
4804 } while (0); mutex_unlock(&hdw->i2c_list_lock);
4816 Stuff for Emacs to see, in order to encourage consistent editing style:
4817 *** Local Variables: ***
4819 *** fill-column: 75 ***
4820 *** tab-width: 8 ***
4821 *** c-basic-offset: 8 ***