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, \ |
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 |
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 | */ |
137 | struct dvb_usb_rc { | |
de73beee | 138 | const char *map_name; |
831511bd AP |
139 | u64 allowed_protos; |
140 | int (*change_protocol)(struct rc_dev *dev, u64 rc_type); | |
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 | |
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 |
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 | }; |
193 | ||
c79b339f AP |
194 | /** |
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 *, |
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 |
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; |
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 |
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; |
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]; |
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); |
396 | extern int dvb_usbv2_resume(struct usb_interface *); | |
15d08836 | 397 | extern int dvb_usbv2_reset_resume(struct usb_interface *); |
c79b339f AP |
398 | |
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); |
402 | ||
c79b339f | 403 | #endif |