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

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