source: src/linux/universal/linux-3.18/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

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