summaryrefslogtreecommitdiffstats
path: root/drivers/media/usb/dvb-usb-v2/dvb_usb.h
blob: 658c6d47fdff7f0fd2bf1bc8a2de7bc7a61a415d (plain)
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
/*
 * 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;
#define ADAP_INIT                0
#define ADAP_SLEEP               1
#define ADAP_STREAMING           2
	unsigned long state_bits;

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

	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
 * @rc_polling_active: set when RC polling is active
 * @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;
	bool rc_polling_active;
	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);
/* caller must hold lock when locked versions are called */
extern int dvb_usbv2_generic_rw_locked(struct dvb_usb_device *,
		u8 *, u16, u8 *, u16);
extern int dvb_usbv2_generic_write_locked(struct dvb_usb_device *, u8 *, u16);

#endif