pvrusb2-hdw-internal.h 13.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 *
 *
 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#ifndef __PVRUSB2_HDW_INTERNAL_H
#define __PVRUSB2_HDW_INTERNAL_H

/*

  This header sets up all the internal structures and definitions needed to
  track and coordinate the driver's interaction with the hardware.  ONLY
  source files which actually implement part of that whole circus should be
  including this header.  Higher levels, like the external layers to the
  various public APIs (V4L, sysfs, etc) should NOT ever include this
  private, internal header.  This means that pvrusb2-hdw, pvrusb2-encoder,
  etc will include this, but pvrusb2-v4l should not.

*/

#include <linux/videodev2.h>
#include <linux/i2c.h>
37
#include <linux/workqueue.h>
38 39 40
#include <linux/mutex.h>
#include "pvrusb2-hdw.h"
#include "pvrusb2-io.h"
41
#include <media/v4l2-device.h>
42
#include <media/cx2341x.h>
43
#include "pvrusb2-devattr.h"
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

/* Legal values for PVR2_CID_HSM */
#define PVR2_CVAL_HSM_FAIL 0
#define PVR2_CVAL_HSM_FULL 1
#define PVR2_CVAL_HSM_HIGH 2

#define PVR2_VID_ENDPOINT        0x84
#define PVR2_UNK_ENDPOINT        0x86    /* maybe raw yuv ? */
#define PVR2_VBI_ENDPOINT        0x88

#define PVR2_CTL_BUFFSIZE        64

#define FREQTABLE_SIZE 500

#define LOCK_TAKE(x) do { mutex_lock(&x##_mutex); x##_held = !0; } while (0)
#define LOCK_GIVE(x) do { x##_held = 0; mutex_unlock(&x##_mutex); } while (0)

typedef int (*pvr2_ctlf_is_dirty)(struct pvr2_ctrl *);
typedef void (*pvr2_ctlf_clear_dirty)(struct pvr2_ctrl *);
63
typedef int (*pvr2_ctlf_check_value)(struct pvr2_ctrl *,int);
64 65 66 67 68 69 70
typedef int (*pvr2_ctlf_get_value)(struct pvr2_ctrl *,int *);
typedef int (*pvr2_ctlf_set_value)(struct pvr2_ctrl *,int msk,int val);
typedef int (*pvr2_ctlf_val_to_sym)(struct pvr2_ctrl *,int msk,int val,
				    char *,unsigned int,unsigned int *);
typedef int (*pvr2_ctlf_sym_to_val)(struct pvr2_ctrl *,
				    const char *,unsigned int,
				    int *mskp,int *valp);
71
typedef unsigned int (*pvr2_ctlf_get_v4lflags)(struct pvr2_ctrl *);
72 73 74 75 76 77 78 79 80 81 82 83

/* This structure describes a specific control.  A table of these is set up
   in pvrusb2-hdw.c. */
struct pvr2_ctl_info {
	/* Control's name suitable for use as an identifier */
	const char *name;

	/* Short description of control */
	const char *desc;

	/* Control's implementation */
	pvr2_ctlf_get_value get_value;      /* Get its value */
84
	pvr2_ctlf_get_value get_def_value;  /* Get its default value */
85 86
	pvr2_ctlf_get_value get_min_value;  /* Get minimum allowed value */
	pvr2_ctlf_get_value get_max_value;  /* Get maximum allowed value */
87
	pvr2_ctlf_set_value set_value;      /* Set its value */
88
	pvr2_ctlf_check_value check_value;  /* Check that value is valid */
89 90 91 92
	pvr2_ctlf_val_to_sym val_to_sym;    /* Custom convert value->symbol */
	pvr2_ctlf_sym_to_val sym_to_val;    /* Custom convert symbol->value */
	pvr2_ctlf_is_dirty is_dirty;        /* Return true if dirty */
	pvr2_ctlf_clear_dirty clear_dirty;  /* Clear dirty state */
93
	pvr2_ctlf_get_v4lflags get_v4lflags;/* Retrieve v4l flags */
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

	/* Control's type (int, enum, bitmask) */
	enum pvr2_ctl_type type;

	/* Associated V4L control ID, if any */
	int v4l_id;

	/* Associated driver internal ID, if any */
	int internal_id;

	/* Don't implicitly initialize this control's value */
	int skip_init;

	/* Starting value for this control */
	int default_value;

	/* Type-specific control information */
	union {
		struct { /* Integer control */
			long min_value; /* lower limit */
			long max_value; /* upper limit */
		} type_int;
		struct { /* enumerated control */
			unsigned int count;       /* enum value count */
118
			const char * const *value_names; /* symbol names */
119 120 121 122 123 124 125 126 127
		} type_enum;
		struct { /* bitmask control */
			unsigned int valid_bits; /* bits in use */
			const char **bit_names;  /* symbol name/bit */
		} type_bitmask;
	} def;
};


128 129 130 131 132 133 134
/* Same as pvr2_ctl_info, but includes storage for the control description */
#define PVR2_CTLD_INFO_DESC_SIZE 32
struct pvr2_ctld_info {
	struct pvr2_ctl_info info;
	char desc[PVR2_CTLD_INFO_DESC_SIZE];
};

135 136 137 138 139 140 141 142 143 144 145 146 147 148
struct pvr2_ctrl {
	const struct pvr2_ctl_info *info;
	struct pvr2_hdw *hdw;
};



/* Disposition of firmware1 loading situation */
#define FW1_STATE_UNKNOWN 0
#define FW1_STATE_MISSING 1
#define FW1_STATE_FAILED 2
#define FW1_STATE_RELOAD 3
#define FW1_STATE_OK 4

149 150 151 152 153
/* What state the device is in if it is a hybrid */
#define PVR2_PATHWAY_UNKNOWN 0
#define PVR2_PATHWAY_ANALOG 1
#define PVR2_PATHWAY_DIGITAL 2

154 155 156 157 158 159 160 161 162 163 164
typedef int (*pvr2_i2c_func)(struct pvr2_hdw *,u8,u8 *,u16,u8 *, u16);
#define PVR2_I2C_FUNC_CNT 128

/* This structure contains all state data directly needed to
   manipulate the hardware (as opposed to complying with a kernel
   interface) */
struct pvr2_hdw {
	/* Underlying USB device handle */
	struct usb_device *usb_dev;
	struct usb_interface *usb_intf;

165 166
	/* Our handle into the v4l2 sub-device architecture */
	struct v4l2_device v4l2_dev;
167 168
	/* Device description, anything that must adjust behavior based on
	   device specific info will use information held here. */
169
	const struct pvr2_device_desc *hdw_desc;
170

171 172 173 174
	/* Kernel worker thread handling */
	struct workqueue_struct *workqueue;
	struct work_struct workpoll;     /* Update driver state */

175 176 177 178 179 180 181
	/* Video spigot */
	struct pvr2_stream *vid_stream;

	/* Mutex for all hardware state control */
	struct mutex big_lock_mutex;
	int big_lock_held;  /* For debugging */

182 183 184 185
	/* This is a simple string which identifies the instance of this
	   driver.  It is unique within the set of existing devices, but
	   there is no attempt to keep the name consistent with the same
	   physical device each time. */
186 187
	char name[32];

188 189 190 191 192 193 194 195
	/* This is a simple string which identifies the physical device
	   instance itself - if possible.  (If not possible, then it is
	   based on the specific driver instance, similar to name above.)
	   The idea here is that userspace might hopefully be able to use
	   this recognize specific tuners.  It will encode a serial number,
	   if available. */
	char identifier[32];

196 197 198 199 200 201 202
	/* I2C stuff */
	struct i2c_adapter i2c_adap;
	struct i2c_algorithm i2c_algo;
	pvr2_i2c_func i2c_func[PVR2_I2C_FUNC_CNT];
	int i2c_cx25840_hack_state;
	int i2c_linked;

203 204 205
	/* IR related */
	unsigned int ir_scheme_active; /* IR scheme as seen from the outside */

206 207 208 209 210 211 212 213 214 215 216
	/* Frequency table */
	unsigned int freqTable[FREQTABLE_SIZE];
	unsigned int freqProgSlot;

	/* Stuff for handling low level control interaction with device */
	struct mutex ctl_lock_mutex;
	int ctl_lock_held;  /* For debugging */
	struct urb *ctl_write_urb;
	struct urb *ctl_read_urb;
	unsigned char *ctl_write_buffer;
	unsigned char *ctl_read_buffer;
217 218 219
	int ctl_write_pend_flag;
	int ctl_read_pend_flag;
	int ctl_timeout_flag;
220 221 222 223 224 225 226
	struct completion ctl_done;
	unsigned char cmd_buffer[PVR2_CTL_BUFFSIZE];
	int cmd_debug_state;               // Low level command debugging info
	unsigned char cmd_debug_code;      //
	unsigned int cmd_debug_write_len;  //
	unsigned int cmd_debug_read_len;   //

227 228
	/* Bits of state that describe what is going on with various parts
	   of the driver. */
229
	int state_pathway_ok;         /* Pathway config is ok */
230 231 232 233
	int state_encoder_ok;         /* Encoder is operational */
	int state_encoder_run;        /* Encoder is running */
	int state_encoder_config;     /* Encoder is configured */
	int state_encoder_waitok;     /* Encoder pre-wait done */
234
	int state_encoder_runok;      /* Encoder has run for >= .25 sec */
235
	int state_decoder_run;        /* Decoder is running */
236
	int state_decoder_ready;      /* Decoder is stabilized & streamable */
237
	int state_usbstream_run;      /* FX2 is streaming */
238
	int state_decoder_quiescent;  /* Decoder idle for minimal interval */
239
	int state_pipeline_config;    /* Pipeline is configured */
240 241 242
	int state_pipeline_req;       /* Somebody wants to stream */
	int state_pipeline_pause;     /* Pipeline must be paused */
	int state_pipeline_idle;      /* Pipeline not running */
243 244 245 246 247 248 249

	/* This is the master state of the driver.  It is the combined
	   result of other bits of state.  Examining this will indicate the
	   overall state of the driver.  Values here are one of
	   PVR2_STATE_xxxx */
	unsigned int master_state;

250 251 252
	/* True if device led is currently on */
	int led_on;

253 254 255 256 257 258
	/* True if states must be re-evaluated */
	int state_stale;

	void (*state_func)(void *);
	void *state_data;

259 260
	/* Timer for measuring required decoder settling time before we're
	   allowed to fire it up again. */
261 262
	struct timer_list quiescent_timer;

263 264 265 266 267 268
	/* Timer for measuring decoder stabilization time, which is the
	   amount of time we need to let the decoder run before we can
	   trust its output (otherwise the encoder might see garbage and
	   then fail to start correctly). */
	struct timer_list decoder_stabilization_timer;

269 270 271
	/* Timer for measuring encoder pre-wait time */
	struct timer_list encoder_wait_timer;

272 273 274
	/* Timer for measuring encoder minimum run time */
	struct timer_list encoder_run_timer;

275 276 277 278
	/* Place to block while waiting for state changes */
	wait_queue_head_t state_wait_data;


279
	int force_dirty;        /* consider all controls dirty if true */
280
	int flag_ok;            /* device in known good state */
281
	int flag_modulefail;    /* true if at least one module failed to load */
282 283 284
	int flag_disconnected;  /* flag_ok == 0 due to disconnect */
	int flag_init_ok;       /* true if structure is fully initialized */
	int fw1_state;          /* current situation with fw1 */
285
	int pathway_state;      /* one of PVR2_PATHWAY_xxx */
286 287
	int flag_decoder_missed;/* We've noticed missing decoder */
	int flag_tripped;       /* Indicates overall failure to start */
288

289
	unsigned int decoder_client_id;
290 291 292 293

	// CPU firmware info (used to help find / save firmware data)
	char *fw_buffer;
	unsigned int fw_size;
294
	int fw_cpu_flag; /* True if we are dealing with the CPU */
295 296 297 298

	/* Tuner / frequency control stuff */
	unsigned int tuner_type;
	int tuner_updated;
299 300 301 302 303
	unsigned int freqValTelevision;  /* Current freq for tv mode */
	unsigned int freqValRadio;       /* Current freq for radio mode */
	unsigned int freqSlotTelevision; /* Current slot for tv mode */
	unsigned int freqSlotRadio;      /* Current slot for radio mode */
	unsigned int freqSelector;       /* 0=radio 1=television */
304 305
	int freqDirty;

306 307 308 309
	/* Current tuner info - this information is polled from the I2C bus */
	struct v4l2_tuner tuner_signal_info;
	int tuner_signal_stale;

310 311 312 313
	/* Cropping capability info */
	struct v4l2_cropcap cropcap_info;
	int cropcap_stale;

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
	/* Video standard handling */
	v4l2_std_id std_mask_eeprom; // Hardware supported selections
	v4l2_std_id std_mask_avail;  // Which standards we may select from
	v4l2_std_id std_mask_cur;    // Currently selected standard(s)
	unsigned int std_enum_cnt;   // # of enumerated standards
	int std_enum_cur;            // selected standard enumeration value
	int std_dirty;               // True if std_mask_cur has changed
	struct pvr2_ctl_info std_info_enum;
	struct pvr2_ctl_info std_info_avail;
	struct pvr2_ctl_info std_info_cur;
	struct v4l2_standard *std_defs;
	const char **std_enum_names;

	// Generated string names, one per actual V4L2 standard
	const char *std_mask_ptrs[32];
	char std_mask_names[32][10];

	int unit_number;             /* ID for driver instance */
	unsigned long serial_number; /* ID for hardware itself */

334 335
	char bus_info[32]; /* Bus location info */

336 337
	/* Minor numbers used by v4l logic (yes, this is a hack, as there
	   should be no v4l junk here).  Probably a better way to do this. */
338 339
	int v4l_minor_number_video;
	int v4l_minor_number_vbi;
340
	int v4l_minor_number_radio;
341

342
	/* Bit mask of PVR2_CVAL_INPUT choices which are valid for the hardware */
343
	unsigned int input_avail_mask;
344
	/* Bit mask of PVR2_CVAL_INPUT choices which are currently allowed */
345
	unsigned int input_allowed_mask;
346

347 348 349
	/* Location of eeprom or a negative number if none */
	int eeprom_addr;

350 351
	enum pvr2_config active_stream_type;
	enum pvr2_config desired_stream_type;
352

353 354 355 356 357
	/* Control state needed for cx2341x module */
	struct cx2341x_mpeg_params enc_cur_state;
	struct cx2341x_mpeg_params enc_ctl_state;
	/* True if an encoder attribute has changed */
	int enc_stale;
358 359
	/* True if an unsafe encoder attribute has changed */
	int enc_unsafe_stale;
360 361
	/* True if enc_cur_state is valid */
	int enc_cur_valid;
362

363 364 365 366 367 368 369 370 371 372 373
	/* Control state */
#define VCREATE_DATA(lab) int lab##_val; int lab##_dirty
	VCREATE_DATA(brightness);
	VCREATE_DATA(contrast);
	VCREATE_DATA(saturation);
	VCREATE_DATA(hue);
	VCREATE_DATA(volume);
	VCREATE_DATA(balance);
	VCREATE_DATA(bass);
	VCREATE_DATA(treble);
	VCREATE_DATA(mute);
374 375 376 377
	VCREATE_DATA(cropl);
	VCREATE_DATA(cropt);
	VCREATE_DATA(cropw);
	VCREATE_DATA(croph);
378 379 380 381
	VCREATE_DATA(input);
	VCREATE_DATA(audiomode);
	VCREATE_DATA(res_hor);
	VCREATE_DATA(res_ver);
382 383 384
	VCREATE_DATA(srate);
#undef VCREATE_DATA

385
	struct pvr2_ctld_info *mpeg_ctrl_info;
386

387
	struct pvr2_ctrl *controls;
388
	unsigned int control_cnt;
389 390
};

391 392 393
/* This function gets the current frequency */
unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);

394 395
void pvr2_hdw_status_poll(struct pvr2_hdw *);

396 397 398 399 400 401 402 403 404 405 406
#endif /* __PVRUSB2_HDW_INTERNAL_H */

/*
  Stuff for Emacs to see, in order to encourage consistent editing style:
  *** Local Variables: ***
  *** mode: c ***
  *** fill-column: 75 ***
  *** tab-width: 8 ***
  *** c-basic-offset: 8 ***
  *** End: ***
  */