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

   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 #ifndef __PVRUSB2_HDW_INTERNAL_H
  21 #define __PVRUSB2_HDW_INTERNAL_H
  22
  23 /*
  24
  25   This header sets up all the internal structures and definitions needed to
  26   track and coordinate the driver's interaction with the hardware.  ONLY
  27   source files which actually implement part of that whole circus should be
  28   including this header.  Higher levels, like the external layers to the
  29   various public APIs (V4L, sysfs, etc) should NOT ever include this
  30   private, internal header.  This means that pvrusb2-hdw, pvrusb2-encoder,
  31   etc will include this, but pvrusb2-v4l should not.
  32
  33 */
  34
  35 #include <linux/videodev2.h>
  36 #include <linux/i2c.h>
  37 #include <linux/workqueue.h>
  38 #include <linux/mutex.h>
  39 #include "pvrusb2-hdw.h"
  40 #include "pvrusb2-io.h"
  41 #include <media/v4l2-device.h>
  42 #include <media/cx2341x.h>
  43 #include <media/ir-kbd-i2c.h>
  44 #include "pvrusb2-devattr.h"
  45
  46 /* Legal values for PVR2_CID_HSM */
  47 #define PVR2_CVAL_HSM_FAIL 0
  48 #define PVR2_CVAL_HSM_FULL 1
  49 #define PVR2_CVAL_HSM_HIGH 2
  50
  51 #define PVR2_VID_ENDPOINT        0x84
  52 #define PVR2_UNK_ENDPOINT        0x86    /* maybe raw yuv ? */
  53 #define PVR2_VBI_ENDPOINT        0x88
  54
  55 #define PVR2_CTL_BUFFSIZE        64
  56
  57 #define FREQTABLE_SIZE 500
  58
  59 #define LOCK_TAKE(x) do { mutex_lock(&x##_mutex); x##_held = !0; } while (0)
  60 #define LOCK_GIVE(x) do { x##_held = 0; mutex_unlock(&x##_mutex); } while (0)
  61
  62 typedef int (*pvr2_ctlf_is_dirty)(struct pvr2_ctrl *);
  63 typedef void (*pvr2_ctlf_clear_dirty)(struct pvr2_ctrl *);
  64 typedef int (*pvr2_ctlf_check_value)(struct pvr2_ctrl *,int);
  65 typedef int (*pvr2_ctlf_get_value)(struct pvr2_ctrl *,int *);
  66 typedef int (*pvr2_ctlf_set_value)(struct pvr2_ctrl *,int msk,int val);
  67 typedef int (*pvr2_ctlf_val_to_sym)(struct pvr2_ctrl *,int msk,int val,
  68                                     char *,unsigned int,unsigned int *);
  69 typedef int (*pvr2_ctlf_sym_to_val)(struct pvr2_ctrl *,
  70                                     const char *,unsigned int,
  71                                     int *mskp,int *valp);
  72 typedef unsigned int (*pvr2_ctlf_get_v4lflags)(struct pvr2_ctrl *);
  73
  74 /* This structure describes a specific control.  A table of these is set up
  75    in pvrusb2-hdw.c. */
  76 struct pvr2_ctl_info {
  77         /* Control's name suitable for use as an identifier */
  78         const char *name;
  79
  80         /* Short description of control */
  81         const char *desc;
  82
  83         /* Control's implementation */
  84         pvr2_ctlf_get_value get_value;      /* Get its value */
  85         pvr2_ctlf_get_value get_def_value;  /* Get its default value */
  86         pvr2_ctlf_get_value get_min_value;  /* Get minimum allowed value */
  87         pvr2_ctlf_get_value get_max_value;  /* Get maximum allowed value */
  88         pvr2_ctlf_set_value set_value;      /* Set its value */
  89         pvr2_ctlf_check_value check_value;  /* Check that value is valid */
  90         pvr2_ctlf_val_to_sym val_to_sym;    /* Custom convert value->symbol */
  91         pvr2_ctlf_sym_to_val sym_to_val;    /* Custom convert symbol->value */
  92         pvr2_ctlf_is_dirty is_dirty;        /* Return true if dirty */
  93         pvr2_ctlf_clear_dirty clear_dirty;  /* Clear dirty state */
  94         pvr2_ctlf_get_v4lflags get_v4lflags;/* Retrieve v4l flags */
  95
  96         /* Control's type (int, enum, bitmask) */
  97         enum pvr2_ctl_type type;
  98
  99         /* Associated V4L control ID, if any */
 100         int v4l_id;
 101
 102         /* Associated driver internal ID, if any */
 103         int internal_id;
 104
 105         /* Don't implicitly initialize this control's value */
 106         int skip_init;
 107
 108         /* Starting value for this control */
 109         int default_value;
 110
 111         /* Type-specific control information */
 112         union {
 113                 struct { /* Integer control */
 114                         long min_value; /* lower limit */
 115                         long max_value; /* upper limit */
 116                 } type_int;
 117                 struct { /* enumerated control */
 118                         unsigned int count;       /* enum value count */
 119                         const char * const *value_names; /* symbol names */
 120                 } type_enum;
 121                 struct { /* bitmask control */
 122                         unsigned int valid_bits; /* bits in use */
 123                         const char **bit_names;  /* symbol name/bit */
 124                 } type_bitmask;
 125         } def;
 126 };
 127
 128
 129 /* Same as pvr2_ctl_info, but includes storage for the control description */
 130 #define PVR2_CTLD_INFO_DESC_SIZE 32
 131 struct pvr2_ctld_info {
 132         struct pvr2_ctl_info info;
 133         char desc[PVR2_CTLD_INFO_DESC_SIZE];
 134 };
 135
 136 struct pvr2_ctrl {
 137         const struct pvr2_ctl_info *info;
 138         struct pvr2_hdw *hdw;
 139 };
 140
 141
 142
 143 /* Disposition of firmware1 loading situation */
 144 #define FW1_STATE_UNKNOWN 0
 145 #define FW1_STATE_MISSING 1
 146 #define FW1_STATE_FAILED 2
 147 #define FW1_STATE_RELOAD 3
 148 #define FW1_STATE_OK 4
 149
 150 /* What state the device is in if it is a hybrid */
 151 #define PVR2_PATHWAY_UNKNOWN 0
 152 #define PVR2_PATHWAY_ANALOG 1
 153 #define PVR2_PATHWAY_DIGITAL 2
 154
 155 typedef int (*pvr2_i2c_func)(struct pvr2_hdw *,u8,u8 *,u16,u8 *, u16);
 156 #define PVR2_I2C_FUNC_CNT 128
 157
 158 /* This structure contains all state data directly needed to
 159    manipulate the hardware (as opposed to complying with a kernel
 160    interface) */
 161 struct pvr2_hdw {
 162         /* Underlying USB device handle */
 163         struct usb_device *usb_dev;
 164         struct usb_interface *usb_intf;
 165
 166         /* Our handle into the v4l2 sub-device architecture */
 167         struct v4l2_device v4l2_dev;
 168         /* Device description, anything that must adjust behavior based on
 169            device specific info will use information held here. */
 170         const struct pvr2_device_desc *hdw_desc;
 171
 172         /* Kernel worker thread handling */
 173         struct workqueue_struct *workqueue;
 174         struct work_struct workpoll;     /* Update driver state */
 175
 176         /* Video spigot */
 177         struct pvr2_stream *vid_stream;
 178
 179         /* Mutex for all hardware state control */
 180         struct mutex big_lock_mutex;
 181         int big_lock_held;  /* For debugging */
 182
 183         /* This is a simple string which identifies the instance of this
 184            driver.  It is unique within the set of existing devices, but
 185            there is no attempt to keep the name consistent with the same
 186            physical device each time. */
 187         char name[32];
 188
 189         /* This is a simple string which identifies the physical device
 190            instance itself - if possible.  (If not possible, then it is
 191            based on the specific driver instance, similar to name above.)
 192            The idea here is that userspace might hopefully be able to use
 193            this recognize specific tuners.  It will encode a serial number,
 194            if available. */
 195         char identifier[32];
 196
 197         /* I2C stuff */
 198         struct i2c_adapter i2c_adap;
 199         struct i2c_algorithm i2c_algo;
 200         pvr2_i2c_func i2c_func[PVR2_I2C_FUNC_CNT];
 201         int i2c_cx25840_hack_state;
 202         int i2c_linked;
 203
 204         /* IR related */
 205         unsigned int ir_scheme_active; /* IR scheme as seen from the outside */
 206         struct IR_i2c_init_data ir_init_data; /* params passed to IR modules */
 207
 208         /* Frequency table */
 209         unsigned int freqTable[FREQTABLE_SIZE];
 210         unsigned int freqProgSlot;
 211
 212         /* Stuff for handling low level control interaction with device */
 213         struct mutex ctl_lock_mutex;
 214         int ctl_lock_held;  /* For debugging */
 215         struct urb *ctl_write_urb;
 216         struct urb *ctl_read_urb;
 217         unsigned char *ctl_write_buffer;
 218         unsigned char *ctl_read_buffer;
 219         int ctl_write_pend_flag;
 220         int ctl_read_pend_flag;
 221         int ctl_timeout_flag;
 222         struct completion ctl_done;
 223         unsigned char cmd_buffer[PVR2_CTL_BUFFSIZE];
 224         int cmd_debug_state;               // Low level command debugging info
 225         unsigned char cmd_debug_code;      //
 226         unsigned int cmd_debug_write_len;  //
 227         unsigned int cmd_debug_read_len;   //
 228
 229         /* Bits of state that describe what is going on with various parts
 230            of the driver. */
 231         int state_pathway_ok;         /* Pathway config is ok */
 232         int state_encoder_ok;         /* Encoder is operational */
 233         int state_encoder_run;        /* Encoder is running */
 234         int state_encoder_config;     /* Encoder is configured */
 235         int state_encoder_waitok;     /* Encoder pre-wait done */
 236         int state_encoder_runok;      /* Encoder has run for >= .25 sec */
 237         int state_decoder_run;        /* Decoder is running */
 238         int state_decoder_ready;      /* Decoder is stabilized & streamable */
 239         int state_usbstream_run;      /* FX2 is streaming */
 240         int state_decoder_quiescent;  /* Decoder idle for minimal interval */
 241         int state_pipeline_config;    /* Pipeline is configured */
 242         int state_pipeline_req;       /* Somebody wants to stream */
 243         int state_pipeline_pause;     /* Pipeline must be paused */
 244         int state_pipeline_idle;      /* Pipeline not running */
 245
 246         /* This is the master state of the driver.  It is the combined
 247            result of other bits of state.  Examining this will indicate the
 248            overall state of the driver.  Values here are one of
 249            PVR2_STATE_xxxx */
 250         unsigned int master_state;
 251
 252         /* True if device led is currently on */
 253         int led_on;
 254
 255         /* True if states must be re-evaluated */
 256         int state_stale;
 257
 258         void (*state_func)(void *);
 259         void *state_data;
 260
 261         /* Timer for measuring required decoder settling time before we're
 262            allowed to fire it up again. */
 263         struct timer_list quiescent_timer;
 264
 265         /* Timer for measuring decoder stabilization time, which is the
 266            amount of time we need to let the decoder run before we can
 267            trust its output (otherwise the encoder might see garbage and
 268            then fail to start correctly). */
 269         struct timer_list decoder_stabilization_timer;
 270
 271         /* Timer for measuring encoder pre-wait time */
 272         struct timer_list encoder_wait_timer;
 273
 274         /* Timer for measuring encoder minimum run time */
 275         struct timer_list encoder_run_timer;
 276
 277         /* Place to block while waiting for state changes */
 278         wait_queue_head_t state_wait_data;
 279
 280
 281         int force_dirty;        /* consider all controls dirty if true */
 282         int flag_ok;            /* device in known good state */
 283         int flag_modulefail;    /* true if at least one module failed to load */
 284         int flag_disconnected;  /* flag_ok == 0 due to disconnect */
 285         int flag_init_ok;       /* true if structure is fully initialized */
 286         int fw1_state;          /* current situation with fw1 */
 287         int pathway_state;      /* one of PVR2_PATHWAY_xxx */
 288         int flag_decoder_missed;/* We've noticed missing decoder */
 289         int flag_tripped;       /* Indicates overall failure to start */
 290
 291         unsigned int decoder_client_id;
 292
 293         // CPU firmware info (used to help find / save firmware data)
 294         char *fw_buffer;
 295         unsigned int fw_size;
 296         int fw_cpu_flag; /* True if we are dealing with the CPU */
 297
 298         /* Tuner / frequency control stuff */
 299         unsigned int tuner_type;
 300         int tuner_updated;
 301         unsigned int freqValTelevision;  /* Current freq for tv mode */
 302         unsigned int freqValRadio;       /* Current freq for radio mode */
 303         unsigned int freqSlotTelevision; /* Current slot for tv mode */
 304         unsigned int freqSlotRadio;      /* Current slot for radio mode */
 305         unsigned int freqSelector;       /* 0=radio 1=television */
 306         int freqDirty;
 307
 308         /* Current tuner info - this information is polled from the I2C bus */
 309         struct v4l2_tuner tuner_signal_info;
 310         int tuner_signal_stale;
 311
 312         /* Cropping capability info */
 313         struct v4l2_cropcap cropcap_info;
 314         int cropcap_stale;
 315
 316         /* Video standard handling */
 317         v4l2_std_id std_mask_eeprom; // Hardware supported selections
 318         v4l2_std_id std_mask_avail;  // Which standards we may select from
 319         v4l2_std_id std_mask_cur;    // Currently selected standard(s)
 320         unsigned int std_enum_cnt;   // # of enumerated standards
 321         int std_enum_cur;            // selected standard enumeration value
 322         int std_dirty;               // True if std_mask_cur has changed
 323         struct pvr2_ctl_info std_info_enum;
 324         struct pvr2_ctl_info std_info_avail;
 325         struct pvr2_ctl_info std_info_cur;
 326         struct v4l2_standard *std_defs;
 327         const char **std_enum_names;
 328
 329         // Generated string names, one per actual V4L2 standard
 330         const char *std_mask_ptrs[32];
 331         char std_mask_names[32][10];
 332
 333         int unit_number;             /* ID for driver instance */
 334         unsigned long serial_number; /* ID for hardware itself */
 335
 336         char bus_info[32]; /* Bus location info */
 337
 338         /* Minor numbers used by v4l logic (yes, this is a hack, as there
 339            should be no v4l junk here).  Probably a better way to do this. */
 340         int v4l_minor_number_video;
 341         int v4l_minor_number_vbi;
 342         int v4l_minor_number_radio;
 343
 344         /* Bit mask of PVR2_CVAL_INPUT choices which are valid for the hardware */
 345         unsigned int input_avail_mask;
 346         /* Bit mask of PVR2_CVAL_INPUT choices which are currently allowed */
 347         unsigned int input_allowed_mask;
 348
 349         /* Location of eeprom or a negative number if none */
 350         int eeprom_addr;
 351
 352         enum pvr2_config active_stream_type;
 353         enum pvr2_config desired_stream_type;
 354
 355         /* Control state needed for cx2341x module */
 356         struct cx2341x_mpeg_params enc_cur_state;
 357         struct cx2341x_mpeg_params enc_ctl_state;
 358         /* True if an encoder attribute has changed */
 359         int enc_stale;
 360         /* True if an unsafe encoder attribute has changed */
 361         int enc_unsafe_stale;
 362         /* True if enc_cur_state is valid */
 363         int enc_cur_valid;
 364
 365         /* Control state */
 366 #define VCREATE_DATA(lab) int lab##_val; int lab##_dirty
 367         VCREATE_DATA(brightness);
 368         VCREATE_DATA(contrast);
 369         VCREATE_DATA(saturation);
 370         VCREATE_DATA(hue);
 371         VCREATE_DATA(volume);
 372         VCREATE_DATA(balance);
 373         VCREATE_DATA(bass);
 374         VCREATE_DATA(treble);
 375         VCREATE_DATA(mute);
 376         VCREATE_DATA(cropl);
 377         VCREATE_DATA(cropt);
 378         VCREATE_DATA(cropw);
 379         VCREATE_DATA(croph);
 380         VCREATE_DATA(input);
 381         VCREATE_DATA(audiomode);
 382         VCREATE_DATA(res_hor);
 383         VCREATE_DATA(res_ver);
 384         VCREATE_DATA(srate);
 385 #undef VCREATE_DATA
 386
 387         struct pvr2_ctld_info *mpeg_ctrl_info;
 388
 389         struct pvr2_ctrl *controls;
 390         unsigned int control_cnt;
 391 };
 392
 393 /* This function gets the current frequency */
 394 unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);
 395
 396 void pvr2_hdw_status_poll(struct pvr2_hdw *);
 397
 398 #endif /* __PVRUSB2_HDW_INTERNAL_H */
 399
 400 /*
 401   Stuff for Emacs to see, in order to encourage consistent editing style:
 402   *** Local Variables: ***
 403   *** mode: c ***
 404   *** fill-column: 75 ***
 405   *** tab-width: 8 ***
 406   *** c-basic-offset: 8 ***
 407   *** End: ***
 408   */