projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] media_device: move allocation out of media_device_*_init
[deliverable/linux.git] / drivers / media / usb / dvb-usb-v2 / dvb_usb_core.c
CommitLineData
c79b339f 1/*
12042b05 2 * DVB USB framework
c79b339f 3 *
99e44da7 4 * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.de>
12042b05 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.
c79b339f 16 *
12042b05
AP		 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 22#include "dvb_usb_common.h"
41b44e35 23#include <media/media-device.h>
c79b339f 24
68126673 25static int dvb_usbv2_disable_rc_polling;
59784343 26module_param_named(disable_rc_polling, dvb_usbv2_disable_rc_polling, int, 0644);
4e60d951 27MODULE_PARM_DESC(disable_rc_polling,
831511bd 28 "disable remote control polling (default: 0)");
c79b339f 29static int dvb_usb_force_pid_filter_usage;
4e60d951
AP		 30module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage,
31 int, 0444);
6d7cfec4
AP		 32MODULE_PARM_DESC(force_pid_filter_usage,
33 "force all DVB USB devices to use a PID filter, if any (default: 0)");
c79b339f 34
6d7cfec4
AP		 35static int dvb_usbv2_download_firmware(struct dvb_usb_device *d,
36 const char *name)
a0d72d24
AP		 37{
38 int ret;
a0921af7 39 const struct firmware *fw;
d10d1b9a 40 dev_dbg(&d->udev->dev, "%s:\n", __func__);
a0d72d24 41
f093c388 42 if (!d->props->download_firmware) {
a0d72d24
AP		 43 ret = -EINVAL;
44 goto err;
45 }
46
47 ret = request_firmware(&fw, name, &d->udev->dev);
48 if (ret < 0) {
6d7cfec4
AP		 49 dev_err(&d->udev->dev,
50 "%s: Did not find the firmware file '%s'. Please see linux/Documentation/dvb/ for more details on firmware-problems. Status %d\n",
51 KBUILD_MODNAME, name, ret);
a0d72d24
AP		 52 goto err;
53 }
54
d10d1b9a
AP		 55 dev_info(&d->udev->dev, "%s: downloading firmware from file '%s'\n",
56 KBUILD_MODNAME, name);
a0d72d24 57
f093c388 58 ret = d->props->download_firmware(d, fw);
a0d72d24 59 release_firmware(fw);
a0d72d24
AP		 60 if (ret < 0)
61 goto err;
62
c65bcb95 63 return ret;
a0d72d24 64err:
d10d1b9a 65 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
a0d72d24
AP		 66 return ret;
67}
68
d496eb8a 69static int dvb_usbv2_i2c_init(struct dvb_usb_device *d)
a177c72b 70{
0fba999f 71 int ret;
d10d1b9a 72 dev_dbg(&d->udev->dev, "%s:\n", __func__);
d70521a3
AP		 73
74 if (!d->props->i2c_algo)
75 return 0;
a177c72b
AP		 76
77 strlcpy(d->i2c_adap.name, d->name, sizeof(d->i2c_adap.name));
f093c388 78 d->i2c_adap.algo = d->props->i2c_algo;
a177c72b 79 d->i2c_adap.dev.parent = &d->udev->dev;
a177c72b
AP		 80 i2c_set_adapdata(&d->i2c_adap, d);
81
82 ret = i2c_add_adapter(&d->i2c_adap);
0fba999f 83 if (ret < 0) {
d70521a3 84 d->i2c_adap.algo = NULL;
d10d1b9a
AP		 85 dev_err(&d->udev->dev, "%s: i2c_add_adapter() failed=%d\n",
86 KBUILD_MODNAME, ret);
0fba999f
AP		 87 goto err;
88 }
a177c72b 89
0fba999f
AP		 90 return 0;
91err:
d10d1b9a 92 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
a177c72b
AP		 93 return ret;
94}
95
d496eb8a 96static int dvb_usbv2_i2c_exit(struct dvb_usb_device *d)
a177c72b 97{
d10d1b9a 98 dev_dbg(&d->udev->dev, "%s:\n", __func__);
0fba999f 99
d70521a3
AP		 100 if (d->i2c_adap.algo)
101 i2c_del_adapter(&d->i2c_adap);
0fba999f 102
a177c72b
AP		 103 return 0;
104}
105
37b44a0f 106#if IS_ENABLED(CONFIG_RC_CORE)
877e0aa7
AP		 107static void dvb_usb_read_remote_control(struct work_struct *work)
108{
109 struct dvb_usb_device *d = container_of(work,
110 struct dvb_usb_device, rc_query_work.work);
111 int ret;
112
831511bd
AP		 113 /*
114 * When the parameter has been set to 1 via sysfs while the
115 * driver was running, or when bulk mode is enabled after IR init.
877e0aa7 116 */
ac1c86c8
AP		 117 if (dvb_usbv2_disable_rc_polling || d->rc.bulk_mode) {
118 d->rc_polling_active = false;
877e0aa7 119 return;
ac1c86c8 120 }
877e0aa7
AP		 121
122 ret = d->rc.query(d);
831511bd 123 if (ret < 0) {
d10d1b9a
AP		 124 dev_err(&d->udev->dev, "%s: rc.query() failed=%d\n",
125 KBUILD_MODNAME, ret);
ac1c86c8 126 d->rc_polling_active = false;
831511bd
AP		 127 return; /* stop polling */
128 }
877e0aa7
AP		 129
130 schedule_delayed_work(&d->rc_query_work,
831511bd 131 msecs_to_jiffies(d->rc.interval));
877e0aa7
AP		 132}
133
134static int dvb_usbv2_remote_init(struct dvb_usb_device *d)
135{
136 int ret;
137 struct rc_dev *dev;
d10d1b9a 138 dev_dbg(&d->udev->dev, "%s:\n", __func__);
ad261839 139
877e0aa7
AP		 140 if (dvb_usbv2_disable_rc_polling || !d->props->get_rc_config)
141 return 0;
142
de73beee 143 d->rc.map_name = d->rc_map;
877e0aa7
AP		 144 ret = d->props->get_rc_config(d, &d->rc);
145 if (ret < 0)
146 goto err;
147
de73beee
AP		 148 /* disable rc when there is no keymap defined */
149 if (!d->rc.map_name)
150 return 0;
151
877e0aa7
AP		 152 dev = rc_allocate_device();
153 if (!dev) {
154 ret = -ENOMEM;
155 goto err;
156 }
157
158 dev->dev.parent = &d->udev->dev;
831511bd 159 dev->input_name = d->name;
877e0aa7
AP		 160 usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
161 strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
162 dev->input_phys = d->rc_phys;
163 usb_to_input_id(d->udev, &dev->input_id);
164 /* TODO: likely RC-core should took const char * */
165 dev->driver_name = (char *) d->props->driver_name;
de73beee 166 dev->map_name = d->rc.map_name;
877e0aa7 167 dev->driver_type = d->rc.driver_type;
c5540fbb 168 dev->allowed_protocols = d->rc.allowed_protos;
877e0aa7
AP		 169 dev->change_protocol = d->rc.change_protocol;
170 dev->priv = d;
877e0aa7
AP		 171
172 ret = rc_register_device(dev);
173 if (ret < 0) {
174 rc_free_device(dev);
175 goto err;
176 }
177
877e0aa7
AP		 178 d->rc_dev = dev;
179
180 /* start polling if needed */
181 if (d->rc.query && !d->rc.bulk_mode) {
182 /* initialize a work queue for handling polling */
183 INIT_DELAYED_WORK(&d->rc_query_work,
184 dvb_usb_read_remote_control);
6d7cfec4
AP		 185 dev_info(&d->udev->dev,
186 "%s: schedule remote query interval to %d msecs\n",
187 KBUILD_MODNAME, d->rc.interval);
877e0aa7
AP		 188 schedule_delayed_work(&d->rc_query_work,
189 msecs_to_jiffies(d->rc.interval));
ac1c86c8 190 d->rc_polling_active = true;
877e0aa7
AP		 191 }
192
877e0aa7
AP		 193 return 0;
194err:
d10d1b9a 195 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
877e0aa7
AP		 196 return ret;
197}
198
199static int dvb_usbv2_remote_exit(struct dvb_usb_device *d)
200{
d10d1b9a 201 dev_dbg(&d->udev->dev, "%s:\n", __func__);
ad261839
AP		 202
203 if (d->rc_dev) {
877e0aa7
AP		 204 cancel_delayed_work_sync(&d->rc_query_work);
205 rc_unregister_device(d->rc_dev);
ad261839 206 d->rc_dev = NULL;
877e0aa7
AP		 207 }
208
877e0aa7
AP		 209 return 0;
210}
0c87c66a 211#else
ef382402
AP		 212 #define dvb_usbv2_remote_init(args...) 0
213 #define dvb_usbv2_remote_exit(args...)
0c87c66a 214#endif
877e0aa7 215
41a0abf7
AP		 216static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buf,
217 size_t len)
218{
219 struct dvb_usb_adapter *adap = stream->user_priv;
220 dvb_dmx_swfilter(&adap->demux, buf, len);
221}
222
223static void dvb_usb_data_complete_204(struct usb_data_stream *stream, u8 *buf,
224 size_t len)
225{
226 struct dvb_usb_adapter *adap = stream->user_priv;
227 dvb_dmx_swfilter_204(&adap->demux, buf, len);
228}
229
230static void dvb_usb_data_complete_raw(struct usb_data_stream *stream, u8 *buf,
231 size_t len)
232{
233 struct dvb_usb_adapter *adap = stream->user_priv;
234 dvb_dmx_swfilter_raw(&adap->demux, buf, len);
235}
236
691a5502 237static int dvb_usbv2_adapter_stream_init(struct dvb_usb_adapter *adap)
41a0abf7 238{
d10d1b9a
AP		 239 dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
240 adap->id);
41a0abf7
AP		 241
242 adap->stream.udev = adap_to_d(adap)->udev;
243 adap->stream.user_priv = adap;
244 adap->stream.complete = dvb_usb_data_complete;
245
246 return usb_urb_initv2(&adap->stream, &adap->props->stream);
247}
248
691a5502 249static int dvb_usbv2_adapter_stream_exit(struct dvb_usb_adapter *adap)
41a0abf7 250{
d10d1b9a
AP		 251 dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
252 adap->id);
41a0abf7 253
831511bd 254 return usb_urb_exitv2(&adap->stream);
41a0abf7
AP		 255}
256
96d7ca5e 257static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
41a0abf7
AP		 258{
259 struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
260 struct dvb_usb_device *d = adap_to_d(adap);
96d7ca5e
AP		 261 int ret = 0;
262 struct usb_data_stream_properties stream_props;
263 dev_dbg(&d->udev->dev,
264 "%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
d10d1b9a 265 __func__, adap->id, adap->active_fe, dvbdmxfeed->type,
41a0abf7 266 adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
96d7ca5e 267 dvbdmxfeed->pid, dvbdmxfeed->index);
41a0abf7 268
96d7ca5e 269 /* wait init is done */
74316201 270 wait_on_bit(&adap->state_bits, ADAP_INIT, TASK_UNINTERRUPTIBLE);
bdecbe43 271
41a0abf7
AP		 272 if (adap->active_fe == -1)
273 return -EINVAL;
274
96d7ca5e
AP		 275 /* skip feed setup if we are already feeding */
276 if (adap->feed_count++ > 0)
277 goto skip_feed_start;
278
279 /* set 'streaming' status bit */
280 set_bit(ADAP_STREAMING, &adap->state_bits);
281
282 /* resolve input and output streaming parameters */
283 if (d->props->get_stream_config) {
284 memcpy(&stream_props, &adap->props->stream,
285 sizeof(struct usb_data_stream_properties));
286 ret = d->props->get_stream_config(adap->fe[adap->active_fe],
287 &adap->ts_type, &stream_props);
288 if (ret)
289 dev_err(&d->udev->dev,
290 "%s: get_stream_config() failed=%d\n",
291 KBUILD_MODNAME, ret);
292 } else {
293 stream_props = adap->props->stream;
294 }
295
296 switch (adap->ts_type) {
297 case DVB_USB_FE_TS_TYPE_204:
298 adap->stream.complete = dvb_usb_data_complete_204;
299 break;
300 case DVB_USB_FE_TS_TYPE_RAW:
301 adap->stream.complete = dvb_usb_data_complete_raw;
302 break;
303 case DVB_USB_FE_TS_TYPE_188:
304 default:
305 adap->stream.complete = dvb_usb_data_complete;
306 break;
307 }
308
309 /* submit USB streaming packets */
310 usb_urb_submitv2(&adap->stream, &stream_props);
311
312 /* enable HW PID filter */
313 if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
314 ret = adap->props->pid_filter_ctrl(adap, 1);
315 if (ret)
316 dev_err(&d->udev->dev,
317 "%s: pid_filter_ctrl() failed=%d\n",
318 KBUILD_MODNAME, ret);
319 }
320
321 /* ask device to start streaming */
322 if (d->props->streaming_ctrl) {
323 ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 1);
324 if (ret)
325 dev_err(&d->udev->dev,
326 "%s: streaming_ctrl() failed=%d\n",
327 KBUILD_MODNAME, ret);
41a0abf7 328 }
96d7ca5e 329skip_feed_start:
41a0abf7 330
96d7ca5e
AP		 331 /* add PID to device HW PID filter */
332 if (adap->pid_filtering && adap->props->pid_filter) {
41a0abf7 333 ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
96d7ca5e
AP		 334 dvbdmxfeed->pid, 1);
335 if (ret)
2d9e7ea6
AP		 336 dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
337 KBUILD_MODNAME, ret);
338 }
41a0abf7 339
96d7ca5e
AP		 340 if (ret)
341 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
342 return ret;
343}
41a0abf7 344
96d7ca5e
AP		 345static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
346{
347 struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
348 struct dvb_usb_device *d = adap_to_d(adap);
349 int ret = 0;
350 dev_dbg(&d->udev->dev,
351 "%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
352 __func__, adap->id, adap->active_fe, dvbdmxfeed->type,
353 adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
354 dvbdmxfeed->pid, dvbdmxfeed->index);
355
356 if (adap->active_fe == -1)
357 return -EINVAL;
358
359 /* remove PID from device HW PID filter */
360 if (adap->pid_filtering && adap->props->pid_filter) {
361 ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
362 dvbdmxfeed->pid, 0);
363 if (ret)
364 dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
365 KBUILD_MODNAME, ret);
41a0abf7
AP		 366 }
367
96d7ca5e
AP		 368 /* we cannot stop streaming until last PID is removed */
369 if (--adap->feed_count > 0)
370 goto skip_feed_stop;
371
372 /* ask device to stop streaming */
373 if (d->props->streaming_ctrl) {
374 ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 0);
375 if (ret)
376 dev_err(&d->udev->dev,
377 "%s: streaming_ctrl() failed=%d\n",
378 KBUILD_MODNAME, ret);
379 }
380
381 /* disable HW PID filter */
382 if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
383 ret = adap->props->pid_filter_ctrl(adap, 0);
384 if (ret)
385 dev_err(&d->udev->dev,
386 "%s: pid_filter_ctrl() failed=%d\n",
387 KBUILD_MODNAME, ret);
388 }
389
390 /* kill USB streaming packets */
391 usb_urb_killv2(&adap->stream);
392
393 /* clear 'streaming' status bit */
bdecbe43 394 clear_bit(ADAP_STREAMING, &adap->state_bits);
4e857c58 395 smp_mb__after_atomic();
bdecbe43 396 wake_up_bit(&adap->state_bits, ADAP_STREAMING);
96d7ca5e 397skip_feed_stop:
41a0abf7 398
96d7ca5e
AP		 399 if (ret)
400 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
401 return ret;
41a0abf7
AP		 402}
403
9f806795 404static int dvb_usbv2_media_device_init(struct dvb_usb_adapter *adap)
6f6c77d8
RLLC		 405{
406#ifdef CONFIG_MEDIA_CONTROLLER_DVB
6f6c77d8 407 struct media_device *mdev;
823b460e 408 struct dvb_usb_device *d = adap_to_d(adap);
6f6c77d8 409 struct usb_device *udev = d->udev;
6f6c77d8 410
6cf5dad1 411 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
6f6c77d8 412 if (!mdev)
9f806795 413 return -ENOMEM;
6f6c77d8 414
6cf5dad1
MCC		 415 media_device_usb_init(mdev, udev, d->name);
416
89a2c1d6 417 dvb_register_media_controller(&adap->dvb_adap, mdev);
6f6c77d8
RLLC		 418
419 dev_info(&d->udev->dev, "media controller created\n");
9832e155 420#endif
9f806795 421 return 0;
9832e155 422}
6f6c77d8 423
9f806795 424static int dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
9832e155
JMC		 425{
426#ifdef CONFIG_MEDIA_CONTROLLER_DVB
9f806795
MCC		 427 return media_device_register(adap->dvb_adap.mdev);
428#else
429 return 0;
6f6c77d8
RLLC		 430#endif
431}
432
823b460e 433static void dvb_usbv2_media_device_unregister(struct dvb_usb_adapter *adap)
6f6c77d8
RLLC		 434{
435#ifdef CONFIG_MEDIA_CONTROLLER_DVB
823b460e
MCC		 436
437 if (!adap->dvb_adap.mdev)
6f6c77d8
RLLC		 438 return;
439
823b460e 440 media_device_unregister(adap->dvb_adap.mdev);
9832e155 441 media_device_cleanup(adap->dvb_adap.mdev);
823b460e
MCC		 442 kfree(adap->dvb_adap.mdev);
443 adap->dvb_adap.mdev = NULL;
6f6c77d8
RLLC		 444
445#endif
446}
447
691a5502 448static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
41a0abf7
AP		 449{
450 int ret;
451 struct dvb_usb_device *d = adap_to_d(adap);
823b460e 452
d10d1b9a 453 dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
41a0abf7
AP		 454
455 ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner,
456 &d->udev->dev, d->props->adapter_nr);
457 if (ret < 0) {
d10d1b9a
AP		 458 dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n",
459 __func__, ret);
831511bd 460 goto err_dvb_register_adapter;
41a0abf7
AP		 461 }
462
463 adap->dvb_adap.priv = adap;
464
9f806795
MCC		 465 ret = dvb_usbv2_media_device_init(adap);
466 if (ret < 0) {
467 dev_dbg(&d->udev->dev, "%s: dvb_usbv2_media_device_init() failed=%d\n",
468 __func__, ret);
469 goto err_dvb_register_mc;
470 }
6f6c77d8 471
41a0abf7
AP		 472 if (d->props->read_mac_address) {
473 ret = d->props->read_mac_address(adap,
474 adap->dvb_adap.proposed_mac);
475 if (ret < 0)
831511bd 476 goto err_dvb_dmx_init;
41a0abf7 477
d10d1b9a
AP		 478 dev_info(&d->udev->dev, "%s: MAC address: %pM\n",
479 KBUILD_MODNAME, adap->dvb_adap.proposed_mac);
41a0abf7
AP		 480 }
481
482 adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
483 adap->demux.priv = adap;
484 adap->demux.filternum = 0;
831511bd 485 adap->demux.filternum = adap->max_feed_count;
41a0abf7
AP		 486 adap->demux.feednum = adap->demux.filternum;
487 adap->demux.start_feed = dvb_usb_start_feed;
488 adap->demux.stop_feed = dvb_usb_stop_feed;
489 adap->demux.write_to_decoder = NULL;
490 ret = dvb_dmx_init(&adap->demux);
491 if (ret < 0) {
d10d1b9a
AP		 492 dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n",
493 KBUILD_MODNAME, ret);
831511bd 494 goto err_dvb_dmx_init;
41a0abf7
AP		 495 }
496
497 adap->dmxdev.filternum = adap->demux.filternum;
498 adap->dmxdev.demux = &adap->demux.dmx;
499 adap->dmxdev.capabilities = 0;
500 ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
501 if (ret < 0) {
d10d1b9a
AP		 502 dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n",
503 KBUILD_MODNAME, ret);
831511bd 504 goto err_dvb_dmxdev_init;
41a0abf7
AP		 505 }
506
507 ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
508 if (ret < 0) {
d10d1b9a
AP		 509 dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n",
510 KBUILD_MODNAME, ret);
831511bd 511 goto err_dvb_net_init;
41a0abf7
AP		 512 }
513
41a0abf7 514 return 0;
831511bd 515err_dvb_net_init:
41a0abf7 516 dvb_dmxdev_release(&adap->dmxdev);
831511bd 517err_dvb_dmxdev_init:
41a0abf7 518 dvb_dmx_release(&adap->demux);
831511bd 519err_dvb_dmx_init:
823b460e 520 dvb_usbv2_media_device_unregister(adap);
9f806795 521err_dvb_register_mc:
41a0abf7 522 dvb_unregister_adapter(&adap->dvb_adap);
831511bd 523err_dvb_register_adapter:
41a0abf7
AP		 524 adap->dvb_adap.priv = NULL;
525 return ret;
526}
527
691a5502 528static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
41a0abf7 529{
d10d1b9a
AP		 530 dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
531 adap->id);
41a0abf7
AP		 532
533 if (adap->dvb_adap.priv) {
534 dvb_net_release(&adap->dvb_net);
535 adap->demux.dmx.close(&adap->demux.dmx);
536 dvb_dmxdev_release(&adap->dmxdev);
537 dvb_dmx_release(&adap->demux);
538 dvb_unregister_adapter(&adap->dvb_adap);
539 }
540
541 return 0;
542}
543
691a5502 544static int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
41a0abf7
AP		 545{
546 int ret;
547
548 if (onoff)
549 d->powered++;
550 else
551 d->powered--;
552
553 if (d->powered == 0 || (onoff && d->powered == 1)) {
554 /* when switching from 1 to 0 or from 0 to 1 */
d10d1b9a 555 dev_dbg(&d->udev->dev, "%s: power=%d\n", __func__, onoff);
41a0abf7
AP		 556 if (d->props->power_ctrl) {
557 ret = d->props->power_ctrl(d, onoff);
18cfe03d
AP		 558 if (ret < 0)
559 goto err;
41a0abf7
AP		 560 }
561 }
562
563 return 0;
564err:
d10d1b9a 565 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
41a0abf7
AP		 566 return ret;
567}
568
831511bd 569static int dvb_usb_fe_init(struct dvb_frontend *fe)
41a0abf7
AP		 570{
571 int ret;
572 struct dvb_usb_adapter *adap = fe->dvb->priv;
573 struct dvb_usb_device *d = adap_to_d(adap);
d10d1b9a
AP		 574 dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
575 fe->id);
41a0abf7 576
06bae122
AP		 577 if (!adap->suspend_resume_active) {
578 adap->active_fe = fe->id;
bdecbe43 579 set_bit(ADAP_INIT, &adap->state_bits);
06bae122
AP		 580 }
581
41a0abf7
AP		 582 ret = dvb_usbv2_device_power_ctrl(d, 1);
583 if (ret < 0)
584 goto err;
585
586 if (d->props->frontend_ctrl) {
587 ret = d->props->frontend_ctrl(fe, 1);
588 if (ret < 0)
589 goto err;
590 }
591
592 if (adap->fe_init[fe->id]) {
593 ret = adap->fe_init[fe->id](fe);
594 if (ret < 0)
595 goto err;
596 }
41a0abf7 597err:
bdecbe43
AP		 598 if (!adap->suspend_resume_active) {
599 clear_bit(ADAP_INIT, &adap->state_bits);
4e857c58 600 smp_mb__after_atomic();
bdecbe43
AP		 601 wake_up_bit(&adap->state_bits, ADAP_INIT);
602 }
0898b954 603
06bae122 604 dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
0898b954
AP		 605 return ret;
606}
607
41a0abf7
AP		 608static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
609{
610 int ret;
611 struct dvb_usb_adapter *adap = fe->dvb->priv;
612 struct dvb_usb_device *d = adap_to_d(adap);
d10d1b9a
AP		 613 dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
614 fe->id);
41a0abf7 615
bdecbe43
AP		 616 if (!adap->suspend_resume_active) {
617 set_bit(ADAP_SLEEP, &adap->state_bits);
74316201 618 wait_on_bit(&adap->state_bits, ADAP_STREAMING,
bdecbe43
AP		 619 TASK_UNINTERRUPTIBLE);
620 }
06bae122 621
41a0abf7
AP		 622 if (adap->fe_sleep[fe->id]) {
623 ret = adap->fe_sleep[fe->id](fe);
624 if (ret < 0)
625 goto err;
626 }
627
628 if (d->props->frontend_ctrl) {
629 ret = d->props->frontend_ctrl(fe, 0);
630 if (ret < 0)
631 goto err;
632 }
633
634 ret = dvb_usbv2_device_power_ctrl(d, 0);
635 if (ret < 0)
636 goto err;
41a0abf7 637err:
06bae122
AP		 638 if (!adap->suspend_resume_active) {
639 adap->active_fe = -1;
bdecbe43 640 clear_bit(ADAP_SLEEP, &adap->state_bits);
4e857c58 641 smp_mb__after_atomic();
bdecbe43 642 wake_up_bit(&adap->state_bits, ADAP_SLEEP);
06bae122 643 }
0898b954 644
06bae122 645 dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
0898b954
AP		 646 return ret;
647}
648
691a5502 649static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
41a0abf7
AP		 650{
651 int ret, i, count_registered = 0;
652 struct dvb_usb_device *d = adap_to_d(adap);
d10d1b9a 653 dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
41a0abf7
AP		 654
655 memset(adap->fe, 0, sizeof(adap->fe));
656 adap->active_fe = -1;
657
658 if (d->props->frontend_attach) {
659 ret = d->props->frontend_attach(adap);
660 if (ret < 0) {
6d7cfec4
AP		 661 dev_dbg(&d->udev->dev,
662 "%s: frontend_attach() failed=%d\n",
663 __func__, ret);
41a0abf7
AP		 664 goto err_dvb_frontend_detach;
665 }
666 } else {
d10d1b9a
AP		 667 dev_dbg(&d->udev->dev, "%s: frontend_attach() do not exists\n",
668 __func__);
41a0abf7
AP		 669 ret = 0;
670 goto err;
671 }
672
673 for (i = 0; i < MAX_NO_OF_FE_PER_ADAP && adap->fe[i]; i++) {
674 adap->fe[i]->id = i;
41a0abf7
AP		 675 /* re-assign sleep and wakeup functions */
676 adap->fe_init[i] = adap->fe[i]->ops.init;
06bae122 677 adap->fe[i]->ops.init = dvb_usb_fe_init;
41a0abf7 678 adap->fe_sleep[i] = adap->fe[i]->ops.sleep;
06bae122 679 adap->fe[i]->ops.sleep = dvb_usb_fe_sleep;
41a0abf7
AP		 680
681 ret = dvb_register_frontend(&adap->dvb_adap, adap->fe[i]);
682 if (ret < 0) {
6d7cfec4
AP		 683 dev_err(&d->udev->dev,
684 "%s: frontend%d registration failed\n",
685 KBUILD_MODNAME, i);
41a0abf7
AP		 686 goto err_dvb_unregister_frontend;
687 }
688
689 count_registered++;
690 }
691
692 if (d->props->tuner_attach) {
693 ret = d->props->tuner_attach(adap);
694 if (ret < 0) {
d10d1b9a
AP		 695 dev_dbg(&d->udev->dev, "%s: tuner_attach() failed=%d\n",
696 __func__, ret);
41a0abf7
AP		 697 goto err_dvb_unregister_frontend;
698 }
699 }
700
0230d60e 701 ret = dvb_create_media_graph(&adap->dvb_adap, true);
0d3ab841
MCC		 702 if (ret < 0)
703 goto err_dvb_unregister_frontend;
6f6c77d8 704
9f806795 705 ret = dvb_usbv2_media_device_register(adap);
9832e155 706
9f806795 707 return ret;
41a0abf7
AP		 708
709err_dvb_unregister_frontend:
710 for (i = count_registered - 1; i >= 0; i--)
711 dvb_unregister_frontend(adap->fe[i]);
712
713err_dvb_frontend_detach:
714 for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
2a858486 715 if (adap->fe[i]) {
41a0abf7 716 dvb_frontend_detach(adap->fe[i]);
2a858486
AP		 717 adap->fe[i] = NULL;
718 }
41a0abf7
AP		 719 }
720
721err:
d10d1b9a 722 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
41a0abf7
AP		 723 return ret;
724}
725
691a5502 726static int dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter *adap)
41a0abf7 727{
ca42129f
AP		 728 int ret, i;
729 struct dvb_usb_device *d = adap_to_d(adap);
730
731 dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
41a0abf7
AP		 732
733 for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
734 if (adap->fe[i]) {
735 dvb_unregister_frontend(adap->fe[i]);
736 dvb_frontend_detach(adap->fe[i]);
737 }
738 }
739
1066d77f
AP		 740 if (d->props->tuner_detach) {
741 ret = d->props->tuner_detach(adap);
742 if (ret < 0) {
743 dev_dbg(&d->udev->dev, "%s: tuner_detach() failed=%d\n",
744 __func__, ret);
745 }
746 }
747
ca42129f
AP		 748 if (d->props->frontend_detach) {
749 ret = d->props->frontend_detach(adap);
750 if (ret < 0) {
751 dev_dbg(&d->udev->dev,
752 "%s: frontend_detach() failed=%d\n",
753 __func__, ret);
754 }
755 }
756
41a0abf7
AP		 757 return 0;
758}
759
59784343 760static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
c79b339f
AP		 761{
762 struct dvb_usb_adapter *adap;
d496eb8a 763 int ret, i, adapter_count;
c79b339f 764
5b853004 765 /* resolve adapter count */
f093c388
AP		 766 adapter_count = d->props->num_adapters;
767 if (d->props->get_adapter_count) {
768 ret = d->props->get_adapter_count(d);
5b853004
AP		 769 if (ret < 0)
770 goto err;
771
772 adapter_count = ret;
773 }
774
d496eb8a
AP		 775 for (i = 0; i < adapter_count; i++) {
776 adap = &d->adapter[i];
f093c388
AP		 777 adap->id = i;
778 adap->props = &d->props->adapter[i];
4e60d951 779
e46c5b66
AP		 780 /* speed - when running at FULL speed we need a HW PID filter */
781 if (d->udev->speed == USB_SPEED_FULL &&
f093c388 782 !(adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
6d7cfec4
AP		 783 dev_err(&d->udev->dev,
784 "%s: this USB2.0 device cannot be run on a USB1.1 port (it lacks a hardware PID filter)\n",
d10d1b9a 785 KBUILD_MODNAME);
d496eb8a
AP		 786 ret = -ENODEV;
787 goto err;
e46c5b66 788 } else if ((d->udev->speed == USB_SPEED_FULL &&
f093c388
AP		 789 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
790 (adap->props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
6d7cfec4
AP		 791 dev_info(&d->udev->dev,
792 "%s: will use the device's hardware PID filter (table count: %d)\n",
793 KBUILD_MODNAME,
f093c388 794 adap->props->pid_filter_count);
e46c5b66 795 adap->pid_filtering = 1;
f093c388 796 adap->max_feed_count = adap->props->pid_filter_count;
e46c5b66 797 } else {
6d7cfec4
AP		 798 dev_info(&d->udev->dev,
799 "%s: will pass the complete MPEG2 transport stream to the software demuxer\n",
800 KBUILD_MODNAME);
e46c5b66
AP		 801 adap->pid_filtering = 0;
802 adap->max_feed_count = 255;
803 }
c79b339f 804
e46c5b66 805 if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
f093c388 806 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
6d7cfec4
AP		 807 dev_info(&d->udev->dev,
808 "%s: PID filter enabled by module option\n",
809 KBUILD_MODNAME);
e46c5b66 810 adap->pid_filtering = 1;
f093c388 811 adap->max_feed_count = adap->props->pid_filter_count;
c79b339f 812 }
c79b339f 813
59784343 814 ret = dvb_usbv2_adapter_stream_init(adap);
4e60d951 815 if (ret)
d496eb8a 816 goto err;
4e60d951 817
59784343 818 ret = dvb_usbv2_adapter_dvb_init(adap);
4e60d951 819 if (ret)
d496eb8a 820 goto err;
4e60d951 821
59784343 822 ret = dvb_usbv2_adapter_frontend_init(adap);
4e60d951 823 if (ret)
d496eb8a 824 goto err;
c79b339f
AP		 825
826 /* use exclusive FE lock if there is multiple shared FEs */
20bb9cc4 827 if (adap->fe[1])
c79b339f 828 adap->dvb_adap.mfe_shared = 1;
c79b339f
AP		 829 }
830
c79b339f 831 return 0;
5b853004 832err:
d10d1b9a 833 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
5b853004 834 return ret;
c79b339f
AP		 835}
836
59784343 837static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
c79b339f 838{
d496eb8a 839 int i;
d10d1b9a 840 dev_dbg(&d->udev->dev, "%s:\n", __func__);
6e3a5daa
AP		 841
842 for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
b62fd172 843 if (d->adapter[i].props) {
b62fd172
AP		 844 dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
845 dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
7a0af6ed 846 dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
33c68533 847 dvb_usbv2_media_device_unregister(&d->adapter[i]);
b62fd172 848 }
c79b339f 849 }
d496eb8a 850
c79b339f
AP		 851 return 0;
852}
853
c79b339f 854/* general initialization functions */
59784343 855static int dvb_usbv2_exit(struct dvb_usb_device *d)
c79b339f 856{
d10d1b9a 857 dev_dbg(&d->udev->dev, "%s:\n", __func__);
d70521a3 858
59784343
AP		 859 dvb_usbv2_remote_exit(d);
860 dvb_usbv2_adapter_exit(d);
861 dvb_usbv2_i2c_exit(d);
c79b339f
AP		 862 kfree(d->priv);
863 kfree(d);
d496eb8a 864
c79b339f
AP		 865 return 0;
866}
867
59784343 868static int dvb_usbv2_init(struct dvb_usb_device *d)
c79b339f 869{
831511bd 870 int ret;
d10d1b9a 871 dev_dbg(&d->udev->dev, "%s:\n", __func__);
c79b339f 872
59784343 873 dvb_usbv2_device_power_ctrl(d, 1);
c79b339f 874
f093c388
AP		 875 if (d->props->read_config) {
876 ret = d->props->read_config(d);
43402bbd
AP		 877 if (ret < 0)
878 goto err;
879 }
880
59784343 881 ret = dvb_usbv2_i2c_init(d);
d496eb8a
AP		 882 if (ret < 0)
883 goto err;
4e60d951 884
d496eb8a
AP		 885 ret = dvb_usbv2_adapter_init(d);
886 if (ret < 0)
887 goto err;
c79b339f 888
f093c388
AP		 889 if (d->props->init) {
890 ret = d->props->init(d);
d496eb8a
AP		 891 if (ret < 0)
892 goto err;
893 }
dc786937 894
59784343 895 ret = dvb_usbv2_remote_init(d);
d496eb8a
AP		 896 if (ret < 0)
897 goto err;
c79b339f 898
59784343 899 dvb_usbv2_device_power_ctrl(d, 0);
c79b339f
AP		 900
901 return 0;
43402bbd 902err:
d496eb8a 903 dvb_usbv2_device_power_ctrl(d, 0);
d10d1b9a 904 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
43402bbd 905 return ret;
c79b339f
AP		 906}
907
dd0f5e0b
AP		 908int dvb_usbv2_probe(struct usb_interface *intf,
909 const struct usb_device_id *id)
4f208d4e
AP		 910{
911 int ret;
dd0f5e0b
AP		 912 struct dvb_usb_device *d;
913 struct usb_device *udev = interface_to_usbdev(intf);
914 struct dvb_usb_driver_info *driver_info =
915 (struct dvb_usb_driver_info *) id->driver_info;
916
917 dev_dbg(&udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
918 intf->cur_altsetting->desc.bInterfaceNumber);
919
920 if (!id->driver_info) {
921 dev_err(&udev->dev, "%s: driver_info failed\n", KBUILD_MODNAME);
922 ret = -ENODEV;
923 goto err;
924 }
925
926 d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
927 if (!d) {
928 dev_err(&udev->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
929 ret = -ENOMEM;
930 goto err;
931 }
496e8278 932
ac5361a8 933 d->intf = intf;
dd0f5e0b
AP		 934 d->name = driver_info->name;
935 d->rc_map = driver_info->rc_map;
936 d->udev = udev;
937 d->props = driver_info->props;
938
939 if (intf->cur_altsetting->desc.bInterfaceNumber !=
940 d->props->bInterfaceNumber) {
941 ret = -ENODEV;
942 goto err_free_all;
943 }
944
945 mutex_init(&d->usb_mutex);
946 mutex_init(&d->i2c_mutex);
c79b339f 947
f093c388
AP		 948 if (d->props->size_of_priv) {
949 d->priv = kzalloc(d->props->size_of_priv, GFP_KERNEL);
4f208d4e 950 if (!d->priv) {
d10d1b9a
AP		 951 dev_err(&d->udev->dev, "%s: kzalloc() failed\n",
952 KBUILD_MODNAME);
496e8278 953 ret = -ENOMEM;
dd0f5e0b 954 goto err_free_all;
496e8278
AP		 955 }
956 }
c79b339f 957
f093c388 958 if (d->props->identify_state) {
a0921af7
AP		 959 const char *name = NULL;
960 ret = d->props->identify_state(d, &name);
496e8278
AP		 961 if (ret == 0) {
962 ;
963 } else if (ret == COLD) {
6d7cfec4
AP		 964 dev_info(&d->udev->dev,
965 "%s: found a '%s' in cold state\n",
966 KBUILD_MODNAME, d->name);
a0921af7
AP		 967
968 if (!name)
969 name = d->props->firmware;
970
971 ret = dvb_usbv2_download_firmware(d, name);
972 if (ret == 0) {
973 /* device is warm, continue initialization */
974 ;
975 } else if (ret == RECONNECTS_USB) {
976 /*
977 * USB core will call disconnect() and then
978 * probe() as device reconnects itself from the
979 * USB bus. disconnect() will release all driver
980 * resources and probe() is called for 'new'
981 * device. As 'new' device is warm we should
982 * never go here again.
983 */
dd0f5e0b 984 goto exit;
a0921af7 985 } else {
dd0f5e0b 986 goto err_free_all;
a0921af7 987 }
496e8278 988 } else {
dd0f5e0b 989 goto err_free_all;
496e8278 990 }
c79b339f
AP		 991 }
992
d10d1b9a
AP		 993 dev_info(&d->udev->dev, "%s: found a '%s' in warm state\n",
994 KBUILD_MODNAME, d->name);
c79b339f 995
59784343 996 ret = dvb_usbv2_init(d);
4f208d4e 997 if (ret < 0)
dd0f5e0b 998 goto err_free_all;
c79b339f 999
6d7cfec4
AP		 1000 dev_info(&d->udev->dev,
1001 "%s: '%s' successfully initialized and connected\n",
1002 KBUILD_MODNAME, d->name);
dd0f5e0b 1003exit:
4f208d4e 1004 usb_set_intfdata(intf, d);
21f5a32e
AP		 1005
1006 return 0;
dd0f5e0b
AP		 1007err_free_all:
1008 dvb_usbv2_exit(d);
21f5a32e 1009err:
d10d1b9a 1010 dev_dbg(&udev->dev, "%s: failed=%d\n", __func__, ret);
21f5a32e
AP		 1011 return ret;
1012}
6b8c8c40 1013EXPORT_SYMBOL(dvb_usbv2_probe);
21f5a32e 1014
6b8c8c40 1015void dvb_usbv2_disconnect(struct usb_interface *intf)
c79b339f
AP		 1016{
1017 struct dvb_usb_device *d = usb_get_intfdata(intf);
831511bd 1018 const char *name = d->name;
d10d1b9a 1019 struct device dev = d->udev->dev;
6f6c77d8 1020
dd0f5e0b
AP		 1021 dev_dbg(&d->udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
1022 intf->cur_altsetting->desc.bInterfaceNumber);
c79b339f 1023
831511bd
AP		 1024 if (d->props->exit)
1025 d->props->exit(d);
5b6a63cc 1026
823eebac 1027 dvb_usbv2_exit(d);
4f208d4e 1028
d10d1b9a 1029 dev_info(&dev, "%s: '%s' successfully deinitialized and disconnected\n",
4f208d4e 1030 KBUILD_MODNAME, name);
c79b339f 1031}
6b8c8c40 1032EXPORT_SYMBOL(dvb_usbv2_disconnect);
c79b339f 1033
ef81e9eb
AP		 1034int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
1035{
1036 struct dvb_usb_device *d = usb_get_intfdata(intf);
15d08836 1037 int ret = 0, i, active_fe;
0898b954 1038 struct dvb_frontend *fe;
d10d1b9a 1039 dev_dbg(&d->udev->dev, "%s:\n", __func__);
ef81e9eb
AP		 1040
1041 /* stop remote controller poll */
ac1c86c8 1042 if (d->rc_polling_active)
ef81e9eb
AP		 1043 cancel_delayed_work_sync(&d->rc_query_work);
1044
5cd98320 1045 for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
0898b954
AP		 1046 active_fe = d->adapter[i].active_fe;
1047 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1048 fe = d->adapter[i].fe[active_fe];
06bae122 1049 d->adapter[i].suspend_resume_active = true;
0898b954
AP		 1050
1051 if (d->props->streaming_ctrl)
1052 d->props->streaming_ctrl(fe, 0);
1053
1054 /* stop usb streaming */
ef81e9eb 1055 usb_urb_killv2(&d->adapter[i].stream);
0898b954 1056
15d08836 1057 ret = dvb_frontend_suspend(fe);
0898b954 1058 }
ef81e9eb
AP		 1059 }
1060
15d08836 1061 return ret;
ef81e9eb
AP		 1062}
1063EXPORT_SYMBOL(dvb_usbv2_suspend);
1064
15d08836 1065static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
ef81e9eb 1066{
15d08836 1067 int ret = 0, i, active_fe;
0898b954 1068 struct dvb_frontend *fe;
d10d1b9a 1069 dev_dbg(&d->udev->dev, "%s:\n", __func__);
ef81e9eb 1070
5cd98320 1071 for (i = 0; i < MAX_NO_OF_ADAPTER_PER_DEVICE; i++) {
0898b954
AP		 1072 active_fe = d->adapter[i].active_fe;
1073 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1074 fe = d->adapter[i].fe[active_fe];
1075
15d08836 1076 ret = dvb_frontend_resume(fe);
0898b954
AP		 1077
1078 /* resume usb streaming */
ef81e9eb 1079 usb_urb_submitv2(&d->adapter[i].stream, NULL);
0898b954
AP		 1080
1081 if (d->props->streaming_ctrl)
1082 d->props->streaming_ctrl(fe, 1);
06bae122
AP		 1083
1084 d->adapter[i].suspend_resume_active = false;
0898b954 1085 }
ef81e9eb
AP		 1086 }
1087
1088 /* start remote controller poll */
ac1c86c8 1089 if (d->rc_polling_active)
ef81e9eb
AP		 1090 schedule_delayed_work(&d->rc_query_work,
1091 msecs_to_jiffies(d->rc.interval));
1092
15d08836
AP		 1093 return ret;
1094}
1095
1096int dvb_usbv2_resume(struct usb_interface *intf)
1097{
1098 struct dvb_usb_device *d = usb_get_intfdata(intf);
1099 dev_dbg(&d->udev->dev, "%s:\n", __func__);
1100
1101 return dvb_usbv2_resume_common(d);
ef81e9eb
AP		 1102}
1103EXPORT_SYMBOL(dvb_usbv2_resume);
1104
15d08836
AP		 1105int dvb_usbv2_reset_resume(struct usb_interface *intf)
1106{
1107 struct dvb_usb_device *d = usb_get_intfdata(intf);
1108 int ret;
1109 dev_dbg(&d->udev->dev, "%s:\n", __func__);
1110
1111 dvb_usbv2_device_power_ctrl(d, 1);
1112
1113 if (d->props->init)
1114 d->props->init(d);
1115
1116 ret = dvb_usbv2_resume_common(d);
1117
1118 dvb_usbv2_device_power_ctrl(d, 0);
1119
1120 return ret;
1121}
1122EXPORT_SYMBOL(dvb_usbv2_reset_resume);
1123
12042b05 1124MODULE_VERSION("2.0");
99e44da7 1125MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
12042b05
AP		 1126MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1127MODULE_DESCRIPTION("DVB USB common");
c79b339f 1128MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.27129 seconds and 5 git commands to generate.