Commit | Line | Data |
---|---|---|
776338e1 JS |
1 | /* dvb-usb-dvb.c is part of the DVB USB library. |
2 | * | |
99e44da7 | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.de) |
776338e1 JS |
4 | * see dvb-usb-init.c for copyright information. |
5 | * | |
6 | * This file contains functions for initializing and handling the | |
7 | * linux-dvb API. | |
8 | */ | |
9 | #include "dvb-usb-common.h" | |
67873d4e | 10 | #include <media/v4l2-mc.h> |
776338e1 | 11 | |
4d43e13f | 12 | /* does the complete input transfer handling */ |
776338e1 JS |
13 | static int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff) |
14 | { | |
4d43e13f | 15 | struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv; |
c8b7ced3 | 16 | int newfeedcount, ret; |
776338e1 | 17 | |
4d43e13f | 18 | if (adap == NULL) |
776338e1 JS |
19 | return -ENODEV; |
20 | ||
2d04c13a MK |
21 | if ((adap->active_fe < 0) || |
22 | (adap->active_fe >= adap->num_frontends_initialized)) { | |
77eed219 MK |
23 | return -EINVAL; |
24 | } | |
25 | ||
4d43e13f | 26 | newfeedcount = adap->feedcount + (onoff ? 1 : -1); |
776338e1 | 27 | |
4d43e13f | 28 | /* stop feed before setting a new pid if there will be no pid anymore */ |
776338e1 JS |
29 | if (newfeedcount == 0) { |
30 | deb_ts("stop feeding\n"); | |
77eed219 | 31 | usb_urb_kill(&adap->fe_adap[adap->active_fe].stream); |
776338e1 | 32 | |
77eed219 MK |
33 | if (adap->props.fe[adap->active_fe].streaming_ctrl != NULL) { |
34 | ret = adap->props.fe[adap->active_fe].streaming_ctrl(adap, 0); | |
dca6b74b MP |
35 | if (ret < 0) { |
36 | err("error while stopping stream."); | |
c8b7ced3 | 37 | return ret; |
dca6b74b | 38 | } |
c8b7ced3 | 39 | } |
776338e1 JS |
40 | } |
41 | ||
4d43e13f | 42 | adap->feedcount = newfeedcount; |
776338e1 JS |
43 | |
44 | /* activate the pid on the device specific pid_filter */ | |
2b7a7c30 MK |
45 | deb_ts("setting pid (%s): %5d %04x at index %d '%s'\n", |
46 | adap->fe_adap[adap->active_fe].pid_filtering ? | |
47 | "yes" : "no", dvbdmxfeed->pid, dvbdmxfeed->pid, | |
48 | dvbdmxfeed->index, onoff ? "on" : "off"); | |
77eed219 MK |
49 | if (adap->props.fe[adap->active_fe].caps & DVB_USB_ADAP_HAS_PID_FILTER && |
50 | adap->fe_adap[adap->active_fe].pid_filtering && | |
51 | adap->props.fe[adap->active_fe].pid_filter != NULL) | |
52 | adap->props.fe[adap->active_fe].pid_filter(adap, dvbdmxfeed->index, dvbdmxfeed->pid, onoff); | |
776338e1 JS |
53 | |
54 | /* start the feed if this was the first feed and there is still a feed | |
55 | * for reception. | |
56 | */ | |
4d43e13f | 57 | if (adap->feedcount == onoff && adap->feedcount > 0) { |
8126fdbc | 58 | deb_ts("submitting all URBs\n"); |
77eed219 | 59 | usb_urb_submit(&adap->fe_adap[adap->active_fe].stream); |
776338e1 JS |
60 | |
61 | deb_ts("controlling pid parser\n"); | |
77eed219 MK |
62 | if (adap->props.fe[adap->active_fe].caps & DVB_USB_ADAP_HAS_PID_FILTER && |
63 | adap->props.fe[adap->active_fe].caps & | |
c8b7ced3 | 64 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF && |
77eed219 MK |
65 | adap->props.fe[adap->active_fe].pid_filter_ctrl != NULL) { |
66 | ret = adap->props.fe[adap->active_fe].pid_filter_ctrl(adap, | |
67 | adap->fe_adap[adap->active_fe].pid_filtering); | |
c8b7ced3 | 68 | if (ret < 0) { |
776338e1 | 69 | err("could not handle pid_parser"); |
c8b7ced3 MP |
70 | return ret; |
71 | } | |
72 | } | |
776338e1 | 73 | deb_ts("start feeding\n"); |
77eed219 MK |
74 | if (adap->props.fe[adap->active_fe].streaming_ctrl != NULL) { |
75 | ret = adap->props.fe[adap->active_fe].streaming_ctrl(adap, 1); | |
c8b7ced3 | 76 | if (ret < 0) { |
776338e1 | 77 | err("error while enabling fifo."); |
c8b7ced3 | 78 | return ret; |
776338e1 | 79 | } |
c8b7ced3 | 80 | } |
776338e1 | 81 | |
776338e1 JS |
82 | } |
83 | return 0; | |
84 | } | |
85 | ||
86 | static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed) | |
87 | { | |
e68c2fe6 LB |
88 | deb_ts("start pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid, |
89 | dvbdmxfeed->type); | |
90 | return dvb_usb_ctrl_feed(dvbdmxfeed, 1); | |
776338e1 JS |
91 | } |
92 | ||
93 | static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) | |
94 | { | |
95 | deb_ts("stop pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid, dvbdmxfeed->type); | |
e68c2fe6 | 96 | return dvb_usb_ctrl_feed(dvbdmxfeed, 0); |
776338e1 JS |
97 | } |
98 | ||
9f806795 | 99 | static int dvb_usb_media_device_init(struct dvb_usb_adapter *adap) |
496ccf92 RLLC |
100 | { |
101 | #ifdef CONFIG_MEDIA_CONTROLLER_DVB | |
496ccf92 | 102 | struct media_device *mdev; |
a3dfc6d9 | 103 | struct dvb_usb_device *d = adap->dev; |
496ccf92 | 104 | struct usb_device *udev = d->udev; |
496ccf92 | 105 | |
67873d4e | 106 | mdev = v4l2_mc_usb_media_device_init(udev, d->desc->name); |
9832e155 | 107 | |
89a2c1d6 | 108 | dvb_register_media_controller(&adap->dvb_adap, mdev); |
496ccf92 RLLC |
109 | |
110 | dev_info(&d->udev->dev, "media controller created\n"); | |
496ccf92 | 111 | #endif |
9f806795 | 112 | return 0; |
496ccf92 RLLC |
113 | } |
114 | ||
9f806795 | 115 | static int dvb_usb_media_device_register(struct dvb_usb_adapter *adap) |
9832e155 JMC |
116 | { |
117 | #ifdef CONFIG_MEDIA_CONTROLLER_DVB | |
9f806795 MCC |
118 | return media_device_register(adap->dvb_adap.mdev); |
119 | #else | |
120 | return 0; | |
9832e155 JMC |
121 | #endif |
122 | } | |
123 | ||
a3dfc6d9 | 124 | static void dvb_usb_media_device_unregister(struct dvb_usb_adapter *adap) |
496ccf92 RLLC |
125 | { |
126 | #ifdef CONFIG_MEDIA_CONTROLLER_DVB | |
a3dfc6d9 | 127 | if (!adap->dvb_adap.mdev) |
496ccf92 RLLC |
128 | return; |
129 | ||
a3dfc6d9 | 130 | media_device_unregister(adap->dvb_adap.mdev); |
9832e155 | 131 | media_device_cleanup(adap->dvb_adap.mdev); |
a3dfc6d9 MCC |
132 | kfree(adap->dvb_adap.mdev); |
133 | adap->dvb_adap.mdev = NULL; | |
496ccf92 RLLC |
134 | #endif |
135 | } | |
136 | ||
78e92006 | 137 | int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums) |
776338e1 | 138 | { |
77eed219 | 139 | int i; |
78e92006 JG |
140 | int ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name, |
141 | adap->dev->owner, &adap->dev->udev->dev, | |
142 | adapter_nums); | |
776338e1 | 143 | |
78e92006 | 144 | if (ret < 0) { |
776338e1 JS |
145 | deb_info("dvb_register_adapter failed: error %d", ret); |
146 | goto err; | |
147 | } | |
4d43e13f PB |
148 | adap->dvb_adap.priv = adap; |
149 | ||
9f806795 MCC |
150 | ret = dvb_usb_media_device_init(adap); |
151 | if (ret < 0) { | |
152 | deb_info("dvb_usb_media_device_init failed: error %d", ret); | |
153 | goto err_mc; | |
154 | } | |
496ccf92 | 155 | |
4d43e13f | 156 | if (adap->dev->props.read_mac_address) { |
e68c2fe6 LB |
157 | if (adap->dev->props.read_mac_address(adap->dev, adap->dvb_adap.proposed_mac) == 0) |
158 | info("MAC address: %pM", adap->dvb_adap.proposed_mac); | |
776338e1 JS |
159 | else |
160 | err("MAC address reading failed."); | |
161 | } | |
162 | ||
163 | ||
4d43e13f PB |
164 | adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; |
165 | adap->demux.priv = adap; | |
776338e1 | 166 | |
77eed219 MK |
167 | adap->demux.filternum = 0; |
168 | for (i = 0; i < adap->props.num_frontends; i++) { | |
169 | if (adap->demux.filternum < adap->fe_adap[i].max_feed_count) | |
170 | adap->demux.filternum = adap->fe_adap[i].max_feed_count; | |
171 | } | |
172 | adap->demux.feednum = adap->demux.filternum; | |
4d43e13f PB |
173 | adap->demux.start_feed = dvb_usb_start_feed; |
174 | adap->demux.stop_feed = dvb_usb_stop_feed; | |
175 | adap->demux.write_to_decoder = NULL; | |
176 | if ((ret = dvb_dmx_init(&adap->demux)) < 0) { | |
e68c2fe6 | 177 | err("dvb_dmx_init failed: error %d", ret); |
776338e1 JS |
178 | goto err_dmx; |
179 | } | |
180 | ||
4d43e13f PB |
181 | adap->dmxdev.filternum = adap->demux.filternum; |
182 | adap->dmxdev.demux = &adap->demux.dmx; | |
183 | adap->dmxdev.capabilities = 0; | |
184 | if ((ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap)) < 0) { | |
e68c2fe6 | 185 | err("dvb_dmxdev_init failed: error %d", ret); |
776338e1 JS |
186 | goto err_dmx_dev; |
187 | } | |
188 | ||
60826f02 JN |
189 | if ((ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, |
190 | &adap->demux.dmx)) < 0) { | |
e68c2fe6 | 191 | err("dvb_net_init failed: error %d", ret); |
60826f02 JN |
192 | goto err_net_init; |
193 | } | |
776338e1 | 194 | |
4d43e13f | 195 | adap->state |= DVB_USB_ADAP_STATE_DVB; |
8397703e TP |
196 | return 0; |
197 | ||
60826f02 JN |
198 | err_net_init: |
199 | dvb_dmxdev_release(&adap->dmxdev); | |
776338e1 | 200 | err_dmx_dev: |
4d43e13f | 201 | dvb_dmx_release(&adap->demux); |
776338e1 | 202 | err_dmx: |
a3dfc6d9 | 203 | dvb_usb_media_device_unregister(adap); |
9f806795 | 204 | err_mc: |
4d43e13f | 205 | dvb_unregister_adapter(&adap->dvb_adap); |
776338e1 JS |
206 | err: |
207 | return ret; | |
776338e1 JS |
208 | } |
209 | ||
4d43e13f | 210 | int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap) |
776338e1 | 211 | { |
4d43e13f | 212 | if (adap->state & DVB_USB_ADAP_STATE_DVB) { |
776338e1 | 213 | deb_info("unregistering DVB part\n"); |
4d43e13f PB |
214 | dvb_net_release(&adap->dvb_net); |
215 | adap->demux.dmx.close(&adap->demux.dmx); | |
216 | dvb_dmxdev_release(&adap->dmxdev); | |
217 | dvb_dmx_release(&adap->demux); | |
a3dfc6d9 | 218 | dvb_usb_media_device_unregister(adap); |
4d43e13f PB |
219 | dvb_unregister_adapter(&adap->dvb_adap); |
220 | adap->state &= ~DVB_USB_ADAP_STATE_DVB; | |
776338e1 JS |
221 | } |
222 | return 0; | |
223 | } | |
224 | ||
77eed219 MK |
225 | static int dvb_usb_set_active_fe(struct dvb_frontend *fe, int onoff) |
226 | { | |
227 | struct dvb_usb_adapter *adap = fe->dvb->priv; | |
228 | ||
229 | int ret = (adap->props.frontend_ctrl) ? | |
230 | adap->props.frontend_ctrl(fe, onoff) : 0; | |
231 | ||
232 | if (ret < 0) { | |
233 | err("frontend_ctrl request failed"); | |
234 | return ret; | |
235 | } | |
236 | if (onoff) | |
237 | adap->active_fe = fe->id; | |
238 | ||
239 | return 0; | |
240 | } | |
241 | ||
776338e1 JS |
242 | static int dvb_usb_fe_wakeup(struct dvb_frontend *fe) |
243 | { | |
4d43e13f | 244 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
776338e1 | 245 | |
4d43e13f | 246 | dvb_usb_device_power_ctrl(adap->dev, 1); |
776338e1 | 247 | |
77eed219 | 248 | dvb_usb_set_active_fe(fe, 1); |
9bd9e3bd | 249 | |
77eed219 MK |
250 | if (adap->fe_adap[fe->id].fe_init) |
251 | adap->fe_adap[fe->id].fe_init(fe); | |
776338e1 JS |
252 | |
253 | return 0; | |
254 | } | |
255 | ||
256 | static int dvb_usb_fe_sleep(struct dvb_frontend *fe) | |
257 | { | |
4d43e13f | 258 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
776338e1 | 259 | |
77eed219 MK |
260 | if (adap->fe_adap[fe->id].fe_sleep) |
261 | adap->fe_adap[fe->id].fe_sleep(fe); | |
9bd9e3bd | 262 | |
77eed219 | 263 | dvb_usb_set_active_fe(fe, 0); |
776338e1 | 264 | |
4d43e13f | 265 | return dvb_usb_device_power_ctrl(adap->dev, 0); |
776338e1 JS |
266 | } |
267 | ||
4d43e13f | 268 | int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap) |
776338e1 | 269 | { |
77eed219 | 270 | int ret, i; |
9bd9e3bd | 271 | |
77eed219 MK |
272 | /* register all given adapter frontends */ |
273 | for (i = 0; i < adap->props.num_frontends; i++) { | |
9bd9e3bd | 274 | |
77eed219 MK |
275 | if (adap->props.fe[i].frontend_attach == NULL) { |
276 | err("strange: '%s' #%d,%d " | |
277 | "doesn't want to attach a frontend.", | |
278 | adap->dev->desc->name, adap->id, i); | |
9bd9e3bd | 279 | |
77eed219 MK |
280 | return 0; |
281 | } | |
776338e1 | 282 | |
77eed219 MK |
283 | ret = adap->props.fe[i].frontend_attach(adap); |
284 | if (ret || adap->fe_adap[i].fe == NULL) { | |
9bd9e3bd AP |
285 | /* only print error when there is no FE at all */ |
286 | if (i == 0) | |
287 | err("no frontend was attached by '%s'", | |
288 | adap->dev->desc->name); | |
289 | ||
290 | return 0; | |
291 | } | |
776338e1 | 292 | |
77eed219 | 293 | adap->fe_adap[i].fe->id = i; |
9bd9e3bd AP |
294 | |
295 | /* re-assign sleep and wakeup functions */ | |
77eed219 MK |
296 | adap->fe_adap[i].fe_init = adap->fe_adap[i].fe->ops.init; |
297 | adap->fe_adap[i].fe->ops.init = dvb_usb_fe_wakeup; | |
298 | adap->fe_adap[i].fe_sleep = adap->fe_adap[i].fe->ops.sleep; | |
299 | adap->fe_adap[i].fe->ops.sleep = dvb_usb_fe_sleep; | |
9bd9e3bd | 300 | |
77eed219 | 301 | if (dvb_register_frontend(&adap->dvb_adap, adap->fe_adap[i].fe)) { |
9bd9e3bd | 302 | err("Frontend %d registration failed.", i); |
77eed219 MK |
303 | dvb_frontend_detach(adap->fe_adap[i].fe); |
304 | adap->fe_adap[i].fe = NULL; | |
9bd9e3bd AP |
305 | /* In error case, do not try register more FEs, |
306 | * still leaving already registered FEs alive. */ | |
307 | if (i == 0) | |
308 | return -ENODEV; | |
309 | else | |
310 | return 0; | |
776338e1 | 311 | } |
5a19f312 PB |
312 | |
313 | /* only attach the tuner if the demod is there */ | |
77eed219 MK |
314 | if (adap->props.fe[i].tuner_attach != NULL) |
315 | adap->props.fe[i].tuner_attach(adap); | |
316 | ||
317 | adap->num_frontends_initialized++; | |
9bd9e3bd | 318 | } |
0d3ab841 MCC |
319 | if (ret) |
320 | return ret; | |
776338e1 | 321 | |
0230d60e | 322 | ret = dvb_create_media_graph(&adap->dvb_adap, true); |
9f806795 MCC |
323 | if (ret) |
324 | return ret; | |
496ccf92 | 325 | |
9f806795 | 326 | ret = dvb_usb_media_device_register(adap); |
9832e155 | 327 | |
0d3ab841 | 328 | return ret; |
776338e1 JS |
329 | } |
330 | ||
4d43e13f | 331 | int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap) |
776338e1 | 332 | { |
77eed219 | 333 | int i = adap->num_frontends_initialized - 1; |
9bd9e3bd AP |
334 | |
335 | /* unregister all given adapter frontends */ | |
9bd9e3bd | 336 | for (; i >= 0; i--) { |
77eed219 MK |
337 | if (adap->fe_adap[i].fe != NULL) { |
338 | dvb_unregister_frontend(adap->fe_adap[i].fe); | |
339 | dvb_frontend_detach(adap->fe_adap[i].fe); | |
9bd9e3bd | 340 | } |
4e66c97c | 341 | } |
77eed219 | 342 | adap->num_frontends_initialized = 0; |
9bd9e3bd | 343 | |
776338e1 JS |
344 | return 0; |
345 | } |