Pileus Git - ~andy/linux/blob - drivers/media/video/pvrusb2/pvrusb2-hdw.c

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