[linux-2.6-block.git] / drivers / media / usb / dvb-usb-v2 / dvb_usb.h

/*
 * DVB USB framework
 *
 * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@desy.de>
 * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
 *
 *    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, or
 *    (at your option) any later version.
 *
 *    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.,
 *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef DVB_USB_H
#define DVB_USB_H

#include <linux/usb/input.h>
#include <linux/firmware.h>
#include <media/rc-core.h>

#include "dvb_frontend.h"
#include "dvb_demux.h"
#include "dvb_net.h"
#include "dmxdev.h"
#include "dvb-usb-ids.h"

/*
 * device file: /dev/dvb/adapter[0-1]/frontend[0-2]
 *
 * |-- device
 * |   |-- adapter0
 * |   |   |-- frontend0
 * |   |   |-- frontend1
 * |   |   `-- frontend2
 * |   `-- adapter1
 * |       |-- frontend0
 * |       |-- frontend1
 * |       `-- frontend2
 *
 *
 * Commonly used variable names:
 * d = pointer to device (struct dvb_usb_device *)
 * adap = pointer to adapter (struct dvb_usb_adapter *)
 * fe = pointer to frontend (struct dvb_frontend *)
 *
 * Use macros defined in that file to resolve needed pointers.
 */

/* helper macros for every DVB USB driver use */
#define adap_to_d(adap) (container_of(adap, struct dvb_usb_device, \
		adapter[adap->id]))
#define adap_to_priv(adap) (adap_to_d(adap)->priv)
#define fe_to_adap(fe) ((struct dvb_usb_adapter *) ((fe)->dvb->priv))
#define fe_to_d(fe) (adap_to_d(fe_to_adap(fe)))
#define fe_to_priv(fe) (fe_to_d(fe)->priv)
#define d_to_priv(d) (d->priv)

#define dvb_usb_dbg_usb_control_msg(udev, r, t, v, i, b, l) { \
	char *direction; \
	if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
		direction = ">>>"; \
	else \
		direction = "<<<"; \
	dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
			"%s %*ph\n",  __func__, t, r, v & 0xff, v >> 8, \
			i & 0xff, i >> 8, l & 0xff, l >> 8, direction, l, b); \
}

#define DVB_USB_STREAM_BULK(endpoint_, count_, size_) { \
	.type = USB_BULK, \
	.count = count_, \
	.endpoint = endpoint_, \
	.u = { \
		.bulk = { \
			.buffersize = size_, \
		} \
	} \
}

#define DVB_USB_STREAM_ISOC(endpoint_, count_, frames_, size_, interval_) { \
	.type = USB_ISOC, \
	.count = count_, \
	.endpoint = endpoint_, \
	.u = { \
		.isoc = { \
			.framesperurb = frames_, \
			.framesize = size_,\
			.interval = interval_, \
		} \
	} \
}

#define DVB_USB_DEVICE(vend, prod, props_, name_, rc) \
	.match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
	.idVendor = (vend), \
	.idProduct = (prod), \
	.driver_info = (kernel_ulong_t) &((const struct dvb_usb_driver_info) { \
		.props = (props_), \
		.name = (name_), \
		.rc_map = (rc), \
	})

struct dvb_usb_device;
struct dvb_usb_adapter;

/**
 * structure for carrying all needed data from the device driver to the general
 * dvb usb routines
 * @name: device name
 * @rc_map: name of rc codes table
 * @props: structure containing all device properties
 */
struct dvb_usb_driver_info {
	const char *name;
	const char *rc_map;
	const struct dvb_usb_device_properties *props;
};

/**
 * structure for remote controller configuration
 * @map_name: name of rc codes table
 * @allowed_protos: protocol(s) supported by the driver
 * @change_protocol: callback to change protocol
 * @query: called to query an event from the device
 * @interval: time in ms between two queries
 * @driver_type: used to point if a device supports raw mode
 * @bulk_mode: device supports bulk mode for rc (disable polling mode)
 */
struct dvb_usb_rc {
	const char *map_name;
	u64 allowed_protos;
	int (*change_protocol)(struct rc_dev *dev, u64 *rc_type);
	int (*query) (struct dvb_usb_device *d);
	unsigned int interval;
	const enum rc_driver_type driver_type;
	bool bulk_mode;
};

/**
 * usb streaming configration for adapter
 * @type: urb type
 * @count: count of used urbs
 * @endpoint: stream usb endpoint number
 */
struct usb_data_stream_properties {
#define USB_BULK  1
#define USB_ISOC  2
	u8 type;
	u8 count;
	u8 endpoint;

	union {
		struct {
			unsigned int buffersize; /* per URB */
		} bulk;
		struct {
			int framesperurb;
			int framesize;
			int interval;
		} isoc;
	} u;
};

/**
 * properties of dvb usb device adapter
 * @caps: adapter capabilities
 * @pid_filter_count: pid count of adapter pid-filter
 * @pid_filter_ctrl: called to enable/disable pid-filter
 * @pid_filter: called to set/unset pid for filtering
 * @stream: adapter usb stream configuration
 */
#define MAX_NO_OF_FE_PER_ADAP 3
struct dvb_usb_adapter_properties {
#define DVB_USB_ADAP_HAS_PID_FILTER               0x01
#define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02
#define DVB_USB_ADAP_NEED_PID_FILTERING           0x04
	u8 caps;

	u8 pid_filter_count;
	int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int);
	int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int);

	struct usb_data_stream_properties stream;
};

/**
 * struct dvb_usb_device_properties - properties of a dvb-usb-device
 * @driver_name: name of the owning driver module
 * @owner: owner of the dvb_adapter
 * @adapter_nr: values from the DVB_DEFINE_MOD_OPT_ADAPTER_NR() macro
 * @bInterfaceNumber: usb interface number driver binds
 * @size_of_priv: bytes allocated for the driver private data
 * @generic_bulk_ctrl_endpoint: bulk control endpoint number for sent
 * @generic_bulk_ctrl_endpoint_response: bulk control endpoint number for
 *  receive
 * @generic_bulk_ctrl_delay: delay between bulk control sent and receive message
 * @identify_state: called to determine the firmware state (cold or warm) and
 *  return possible firmware file name to be loaded
 * @firmware: name of the firmware file to be loaded
 * @download_firmware: called to download the firmware
 * @i2c_algo: i2c_algorithm if the device has i2c-adapter
 * @num_adapters: dvb usb device adapter count
 * @get_adapter_count: called to resolve adapter count
 * @adapter: array of all adapter properties of device
 * @power_ctrl: called to enable/disable power of the device
 * @read_config: called to resolve device configuration
 * @read_mac_address: called to resolve adapter mac-address
 * @frontend_attach: called to attach the possible frontends
 * @tuner_attach: called to attach the possible tuners
 * @frontend_ctrl: called to power on/off active frontend
 * @streaming_ctrl: called to start/stop the usb streaming of adapter
 * @init: called after adapters are created in order to finalize device
 *  configuration
 * @exit: called when driver is unloaded
 * @get_rc_config: called to resolve used remote controller configuration
 * @get_stream_config: called to resolve input and output stream configuration
 *  of the adapter just before streaming is started. input stream is transport
 *  stream from the demodulator and output stream is usb stream to host.
 */
#define MAX_NO_OF_ADAPTER_PER_DEVICE 2
struct dvb_usb_device_properties {
	const char *driver_name;
	struct module *owner;
	short *adapter_nr;

	u8 bInterfaceNumber;
	unsigned int size_of_priv;
	u8 generic_bulk_ctrl_endpoint;
	u8 generic_bulk_ctrl_endpoint_response;
	unsigned int generic_bulk_ctrl_delay;

#define WARM                  0
#define COLD                  1
	int (*identify_state) (struct dvb_usb_device *, const char **);
	const char *firmware;
#define RECONNECTS_USB        1
	int (*download_firmware) (struct dvb_usb_device *,
			const struct firmware *);

	struct i2c_algorithm *i2c_algo;

	unsigned int num_adapters;
	int (*get_adapter_count) (struct dvb_usb_device *);
	struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
	int (*power_ctrl) (struct dvb_usb_device *, int);
	int (*read_config) (struct dvb_usb_device *d);
	int (*read_mac_address) (struct dvb_usb_adapter *, u8 []);
	int (*frontend_attach) (struct dvb_usb_adapter *);
	int (*tuner_attach) (struct dvb_usb_adapter *);
	int (*frontend_ctrl) (struct dvb_frontend *, int);
	int (*streaming_ctrl) (struct dvb_frontend *, int);
	int (*init) (struct dvb_usb_device *);
	void (*exit) (struct dvb_usb_device *);
	int (*get_rc_config) (struct dvb_usb_device *, struct dvb_usb_rc *);
#define DVB_USB_FE_TS_TYPE_188        0
#define DVB_USB_FE_TS_TYPE_204        1
#define DVB_USB_FE_TS_TYPE_RAW        2
	int (*get_stream_config) (struct dvb_frontend *,  u8 *,
			struct usb_data_stream_properties *);
};

/**
 * generic object of an usb stream
 * @buf_num: number of buffer allocated
 * @buf_size: size of each buffer in buf_list
 * @buf_list: array containing all allocate buffers for streaming
 * @dma_addr: list of dma_addr_t for each buffer in buf_list
 *
 * @urbs_initialized: number of URBs initialized
 * @urbs_submitted: number of URBs submitted
 */
#define MAX_NO_URBS_FOR_DATA_STREAM 10
struct usb_data_stream {
	struct usb_device *udev;
	struct usb_data_stream_properties props;

#define USB_STATE_INIT    0x00
#define USB_STATE_URB_BUF 0x01
	u8 state;

	void (*complete) (struct usb_data_stream *, u8 *, size_t);

	struct urb    *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];
	int            buf_num;
	unsigned long  buf_size;
	u8            *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];
	dma_addr_t     dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];

	int urbs_initialized;
	int urbs_submitted;

	void *user_priv;
};

/**
 * dvb adapter object on dvb usb device
 * @props: pointer to adapter properties
 * @stream: adapter the usb data stream
 * @id: index of this adapter (starting with 0)
 * @ts_type: transport stream, input stream, type
 * @suspend_resume_active: set when there is ongoing suspend / resume
 * @pid_filtering: is hardware pid_filtering used or not
 * @feed_count: current feed count
 * @max_feed_count: maimum feed count device can handle
 * @dvb_adap: adapter dvb_adapter
 * @dmxdev: adapter dmxdev
 * @demux: adapter software demuxer
 * @dvb_net: adapter dvb_net interfaces
 * @sync_mutex: mutex used to sync control and streaming of the adapter
 * @fe: adapter frontends
 * @fe_init: rerouted frontend-init function
 * @fe_sleep: rerouted frontend-sleep function
 */
struct dvb_usb_adapter {
	const struct dvb_usb_adapter_properties *props;
	struct usb_data_stream stream;
	u8 id;
	u8 ts_type;
	bool suspend_resume_active;
	bool pid_filtering;
	u8 feed_count;
	u8 max_feed_count;
	s8 active_fe;

	/* dvb */
	struct dvb_adapter   dvb_adap;
	struct dmxdev        dmxdev;
	struct dvb_demux     demux;
	struct dvb_net       dvb_net;
	struct mutex         sync_mutex;

	struct dvb_frontend *fe[MAX_NO_OF_FE_PER_ADAP];
	int (*fe_init[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
	int (*fe_sleep[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend *);
};

/**
 * dvb usb device object
 * @props: device properties
 * @name: device name
 * @rc_map: name of rc codes table
 * @udev: pointer to the device's struct usb_device
 * @intf: pointer to the device's usb interface
 * @rc: remote controller configuration
 * @probe_work: work to defer .probe()
 * @powered: indicated whether the device is power or not
 * @usb_mutex: mutex for usb control messages
 * @i2c_mutex: mutex for i2c-transfers
 * @i2c_adap: device's i2c-adapter
 * @rc_dev: rc device for the remote control
 * @rc_query_work: work for polling remote
 * @priv: private data of the actual driver (allocate by dvb usb, size defined
 *  in size_of_priv of dvb_usb_properties).
 */
struct dvb_usb_device {
	const struct dvb_usb_device_properties *props;
	const char *name;
	const char *rc_map;

	struct usb_device *udev;
	struct usb_interface *intf;
	struct dvb_usb_rc rc;
	struct work_struct probe_work;
	pid_t work_pid;
	int powered;

	/* locking */
	struct mutex usb_mutex;

	/* i2c */
	struct mutex i2c_mutex;
	struct i2c_adapter i2c_adap;

	struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];

	/* remote control */
	struct rc_dev *rc_dev;
	char rc_phys[64];
	struct delayed_work rc_query_work;

	void *priv;
};

extern int dvb_usbv2_probe(struct usb_interface *,
		const struct usb_device_id *);
extern void dvb_usbv2_disconnect(struct usb_interface *);
extern int dvb_usbv2_suspend(struct usb_interface *, pm_message_t);
extern int dvb_usbv2_resume(struct usb_interface *);
extern int dvb_usbv2_reset_resume(struct usb_interface *);

/* the generic read/write method for device control */
extern int dvb_usbv2_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16);
extern int dvb_usbv2_generic_write(struct dvb_usb_device *, u8 *, u16);

#endif
Commit	Line	Data
12042b05 AP	1	/*
	2	* DVB USB framework
	3	*
	4	* Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@desy.de>
	5	* Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
c79b339f	6	*
12042b05 AP	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, or
	10	* (at your option) any later version.
c79b339f	11	*
12042b05 AP	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
c79b339f	20	*/
12042b05	21
c79b339f AP	22	#ifndef DVB_USB_H
	23	#define DVB_USB_H
	24
831511bd	25	#include <linux/usb/input.h>
c79b339f	26	#include <linux/firmware.h>
c79b339f AP	27	#include <media/rc-core.h>
	28
	29	#include "dvb_frontend.h"
	30	#include "dvb_demux.h"
	31	#include "dvb_net.h"
	32	#include "dmxdev.h"
ccc0e348	33	#include "dvb-usb-ids.h"
c79b339f	34
f93c8028 AP	35	/*
	36	* device file: /dev/dvb/adapter[0-1]/frontend[0-2]
	37	*
	38	* \|-- device
	39	* \| \|-- adapter0
	40	* \| \| \|-- frontend0
	41	* \| \| \|-- frontend1
	42	* \| \| `-- frontend2
	43	* \| `-- adapter1
	44	* \| \|-- frontend0
	45	* \| \|-- frontend1
	46	* \| `-- frontend2
	47	*
	48	*
	49	* Commonly used variable names:
	50	* d = pointer to device (struct dvb_usb_device *)
	51	* adap = pointer to adapter (struct dvb_usb_adapter *)
	52	* fe = pointer to frontend (struct dvb_frontend *)
	53	*
	54	* Use macros defined in that file to resolve needed pointers.
	55	*/
	56
f89f9ff8	57	/* helper macros for every DVB USB driver use */
ec0dd2f2 AP	58	#define adap_to_d(adap) (container_of(adap, struct dvb_usb_device, \
ec0dd2f2 AP	59	adapter[adap->id]))
f89f9ff8 AP	60	#define adap_to_priv(adap) (adap_to_d(adap)->priv)
	61	#define fe_to_adap(fe) ((struct dvb_usb_adapter *) ((fe)->dvb->priv))
	62	#define fe_to_d(fe) (adap_to_d(fe_to_adap(fe)))
	63	#define fe_to_priv(fe) (fe_to_d(fe)->priv)
	64	#define d_to_priv(d) (d->priv)
	65
4ab79283 AP	66	#define dvb_usb_dbg_usb_control_msg(udev, r, t, v, i, b, l) { \
	67	char *direction; \
	68	if (t == (USB_TYPE_VENDOR \| USB_DIR_OUT)) \
	69	direction = ">>>"; \
	70	else \
	71	direction = "<<<"; \
	72	dev_dbg(&udev->dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x " \
	73	"%s %*ph\n", __func__, t, r, v & 0xff, v >> 8, \
	74	i & 0xff, i >> 8, l & 0xff, l >> 8, direction, l, b); \
	75	}
	76
12077a3a AP	77	#define DVB_USB_STREAM_BULK(endpoint_, count_, size_) { \
	78	.type = USB_BULK, \
	79	.count = count_, \
	80	.endpoint = endpoint_, \
	81	.u = { \
	82	.bulk = { \
	83	.buffersize = size_, \
	84	} \
	85	} \
	86	}
	87
	88	#define DVB_USB_STREAM_ISOC(endpoint_, count_, frames_, size_, interval_) { \
	89	.type = USB_ISOC, \
	90	.count = count_, \
	91	.endpoint = endpoint_, \
	92	.u = { \
	93	.isoc = { \
	94	.framesperurb = frames_, \
	95	.framesize = size_,\
	96	.interval = interval_, \
	97	} \
	98	} \
	99	}
c79b339f	100
0359b5fa AP	101	#define DVB_USB_DEVICE(vend, prod, props_, name_, rc) \
	102	.match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
	103	.idVendor = (vend), \
	104	.idProduct = (prod), \
acaec14f	105	.driver_info = (kernel_ulong_t) &((const struct dvb_usb_driver_info) { \
0359b5fa AP	106	.props = (props_), \
	107	.name = (name_), \
	108	.rc_map = (rc), \
	109	})
	110
831511bd AP	111	struct dvb_usb_device;
	112	struct dvb_usb_adapter;
	113
f93c8028 AP	114	/**
	115	* structure for carrying all needed data from the device driver to the general
	116	* dvb usb routines
	117	* @name: device name
	118	* @rc_map: name of rc codes table
	119	* @props: structure containing all device properties
	120	*/
12077a3a AP	121	struct dvb_usb_driver_info {
	122	const char *name;
	123	const char *rc_map;
	124	const struct dvb_usb_device_properties *props;
	125	};
	126
831511bd	127	/**
f93c8028 AP	128	* structure for remote controller configuration
f93c8028 AP	129	* @map_name: name of rc codes table
831511bd	130	* @allowed_protos: protocol(s) supported by the driver
831511bd	131	* @change_protocol: callback to change protocol
f93c8028 AP	132	* @query: called to query an event from the device
	133	* @interval: time in ms between two queries
	134	* @driver_type: used to point if a device supports raw mode
	135	* @bulk_mode: device supports bulk mode for rc (disable polling mode)
831511bd AP	136	*/
831511bd AP	137	struct dvb_usb_rc {
de73beee	138	const char *map_name;
831511bd	139	u64 allowed_protos;
c003ab1b	140	int (change_protocol)(struct rc_dev dev, u64 *rc_type);
831511bd AP	141	int (query) (struct dvb_usb_device d);
	142	unsigned int interval;
	143	const enum rc_driver_type driver_type;
	144	bool bulk_mode;
	145	};
c79b339f AP	146
c79b339f AP	147	/**
f93c8028 AP	148	* usb streaming configration for adapter
	149	* @type: urb type
	150	* @count: count of used urbs
	151	* @endpoint: stream usb endpoint number
c79b339f AP	152	*/
	153	struct usb_data_stream_properties {
	154	#define USB_BULK 1
	155	#define USB_ISOC 2
831511bd AP	156	u8 type;
	157	u8 count;
	158	u8 endpoint;
c79b339f AP	159
	160	union {
	161	struct {
831511bd	162	unsigned int buffersize; /* per URB */
c79b339f AP	163	} bulk;
	164	struct {
	165	int framesperurb;
	166	int framesize;
	167	int interval;
	168	} isoc;
	169	} u;
	170	};
	171
	172	/**
f93c8028 AP	173	* properties of dvb usb device adapter
	174	* @caps: adapter capabilities
	175	* @pid_filter_count: pid count of adapter pid-filter
	176	* @pid_filter_ctrl: called to enable/disable pid-filter
	177	* @pid_filter: called to set/unset pid for filtering
	178	* @stream: adapter usb stream configuration
c79b339f	179	*/
c79b339f AP	180	#define MAX_NO_OF_FE_PER_ADAP 3
c79b339f AP	181	struct dvb_usb_adapter_properties {
e46c5b66 AP	182	#define DVB_USB_ADAP_HAS_PID_FILTER 0x01
	183	#define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02
	184	#define DVB_USB_ADAP_NEED_PID_FILTERING 0x04
831511bd	185	u8 caps;
c79b339f	186
831511bd	187	u8 pid_filter_count;
e46c5b66 AP	188	int (pid_filter_ctrl) (struct dvb_usb_adapter , int);
	189	int (pid_filter) (struct dvb_usb_adapter , int, u16, int);
	190
3024985d	191	struct usb_data_stream_properties stream;
c79b339f AP	192	};
c79b339f AP	193
c79b339f AP	194	/**
c79b339f AP	195	* struct dvb_usb_device_properties - properties of a dvb-usb-device
f93c8028	196	* @driver_name: name of the owning driver module
654e62dc	197	* @owner: owner of the dvb_adapter
f93c8028 AP	198	* @adapter_nr: values from the DVB_DEFINE_MOD_OPT_ADAPTER_NR() macro
	199	* @bInterfaceNumber: usb interface number driver binds
	200	* @size_of_priv: bytes allocated for the driver private data
	201	* @generic_bulk_ctrl_endpoint: bulk control endpoint number for sent
	202	* @generic_bulk_ctrl_endpoint_response: bulk control endpoint number for
	203	* receive
	204	* @generic_bulk_ctrl_delay: delay between bulk control sent and receive message
	205	* @identify_state: called to determine the firmware state (cold or warm) and
	206	* return possible firmware file name to be loaded
	207	* @firmware: name of the firmware file to be loaded
	208	* @download_firmware: called to download the firmware
	209	* @i2c_algo: i2c_algorithm if the device has i2c-adapter
	210	* @num_adapters: dvb usb device adapter count
	211	* @get_adapter_count: called to resolve adapter count
	212	* @adapter: array of all adapter properties of device
	213	* @power_ctrl: called to enable/disable power of the device
	214	* @read_config: called to resolve device configuration
	215	* @read_mac_address: called to resolve adapter mac-address
	216	* @frontend_attach: called to attach the possible frontends
	217	* @tuner_attach: called to attach the possible tuners
	218	* @frontend_ctrl: called to power on/off active frontend
	219	* @streaming_ctrl: called to start/stop the usb streaming of adapter
dc786937	220	* @init: called after adapters are created in order to finalize device
f93c8028 AP	221	* configuration
	222	* @exit: called when driver is unloaded
	223	* @get_rc_config: called to resolve used remote controller configuration
	224	* @get_stream_config: called to resolve input and output stream configuration
	225	* of the adapter just before streaming is started. input stream is transport
	226	* stream from the demodulator and output stream is usb stream to host.
c79b339f AP	227	*/
	228	#define MAX_NO_OF_ADAPTER_PER_DEVICE 2
	229	struct dvb_usb_device_properties {
05752890	230	const char *driver_name;
654e62dc	231	struct module *owner;
55b1f704	232	short *adapter_nr;
831511bd	233
36764037	234	u8 bInterfaceNumber;
831511bd AP	235	unsigned int size_of_priv;
	236	u8 generic_bulk_ctrl_endpoint;
	237	u8 generic_bulk_ctrl_endpoint_response;
1162c7b3	238	unsigned int generic_bulk_ctrl_delay;
005bc3fc	239
a0921af7 AP	240	#define WARM 0
	241	#define COLD 1
	242	int (identify_state) (struct dvb_usb_device , const char **);
005bc3fc	243	const char *firmware;
a0921af7	244	#define RECONNECTS_USB 1
4e60d951 AP	245	int (download_firmware) (struct dvb_usb_device ,
4e60d951 AP	246	const struct firmware *);
c79b339f	247
831511bd	248	struct i2c_algorithm *i2c_algo;
c79b339f	249
831511bd	250	unsigned int num_adapters;
831511bd	251	int (get_adapter_count) (struct dvb_usb_device );
f93c8028	252	struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
831511bd	253	int (power_ctrl) (struct dvb_usb_device , int);
43402bbd	254	int (read_config) (struct dvb_usb_device d);
ddee5694	255	int (read_mac_address) (struct dvb_usb_adapter , u8 []);
2d2b37c7 AP	256	int (frontend_attach) (struct dvb_usb_adapter );
	257	int (tuner_attach) (struct dvb_usb_adapter );
	258	int (frontend_ctrl) (struct dvb_frontend , int);
a13a6e1f	259	int (streaming_ctrl) (struct dvb_frontend , int);
dc786937	260	int (init) (struct dvb_usb_device );
831511bd	261	void (exit) (struct dvb_usb_device );
05752890	262	int (get_rc_config) (struct dvb_usb_device , struct dvb_usb_rc *);
b905a2a1 AP	263	#define DVB_USB_FE_TS_TYPE_188 0
	264	#define DVB_USB_FE_TS_TYPE_204 1
	265	#define DVB_USB_FE_TS_TYPE_RAW 2
	266	int (get_stream_config) (struct dvb_frontend , u8 *,
39831f09	267	struct usb_data_stream_properties *);
c79b339f AP	268	};
	269
	270	/**
f93c8028 AP	271	* generic object of an usb stream
	272	* @buf_num: number of buffer allocated
	273	* @buf_size: size of each buffer in buf_list
	274	* @buf_list: array containing all allocate buffers for streaming
	275	* @dma_addr: list of dma_addr_t for each buffer in buf_list
c79b339f	276	*
f93c8028 AP	277	* @urbs_initialized: number of URBs initialized
f93c8028 AP	278	* @urbs_submitted: number of URBs submitted
c79b339f AP	279	*/
	280	#define MAX_NO_URBS_FOR_DATA_STREAM 10
	281	struct usb_data_stream {
831511bd AP	282	struct usb_device *udev;
831511bd AP	283	struct usb_data_stream_properties props;
c79b339f AP	284
	285	#define USB_STATE_INIT 0x00
	286	#define USB_STATE_URB_BUF 0x01
831511bd	287	u8 state;
c79b339f AP	288
	289	void (complete) (struct usb_data_stream , u8 *, size_t);
	290
	291	struct urb *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];
	292	int buf_num;
	293	unsigned long buf_size;
	294	u8 *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];
	295	dma_addr_t dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];
	296
	297	int urbs_initialized;
	298	int urbs_submitted;
	299
	300	void *user_priv;
	301	};
	302
	303	/**
f93c8028 AP	304	* dvb adapter object on dvb usb device
	305	* @props: pointer to adapter properties
	306	* @stream: adapter the usb data stream
	307	* @id: index of this adapter (starting with 0)
	308	* @ts_type: transport stream, input stream, type
06bae122	309	* @suspend_resume_active: set when there is ongoing suspend / resume
f93c8028 AP	310	* @pid_filtering: is hardware pid_filtering used or not
	311	* @feed_count: current feed count
	312	* @max_feed_count: maimum feed count device can handle
	313	* @dvb_adap: adapter dvb_adapter
	314	* @dmxdev: adapter dmxdev
	315	* @demux: adapter software demuxer
	316	* @dvb_net: adapter dvb_net interfaces
	317	* @sync_mutex: mutex used to sync control and streaming of the adapter
	318	* @fe: adapter frontends
	319	* @fe_init: rerouted frontend-init function
	320	* @fe_sleep: rerouted frontend-sleep function
c79b339f	321	*/
c79b339f	322	struct dvb_usb_adapter {
f093c388	323	const struct dvb_usb_adapter_properties *props;
e46c5b66	324	struct usb_data_stream stream;
831511bd	325	u8 id;
b905a2a1	326	u8 ts_type;
06bae122	327	bool suspend_resume_active;
831511bd AP	328	bool pid_filtering;
	329	u8 feed_count;
	330	u8 max_feed_count;
	331	s8 active_fe;
191f79a4	332
c79b339f AP	333	/* dvb */
	334	struct dvb_adapter dvb_adap;
	335	struct dmxdev dmxdev;
	336	struct dvb_demux demux;
	337	struct dvb_net dvb_net;
831511bd	338	struct mutex sync_mutex;
c79b339f	339
20bb9cc4 AP	340	struct dvb_frontend *fe[MAX_NO_OF_FE_PER_ADAP];
	341	int (fe_init[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend );
	342	int (fe_sleep[MAX_NO_OF_FE_PER_ADAP]) (struct dvb_frontend );
c79b339f AP	343	};
	344
	345	/**
f93c8028 AP	346	* dvb usb device object
	347	* @props: device properties
	348	* @name: device name
	349	* @rc_map: name of rc codes table
	350	* @udev: pointer to the device's struct usb_device
	351	* @intf: pointer to the device's usb interface
	352	* @rc: remote controller configuration
	353	* @probe_work: work to defer .probe()
	354	* @powered: indicated whether the device is power or not
	355	* @usb_mutex: mutex for usb control messages
	356	* @i2c_mutex: mutex for i2c-transfers
	357	* @i2c_adap: device's i2c-adapter
f93c8028	358	* @rc_dev: rc device for the remote control
f93c8028 AP	359	* @rc_query_work: work for polling remote
f93c8028 AP	360	* @priv: private data of the actual driver (allocate by dvb usb, size defined
c79b339f AP	361	* in size_of_priv of dvb_usb_properties).
	362	*/
	363	struct dvb_usb_device {
f093c388	364	const struct dvb_usb_device_properties *props;
7dfd1242	365	const char *name;
64921670	366	const char *rc_map;
831511bd	367
c79b339f	368	struct usb_device *udev;
831511bd AP	369	struct usb_interface *intf;
831511bd AP	370	struct dvb_usb_rc rc;
4f208d4e	371	struct work_struct probe_work;
3238aafb	372	pid_t work_pid;
c79b339f AP	373	int powered;
	374
	375	/* locking */
	376	struct mutex usb_mutex;
	377
	378	/* i2c */
	379	struct mutex i2c_mutex;
	380	struct i2c_adapter i2c_adap;
	381
c79b339f AP	382	struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
	383
	384	/* remote control */
	385	struct rc_dev *rc_dev;
c79b339f AP	386	char rc_phys[64];
c79b339f AP	387	struct delayed_work rc_query_work;
c79b339f	388
c79b339f AP	389	void *priv;
	390	};
	391
6b8c8c40	392	extern int dvb_usbv2_probe(struct usb_interface *,
55b1f704	393	const struct usb_device_id *);
6b8c8c40	394	extern void dvb_usbv2_disconnect(struct usb_interface *);
ef81e9eb AP	395	extern int dvb_usbv2_suspend(struct usb_interface *, pm_message_t);
ef81e9eb AP	396	extern int dvb_usbv2_resume(struct usb_interface *);
15d08836	397	extern int dvb_usbv2_reset_resume(struct usb_interface *);
c79b339f AP	398
c79b339f AP	399	/* the generic read/write method for device control */
1162c7b3	400	extern int dvb_usbv2_generic_rw(struct dvb_usb_device , u8 , u16, u8 *, u16);
c79b339f AP	401	extern int dvb_usbv2_generic_write(struct dvb_usb_device , u8 , u16);
c79b339f AP	402
c79b339f	403	#endif