Loading...
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
48typedef int (*pvr2_ctlf_is_dirty)(struct pvr2_ctrl *);
49typedef void (*pvr2_ctlf_clear_dirty)(struct pvr2_ctrl *);
50typedef int (*pvr2_ctlf_check_value)(struct pvr2_ctrl *,int);
51typedef int (*pvr2_ctlf_get_value)(struct pvr2_ctrl *,int *);
52typedef int (*pvr2_ctlf_set_value)(struct pvr2_ctrl *,int msk,int val);
53typedef int (*pvr2_ctlf_val_to_sym)(struct pvr2_ctrl *,int msk,int val,
54 char *,unsigned int,unsigned int *);
55typedef int (*pvr2_ctlf_sym_to_val)(struct pvr2_ctrl *,
56 const char *,unsigned int,
57 int *mskp,int *valp);
58typedef 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. */
62struct 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
117struct pvr2_ctld_info {
118 struct pvr2_ctl_info info;
119 char desc[PVR2_CTLD_INFO_DESC_SIZE];
120};
121
122struct 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
141typedef 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) */
147struct 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 */
377unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);
378
379void pvr2_hdw_status_poll(struct pvr2_hdw *);
380
381#endif /* __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/drv-intf/cx2341x.h>
43#include <media/i2c/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
62typedef int (*pvr2_ctlf_is_dirty)(struct pvr2_ctrl *);
63typedef void (*pvr2_ctlf_clear_dirty)(struct pvr2_ctrl *);
64typedef int (*pvr2_ctlf_check_value)(struct pvr2_ctrl *,int);
65typedef int (*pvr2_ctlf_get_value)(struct pvr2_ctrl *,int *);
66typedef int (*pvr2_ctlf_set_value)(struct pvr2_ctrl *,int msk,int val);
67typedef int (*pvr2_ctlf_val_to_sym)(struct pvr2_ctrl *,int msk,int val,
68 char *,unsigned int,unsigned int *);
69typedef int (*pvr2_ctlf_sym_to_val)(struct pvr2_ctrl *,
70 const char *,unsigned int,
71 int *mskp,int *valp);
72typedef 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. */
76struct 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
131struct pvr2_ctld_info {
132 struct pvr2_ctl_info info;
133 char desc[PVR2_CTLD_INFO_DESC_SIZE];
134};
135
136struct 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
155typedef 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) */
161struct 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 int std_enum_cur; // selected standard enumeration value
321 int std_dirty; // True if std_mask_cur has changed
322 struct pvr2_ctl_info std_info_enum;
323 struct pvr2_ctl_info std_info_avail;
324 struct pvr2_ctl_info std_info_cur;
325 struct pvr2_ctl_info std_info_detect;
326
327 // Generated string names, one per actual V4L2 standard
328 const char *std_mask_ptrs[32];
329 char std_mask_names[32][16];
330
331 int unit_number; /* ID for driver instance */
332 unsigned long serial_number; /* ID for hardware itself */
333
334 char bus_info[32]; /* Bus location info */
335
336 /* Minor numbers used by v4l logic (yes, this is a hack, as there
337 should be no v4l junk here). Probably a better way to do this. */
338 int v4l_minor_number_video;
339 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 /* Location of eeprom or a negative number if none */
348 int eeprom_addr;
349
350 enum pvr2_config active_stream_type;
351 enum pvr2_config desired_stream_type;
352
353 /* Control state needed for cx2341x module */
354 struct cx2341x_mpeg_params enc_cur_state;
355 struct cx2341x_mpeg_params enc_ctl_state;
356 /* True if an encoder attribute has changed */
357 int enc_stale;
358 /* True if an unsafe encoder attribute has changed */
359 int enc_unsafe_stale;
360 /* True if enc_cur_state is valid */
361 int enc_cur_valid;
362
363 /* Control state */
364#define VCREATE_DATA(lab) int lab##_val; int lab##_dirty
365 VCREATE_DATA(brightness);
366 VCREATE_DATA(contrast);
367 VCREATE_DATA(saturation);
368 VCREATE_DATA(hue);
369 VCREATE_DATA(volume);
370 VCREATE_DATA(balance);
371 VCREATE_DATA(bass);
372 VCREATE_DATA(treble);
373 VCREATE_DATA(mute);
374 VCREATE_DATA(cropl);
375 VCREATE_DATA(cropt);
376 VCREATE_DATA(cropw);
377 VCREATE_DATA(croph);
378 VCREATE_DATA(input);
379 VCREATE_DATA(audiomode);
380 VCREATE_DATA(res_hor);
381 VCREATE_DATA(res_ver);
382 VCREATE_DATA(srate);
383#undef VCREATE_DATA
384
385 struct pvr2_ctld_info *mpeg_ctrl_info;
386
387 struct pvr2_ctrl *controls;
388 unsigned int control_cnt;
389};
390
391/* This function gets the current frequency */
392unsigned long pvr2_hdw_get_cur_freq(struct pvr2_hdw *);
393
394void pvr2_hdw_status_poll(struct pvr2_hdw *);
395
396#endif /* __PVRUSB2_HDW_INTERNAL_H */