[deliverable/linux.git] / drivers / media / video / pvrusb2 / pvrusb2-hdw-internal.h

/*
 *
 *  $Id$
 *
 *  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>
#include <linux/workqueue.h>
#include <linux/mutex.h>
#include "pvrusb2-hdw.h"
#include "pvrusb2-io.h"
#include <media/cx2341x.h>
#include "pvrusb2-devattr.h"

/* 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)

struct pvr2_decoder;

typedef int (*pvr2_ctlf_is_dirty)(struct pvr2_ctrl *);
typedef void (*pvr2_ctlf_clear_dirty)(struct pvr2_ctrl *);
typedef int (*pvr2_ctlf_check_value)(struct pvr2_ctrl *,int);
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);
typedef unsigned int (*pvr2_ctlf_get_v4lflags)(struct pvr2_ctrl *);

/* 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 */
	pvr2_ctlf_get_value get_min_value;  /* Get minimum allowed value */
	pvr2_ctlf_get_value get_max_value;  /* Get maximum allowed value */
	pvr2_ctlf_set_value set_value;      /* Set its value */
	pvr2_ctlf_check_value check_value;  /* Check that value is valid */
	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 */
	pvr2_ctlf_get_v4lflags get_v4lflags;/* Retrieve v4l flags */

	/* 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 */
			const char **value_names; /* symbol names */
		} type_enum;
		struct { /* bitmask control */
			unsigned int valid_bits; /* bits in use */
			const char **bit_names;  /* symbol name/bit */
		} type_bitmask;
	} def;
};


/* 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];
};

struct pvr2_ctrl {
	const struct pvr2_ctl_info *info;
	struct pvr2_hdw *hdw;
};


struct pvr2_decoder_ctrl {
	void *ctxt;
	void (*detach)(void *);
	void (*enable)(void *,int);
	void (*force_reset)(void *);
};

#define PVR2_I2C_PEND_DETECT  0x01  /* Need to detect a client type */
#define PVR2_I2C_PEND_CLIENT  0x02  /* Client needs a specific update */
#define PVR2_I2C_PEND_REFRESH 0x04  /* Client has specific pending bits */
#define PVR2_I2C_PEND_STALE   0x08  /* Broadcast pending bits */

#define PVR2_I2C_PEND_ALL (PVR2_I2C_PEND_DETECT |\
			   PVR2_I2C_PEND_CLIENT |\
			   PVR2_I2C_PEND_REFRESH |\
			   PVR2_I2C_PEND_STALE)

/* 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

/* 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

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;

	/* Device description, anything that must adjust behavior based on
	   device specific info will use information held here. */
	const struct pvr2_device_desc *hdw_desc;

	/* Kernel worker thread handling */
	struct workqueue_struct *workqueue;
	struct work_struct workpoll;     /* Update driver state */
	struct work_struct worki2csync;  /* Update i2c clients */

	/* Video spigot */
	struct pvr2_stream *vid_stream;

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

	char name[32];

	/* 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;
	unsigned int i2c_pend_types;    /* Which types of update are needed */
	unsigned long i2c_pend_mask;    /* Change bits we need to scan */
	unsigned long i2c_stale_mask;   /* Pending broadcast change bits */
	unsigned long i2c_active_mask;  /* All change bits currently in use */
	struct list_head i2c_clients;
	struct mutex i2c_list_lock;

	/* 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;
	int ctl_write_pend_flag;
	int ctl_read_pend_flag;
	int ctl_timeout_flag;
	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;   //

	/* Bits of state that describe what is going on with various parts
	   of the driver. */
	int state_pathway_ok;         /* Pathway config is ok */
	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 */
	int state_encoder_runok;      /* Encoder has run for >= .25 sec */
	int state_decoder_run;        /* Decoder is running */
	int state_usbstream_run;      /* FX2 is streaming */
	int state_decoder_quiescent;  /* Decoder idle for > 50msec */
	int state_pipeline_config;    /* Pipeline is configured */
	int state_pipeline_req;       /* Somebody wants to stream */
	int state_pipeline_pause;     /* Pipeline must be paused */
	int state_pipeline_idle;      /* Pipeline not running */

	/* 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;

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

	/* True if states must be re-evaluated */
	int state_stale;

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

	/* Timer for measuring decoder settling time */
	struct timer_list quiescent_timer;

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

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

	/* Place to block while waiting for state changes */
	wait_queue_head_t state_wait_data;


	int flag_ok;            /* device in known good state */
	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 */
	int pathway_state;      /* one of PVR2_PATHWAY_xxx */
	int flag_decoder_missed;/* We've noticed missing decoder */
	int flag_tripped;       /* Indicates overall failure to start */

	struct pvr2_decoder_ctrl *decoder_ctrl;

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

	// True if there is a request to trigger logging of state in each
	// module.
	int log_requested;

	/* Tuner / frequency control stuff */
	unsigned int tuner_type;
	int tuner_updated;
	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 */
	int freqDirty;

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

	/* 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 */

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

	/* 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. */
	int v4l_minor_number_video;
	int v4l_minor_number_vbi;
	int v4l_minor_number_radio;

	/* Bit mask of PVR2_CVAL_INPUT choices which are valid */
	unsigned int input_avail_mask;

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

	enum pvr2_config active_stream_type;
	enum pvr2_config desired_stream_type;

	/* 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;
	/* True if an unsafe encoder attribute has changed */
	int enc_unsafe_stale;
	/* True if enc_cur_state is valid */
	int enc_cur_valid;

	/* 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);
	VCREATE_DATA(input);
	VCREATE_DATA(audiomode);
	VCREATE_DATA(res_hor);
	VCREATE_DATA(res_ver);
	VCREATE_DATA(srate);
#undef VCREATE_DATA

	struct pvr2_ctld_info *mpeg_ctrl_info;

	struct pvr2_ctrl *controls;
	unsigned int control_cnt;
};

/* This function gets the current frequency */
unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);
void pvr2_hdw_set_decoder(struct pvr2_hdw *,struct pvr2_decoder_ctrl *);

#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: ***
  */
Commit	Line	Data
d855497e MI	1	/*
	2	*
	3	* $Id$
	4	*
	5	* Copyright (C) 2005 Mike Isely <isely@pobox.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21	#ifndef __PVRUSB2_HDW_INTERNAL_H
	22	#define __PVRUSB2_HDW_INTERNAL_H
	23
	24	/*
	25
	26	This header sets up all the internal structures and definitions needed to
	27	track and coordinate the driver's interaction with the hardware. ONLY
	28	source files which actually implement part of that whole circus should be
	29	including this header. Higher levels, like the external layers to the
	30	various public APIs (V4L, sysfs, etc) should NOT ever include this
	31	private, internal header. This means that pvrusb2-hdw, pvrusb2-encoder,
	32	etc will include this, but pvrusb2-v4l should not.
	33
	34	*/
	35
d855497e MI	36	#include <linux/videodev2.h>
d855497e MI	37	#include <linux/i2c.h>
681c7399	38	#include <linux/workqueue.h>
d855497e MI	39	#include <linux/mutex.h>
	40	#include "pvrusb2-hdw.h"
	41	#include "pvrusb2-io.h"
c05c0462	42	#include <media/cx2341x.h>
989eb154	43	#include "pvrusb2-devattr.h"
d855497e	44
d855497e MI	45	/* Legal values for PVR2_CID_HSM */
	46	#define PVR2_CVAL_HSM_FAIL 0
	47	#define PVR2_CVAL_HSM_FULL 1
	48	#define PVR2_CVAL_HSM_HIGH 2
	49
	50	#define PVR2_VID_ENDPOINT 0x84
	51	#define PVR2_UNK_ENDPOINT 0x86 /* maybe raw yuv ? */
	52	#define PVR2_VBI_ENDPOINT 0x88
	53
	54	#define PVR2_CTL_BUFFSIZE 64
	55
	56	#define FREQTABLE_SIZE 500
	57
	58	#define LOCK_TAKE(x) do { mutex_lock(&x##_mutex); x##_held = !0; } while (0)
	59	#define LOCK_GIVE(x) do { x##_held = 0; mutex_unlock(&x##_mutex); } while (0)
	60
	61	struct pvr2_decoder;
	62
	63	typedef int (pvr2_ctlf_is_dirty)(struct pvr2_ctrl );
	64	typedef void (pvr2_ctlf_clear_dirty)(struct pvr2_ctrl );
5549f54f	65	typedef int (pvr2_ctlf_check_value)(struct pvr2_ctrl ,int);
d855497e MI	66	typedef int (pvr2_ctlf_get_value)(struct pvr2_ctrl ,int *);
	67	typedef int (pvr2_ctlf_set_value)(struct pvr2_ctrl ,int msk,int val);
	68	typedef int (pvr2_ctlf_val_to_sym)(struct pvr2_ctrl ,int msk,int val,
	69	char ,unsigned int,unsigned int );
	70	typedef int (pvr2_ctlf_sym_to_val)(struct pvr2_ctrl ,
	71	const char *,unsigned int,
	72	int mskp,int valp);
a761f431	73	typedef unsigned int (pvr2_ctlf_get_v4lflags)(struct pvr2_ctrl );
d855497e MI	74
	75	/* This structure describes a specific control. A table of these is set up
	76	in pvrusb2-hdw.c. */
	77	struct pvr2_ctl_info {
	78	/* Control's name suitable for use as an identifier */
	79	const char *name;
	80
	81	/* Short description of control */
	82	const char *desc;
	83
	84	/* Control's implementation */
	85	pvr2_ctlf_get_value get_value; /* Get its value */
89ebd63f MI	86	pvr2_ctlf_get_value get_min_value; /* Get minimum allowed value */
89ebd63f MI	87	pvr2_ctlf_get_value get_max_value; /* Get maximum allowed value */
d855497e	88	pvr2_ctlf_set_value set_value; /* Set its value */
5549f54f	89	pvr2_ctlf_check_value check_value; /* Check that value is valid */
d855497e MI	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 */
a761f431	94	pvr2_ctlf_get_v4lflags get_v4lflags;/* Retrieve v4l flags */
d855497e MI	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 *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
c05c0462 MI	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
d855497e MI	136	struct pvr2_ctrl {
	137	const struct pvr2_ctl_info *info;
	138	struct pvr2_hdw *hdw;
	139	};
	140
	141
d855497e MI	142	struct pvr2_decoder_ctrl {
	143	void *ctxt;
	144	void (detach)(void );
	145	void (enable)(void ,int);
d855497e MI	146	void (force_reset)(void );
	147	};
	148
	149	#define PVR2_I2C_PEND_DETECT 0x01 /* Need to detect a client type */
	150	#define PVR2_I2C_PEND_CLIENT 0x02 /* Client needs a specific update */
	151	#define PVR2_I2C_PEND_REFRESH 0x04 /* Client has specific pending bits */
	152	#define PVR2_I2C_PEND_STALE 0x08 /* Broadcast pending bits */
	153
	154	#define PVR2_I2C_PEND_ALL (PVR2_I2C_PEND_DETECT \|\
	155	PVR2_I2C_PEND_CLIENT \|\
	156	PVR2_I2C_PEND_REFRESH \|\
	157	PVR2_I2C_PEND_STALE)
	158
	159	/* Disposition of firmware1 loading situation */
	160	#define FW1_STATE_UNKNOWN 0
	161	#define FW1_STATE_MISSING 1
	162	#define FW1_STATE_FAILED 2
	163	#define FW1_STATE_RELOAD 3
	164	#define FW1_STATE_OK 4
	165
62433e31 MI	166	/* What state the device is in if it is a hybrid */
	167	#define PVR2_PATHWAY_UNKNOWN 0
	168	#define PVR2_PATHWAY_ANALOG 1
	169	#define PVR2_PATHWAY_DIGITAL 2
	170
d855497e MI	171	typedef int (pvr2_i2c_func)(struct pvr2_hdw ,u8,u8 ,u16,u8 , u16);
	172	#define PVR2_I2C_FUNC_CNT 128
	173
	174	/* This structure contains all state data directly needed to
	175	manipulate the hardware (as opposed to complying with a kernel
	176	interface) */
	177	struct pvr2_hdw {
	178	/* Underlying USB device handle */
	179	struct usb_device *usb_dev;
	180	struct usb_interface *usb_intf;
	181
f66fbd71 MI	182	/* Device description, anything that must adjust behavior based on
f66fbd71 MI	183	device specific info will use information held here. */
989eb154	184	const struct pvr2_device_desc *hdw_desc;
d855497e	185
681c7399 MI	186	/* Kernel worker thread handling */
	187	struct workqueue_struct *workqueue;
	188	struct work_struct workpoll; /* Update driver state */
	189	struct work_struct worki2csync; /* Update i2c clients */
681c7399	190
d855497e MI	191	/* Video spigot */
	192	struct pvr2_stream *vid_stream;
	193
	194	/* Mutex for all hardware state control */
	195	struct mutex big_lock_mutex;
	196	int big_lock_held; /* For debugging */
	197
d855497e MI	198	char name[32];
	199
	200	/* I2C stuff */
	201	struct i2c_adapter i2c_adap;
	202	struct i2c_algorithm i2c_algo;
	203	pvr2_i2c_func i2c_func[PVR2_I2C_FUNC_CNT];
	204	int i2c_cx25840_hack_state;
	205	int i2c_linked;
	206	unsigned int i2c_pend_types; /* Which types of update are needed */
	207	unsigned long i2c_pend_mask; /* Change bits we need to scan */
	208	unsigned long i2c_stale_mask; /* Pending broadcast change bits */
	209	unsigned long i2c_active_mask; /* All change bits currently in use */
	210	struct list_head i2c_clients;
	211	struct mutex i2c_list_lock;
	212
	213	/* Frequency table */
	214	unsigned int freqTable[FREQTABLE_SIZE];
	215	unsigned int freqProgSlot;
d855497e MI	216
	217	/* Stuff for handling low level control interaction with device */
	218	struct mutex ctl_lock_mutex;
	219	int ctl_lock_held; /* For debugging */
	220	struct urb *ctl_write_urb;
	221	struct urb *ctl_read_urb;
	222	unsigned char *ctl_write_buffer;
	223	unsigned char *ctl_read_buffer;
26e33048 MI	224	int ctl_write_pend_flag;
	225	int ctl_read_pend_flag;
	226	int ctl_timeout_flag;
d855497e MI	227	struct completion ctl_done;
	228	unsigned char cmd_buffer[PVR2_CTL_BUFFSIZE];
	229	int cmd_debug_state; // Low level command debugging info
	230	unsigned char cmd_debug_code; //
	231	unsigned int cmd_debug_write_len; //
	232	unsigned int cmd_debug_read_len; //
	233
681c7399 MI	234	/* Bits of state that describe what is going on with various parts
681c7399 MI	235	of the driver. */
62433e31	236	int state_pathway_ok; /* Pathway config is ok */
e802c14b MI	237	int state_encoder_ok; /* Encoder is operational */
	238	int state_encoder_run; /* Encoder is running */
	239	int state_encoder_config; /* Encoder is configured */
	240	int state_encoder_waitok; /* Encoder pre-wait done */
d913d630	241	int state_encoder_runok; /* Encoder has run for >= .25 sec */
e802c14b MI	242	int state_decoder_run; /* Decoder is running */
	243	int state_usbstream_run; /* FX2 is streaming */
	244	int state_decoder_quiescent; /* Decoder idle for > 50msec */
	245	int state_pipeline_config; /* Pipeline is configured */
7f421fe4 MI	246	int state_pipeline_req; /* Somebody wants to stream */
	247	int state_pipeline_pause; /* Pipeline must be paused */
	248	int state_pipeline_idle; /* Pipeline not running */
681c7399 MI	249
	250	/* This is the master state of the driver. It is the combined
	251	result of other bits of state. Examining this will indicate the
	252	overall state of the driver. Values here are one of
	253	PVR2_STATE_xxxx */
	254	unsigned int master_state;
	255
40381cb0 MI	256	/* True if device led is currently on */
	257	int led_on;
	258
681c7399 MI	259	/* True if states must be re-evaluated */
	260	int state_stale;
	261
	262	void (state_func)(void );
	263	void *state_data;
	264
	265	/* Timer for measuring decoder settling time */
	266	struct timer_list quiescent_timer;
	267
	268	/* Timer for measuring encoder pre-wait time */
	269	struct timer_list encoder_wait_timer;
	270
d913d630 MI	271	/* Timer for measuring encoder minimum run time */
	272	struct timer_list encoder_run_timer;
	273
681c7399 MI	274	/* Place to block while waiting for state changes */
	275	wait_queue_head_t state_wait_data;
	276
	277
9a607f01 MI	278	int flag_ok; /* device in known good state */
	279	int flag_disconnected; /* flag_ok == 0 due to disconnect */
	280	int flag_init_ok; /* true if structure is fully initialized */
9a607f01	281	int fw1_state; /* current situation with fw1 */
62433e31	282	int pathway_state; /* one of PVR2_PATHWAY_xxx */
681c7399 MI	283	int flag_decoder_missed;/* We've noticed missing decoder */
681c7399 MI	284	int flag_tripped; /* Indicates overall failure to start */
d855497e MI	285
	286	struct pvr2_decoder_ctrl *decoder_ctrl;
	287
	288	// CPU firmware info (used to help find / save firmware data)
	289	char *fw_buffer;
	290	unsigned int fw_size;
4db666cc	291	int fw_cpu_flag; /* True if we are dealing with the CPU */
d855497e	292
d855497e MI	293	// True if there is a request to trigger logging of state in each
	294	// module.
	295	int log_requested;
	296
	297	/* Tuner / frequency control stuff */
	298	unsigned int tuner_type;
	299	int tuner_updated;
1bde0289 MI	300	unsigned int freqValTelevision; /* Current freq for tv mode */
	301	unsigned int freqValRadio; /* Current freq for radio mode */
	302	unsigned int freqSlotTelevision; /* Current slot for tv mode */
	303	unsigned int freqSlotRadio; /* Current slot for radio mode */
	304	unsigned int freqSelector; /* 0=radio 1=television */
d855497e MI	305	int freqDirty;
d855497e MI	306
18103c57 MI	307	/* Current tuner info - this information is polled from the I2C bus */
	308	struct v4l2_tuner tuner_signal_info;
	309	int tuner_signal_stale;
	310
d855497e MI	311	/* Video standard handling */
	312	v4l2_std_id std_mask_eeprom; // Hardware supported selections
	313	v4l2_std_id std_mask_avail; // Which standards we may select from
	314	v4l2_std_id std_mask_cur; // Currently selected standard(s)
	315	unsigned int std_enum_cnt; // # of enumerated standards
	316	int std_enum_cur; // selected standard enumeration value
	317	int std_dirty; // True if std_mask_cur has changed
	318	struct pvr2_ctl_info std_info_enum;
	319	struct pvr2_ctl_info std_info_avail;
	320	struct pvr2_ctl_info std_info_cur;
	321	struct v4l2_standard *std_defs;
	322	const char **std_enum_names;
	323
	324	// Generated string names, one per actual V4L2 standard
	325	const char *std_mask_ptrs[32];
	326	char std_mask_names[32][10];
	327
	328	int unit_number; /* ID for driver instance */
	329	unsigned long serial_number; /* ID for hardware itself */
	330
31a18547 MI	331	char bus_info[32]; /* Bus location info */
31a18547 MI	332
2fdf3d9c PK	333	/* Minor numbers used by v4l logic (yes, this is a hack, as there
2fdf3d9c PK	334	should be no v4l junk here). Probably a better way to do this. */
8079384e MI	335	int v4l_minor_number_video;
8079384e MI	336	int v4l_minor_number_vbi;
fd5a75fe	337	int v4l_minor_number_radio;
d855497e	338
7fb20fa3 MI	339	/* Bit mask of PVR2_CVAL_INPUT choices which are valid */
	340	unsigned int input_avail_mask;
	341
d855497e MI	342	/* Location of eeprom or a negative number if none */
	343	int eeprom_addr;
	344
681c7399 MI	345	enum pvr2_config active_stream_type;
681c7399 MI	346	enum pvr2_config desired_stream_type;
d855497e	347
b30d2441 MI	348	/* Control state needed for cx2341x module */
	349	struct cx2341x_mpeg_params enc_cur_state;
	350	struct cx2341x_mpeg_params enc_ctl_state;
	351	/* True if an encoder attribute has changed */
	352	int enc_stale;
681c7399 MI	353	/* True if an unsafe encoder attribute has changed */
681c7399 MI	354	int enc_unsafe_stale;
b30d2441 MI	355	/* True if enc_cur_state is valid */
b30d2441 MI	356	int enc_cur_valid;
c05c0462	357
d855497e MI	358	/* Control state */
	359	#define VCREATE_DATA(lab) int lab##_val; int lab##_dirty
	360	VCREATE_DATA(brightness);
	361	VCREATE_DATA(contrast);
	362	VCREATE_DATA(saturation);
	363	VCREATE_DATA(hue);
	364	VCREATE_DATA(volume);
	365	VCREATE_DATA(balance);
	366	VCREATE_DATA(bass);
	367	VCREATE_DATA(treble);
	368	VCREATE_DATA(mute);
c05c0462 MI	369	VCREATE_DATA(input);
	370	VCREATE_DATA(audiomode);
	371	VCREATE_DATA(res_hor);
	372	VCREATE_DATA(res_ver);
d855497e	373	VCREATE_DATA(srate);
d855497e MI	374	#undef VCREATE_DATA
d855497e MI	375
b30d2441	376	struct pvr2_ctld_info *mpeg_ctrl_info;
c05c0462	377
d855497e	378	struct pvr2_ctrl *controls;
c05c0462	379	unsigned int control_cnt;
d855497e MI	380	};
d855497e MI	381
1bde0289 MI	382	/* This function gets the current frequency */
1bde0289 MI	383	unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);
681c7399	384	void pvr2_hdw_set_decoder(struct pvr2_hdw ,struct pvr2_decoder_ctrl );
1bde0289	385
d855497e MI	386	#endif /* __PVRUSB2_HDW_INTERNAL_H */
	387
	388	/*
	389	Stuff for Emacs to see, in order to encourage consistent editing style:
	390	* Local Variables: *
	391	* mode: c *
	392	* fill-column: 75 *
	393	* tab-width: 8 *
	394	* c-basic-offset: 8 *
	395	* End: *
	396	*/