Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DVB USB framework
0004  *
0005  * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.de>
0006  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
0007  */
0008 
0009 #include "dvb_usb_common.h"
0010 #include <media/media-device.h>
0011 
0012 static int dvb_usbv2_disable_rc_polling;
0013 module_param_named(disable_rc_polling, dvb_usbv2_disable_rc_polling, int, 0644);
0014 MODULE_PARM_DESC(disable_rc_polling,
0015         "disable remote control polling (default: 0)");
0016 static int dvb_usb_force_pid_filter_usage;
0017 module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage,
0018         int, 0444);
0019 MODULE_PARM_DESC(force_pid_filter_usage,
0020         "force all DVB USB devices to use a PID filter, if any (default: 0)");
0021 
0022 static int dvb_usbv2_download_firmware(struct dvb_usb_device *d,
0023         const char *name)
0024 {
0025     int ret;
0026     const struct firmware *fw;
0027     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0028 
0029     if (!d->props->download_firmware) {
0030         ret = -EINVAL;
0031         goto err;
0032     }
0033 
0034     ret = request_firmware(&fw, name, &d->udev->dev);
0035     if (ret < 0) {
0036         dev_err(&d->udev->dev,
0037                 "%s: Did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\n",
0038                 KBUILD_MODNAME, name, ret);
0039         goto err;
0040     }
0041 
0042     dev_info(&d->udev->dev, "%s: downloading firmware from file '%s'\n",
0043             KBUILD_MODNAME, name);
0044 
0045     ret = d->props->download_firmware(d, fw);
0046     release_firmware(fw);
0047     if (ret < 0)
0048         goto err;
0049 
0050     return ret;
0051 err:
0052     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0053     return ret;
0054 }
0055 
0056 static int dvb_usbv2_i2c_init(struct dvb_usb_device *d)
0057 {
0058     int ret;
0059     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0060 
0061     if (!d->props->i2c_algo)
0062         return 0;
0063 
0064     strscpy(d->i2c_adap.name, d->name, sizeof(d->i2c_adap.name));
0065     d->i2c_adap.algo = d->props->i2c_algo;
0066     d->i2c_adap.dev.parent = &d->udev->dev;
0067     i2c_set_adapdata(&d->i2c_adap, d);
0068 
0069     ret = i2c_add_adapter(&d->i2c_adap);
0070     if (ret < 0) {
0071         d->i2c_adap.algo = NULL;
0072         goto err;
0073     }
0074 
0075     return 0;
0076 err:
0077     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0078     return ret;
0079 }
0080 
0081 static int dvb_usbv2_i2c_exit(struct dvb_usb_device *d)
0082 {
0083     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0084 
0085     if (d->i2c_adap.algo)
0086         i2c_del_adapter(&d->i2c_adap);
0087 
0088     return 0;
0089 }
0090 
0091 #if IS_ENABLED(CONFIG_RC_CORE)
0092 static void dvb_usb_read_remote_control(struct work_struct *work)
0093 {
0094     struct dvb_usb_device *d = container_of(work,
0095             struct dvb_usb_device, rc_query_work.work);
0096     int ret;
0097 
0098     /*
0099      * When the parameter has been set to 1 via sysfs while the
0100      * driver was running, or when bulk mode is enabled after IR init.
0101      */
0102     if (dvb_usbv2_disable_rc_polling || d->rc.bulk_mode) {
0103         d->rc_polling_active = false;
0104         return;
0105     }
0106 
0107     ret = d->rc.query(d);
0108     if (ret < 0) {
0109         dev_err(&d->udev->dev, "%s: rc.query() failed=%d\n",
0110                 KBUILD_MODNAME, ret);
0111         d->rc_polling_active = false;
0112         return; /* stop polling */
0113     }
0114 
0115     schedule_delayed_work(&d->rc_query_work,
0116             msecs_to_jiffies(d->rc.interval));
0117 }
0118 
0119 static int dvb_usbv2_remote_init(struct dvb_usb_device *d)
0120 {
0121     int ret;
0122     struct rc_dev *dev;
0123     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0124 
0125     if (dvb_usbv2_disable_rc_polling || !d->props->get_rc_config)
0126         return 0;
0127 
0128     d->rc.map_name = d->rc_map;
0129     ret = d->props->get_rc_config(d, &d->rc);
0130     if (ret < 0)
0131         goto err;
0132 
0133     /* disable rc when there is no keymap defined */
0134     if (!d->rc.map_name)
0135         return 0;
0136 
0137     dev = rc_allocate_device(d->rc.driver_type);
0138     if (!dev) {
0139         ret = -ENOMEM;
0140         goto err;
0141     }
0142 
0143     dev->dev.parent = &d->udev->dev;
0144     dev->device_name = d->name;
0145     usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
0146     strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
0147     dev->input_phys = d->rc_phys;
0148     usb_to_input_id(d->udev, &dev->input_id);
0149     dev->driver_name = d->props->driver_name;
0150     dev->map_name = d->rc.map_name;
0151     dev->allowed_protocols = d->rc.allowed_protos;
0152     dev->change_protocol = d->rc.change_protocol;
0153     dev->timeout = d->rc.timeout;
0154     dev->priv = d;
0155 
0156     ret = rc_register_device(dev);
0157     if (ret < 0) {
0158         rc_free_device(dev);
0159         goto err;
0160     }
0161 
0162     d->rc_dev = dev;
0163 
0164     /* start polling if needed */
0165     if (d->rc.query && !d->rc.bulk_mode) {
0166         /* initialize a work queue for handling polling */
0167         INIT_DELAYED_WORK(&d->rc_query_work,
0168                 dvb_usb_read_remote_control);
0169         dev_info(&d->udev->dev,
0170                 "%s: schedule remote query interval to %d msecs\n",
0171                 KBUILD_MODNAME, d->rc.interval);
0172         schedule_delayed_work(&d->rc_query_work,
0173                 msecs_to_jiffies(d->rc.interval));
0174         d->rc_polling_active = true;
0175     }
0176 
0177     return 0;
0178 err:
0179     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0180     return ret;
0181 }
0182 
0183 static int dvb_usbv2_remote_exit(struct dvb_usb_device *d)
0184 {
0185     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0186 
0187     if (d->rc_dev) {
0188         cancel_delayed_work_sync(&d->rc_query_work);
0189         rc_unregister_device(d->rc_dev);
0190         d->rc_dev = NULL;
0191     }
0192 
0193     return 0;
0194 }
0195 #else
0196     #define dvb_usbv2_remote_init(args...) 0
0197     #define dvb_usbv2_remote_exit(args...)
0198 #endif
0199 
0200 static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buf,
0201         size_t len)
0202 {
0203     struct dvb_usb_adapter *adap = stream->user_priv;
0204     dvb_dmx_swfilter(&adap->demux, buf, len);
0205 }
0206 
0207 static void dvb_usb_data_complete_204(struct usb_data_stream *stream, u8 *buf,
0208         size_t len)
0209 {
0210     struct dvb_usb_adapter *adap = stream->user_priv;
0211     dvb_dmx_swfilter_204(&adap->demux, buf, len);
0212 }
0213 
0214 static void dvb_usb_data_complete_raw(struct usb_data_stream *stream, u8 *buf,
0215         size_t len)
0216 {
0217     struct dvb_usb_adapter *adap = stream->user_priv;
0218     dvb_dmx_swfilter_raw(&adap->demux, buf, len);
0219 }
0220 
0221 static int dvb_usbv2_adapter_stream_init(struct dvb_usb_adapter *adap)
0222 {
0223     dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
0224             adap->id);
0225 
0226     adap->stream.udev = adap_to_d(adap)->udev;
0227     adap->stream.user_priv = adap;
0228     adap->stream.complete = dvb_usb_data_complete;
0229 
0230     return usb_urb_initv2(&adap->stream, &adap->props->stream);
0231 }
0232 
0233 static int dvb_usbv2_adapter_stream_exit(struct dvb_usb_adapter *adap)
0234 {
0235     dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
0236             adap->id);
0237 
0238     return usb_urb_exitv2(&adap->stream);
0239 }
0240 
0241 static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
0242 {
0243     struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
0244     struct dvb_usb_device *d = adap_to_d(adap);
0245     int ret = 0;
0246     struct usb_data_stream_properties stream_props;
0247     dev_dbg(&d->udev->dev,
0248             "%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
0249             __func__, adap->id, adap->active_fe, dvbdmxfeed->type,
0250             adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
0251             dvbdmxfeed->pid, dvbdmxfeed->index);
0252 
0253     /* wait init is done */
0254     wait_on_bit(&adap->state_bits, ADAP_INIT, TASK_UNINTERRUPTIBLE);
0255 
0256     if (adap->active_fe == -1)
0257         return -EINVAL;
0258 
0259     /* skip feed setup if we are already feeding */
0260     if (adap->feed_count++ > 0)
0261         goto skip_feed_start;
0262 
0263     /* set 'streaming' status bit */
0264     set_bit(ADAP_STREAMING, &adap->state_bits);
0265 
0266     /* resolve input and output streaming parameters */
0267     if (d->props->get_stream_config) {
0268         memcpy(&stream_props, &adap->props->stream,
0269                 sizeof(struct usb_data_stream_properties));
0270         ret = d->props->get_stream_config(adap->fe[adap->active_fe],
0271                 &adap->ts_type, &stream_props);
0272         if (ret)
0273             dev_err(&d->udev->dev,
0274                     "%s: get_stream_config() failed=%d\n",
0275                     KBUILD_MODNAME, ret);
0276     } else {
0277         stream_props = adap->props->stream;
0278     }
0279 
0280     switch (adap->ts_type) {
0281     case DVB_USB_FE_TS_TYPE_204:
0282         adap->stream.complete = dvb_usb_data_complete_204;
0283         break;
0284     case DVB_USB_FE_TS_TYPE_RAW:
0285         adap->stream.complete = dvb_usb_data_complete_raw;
0286         break;
0287     case DVB_USB_FE_TS_TYPE_188:
0288     default:
0289         adap->stream.complete = dvb_usb_data_complete;
0290         break;
0291     }
0292 
0293     /* submit USB streaming packets */
0294     usb_urb_submitv2(&adap->stream, &stream_props);
0295 
0296     /* enable HW PID filter */
0297     if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
0298         ret = adap->props->pid_filter_ctrl(adap, 1);
0299         if (ret)
0300             dev_err(&d->udev->dev,
0301                     "%s: pid_filter_ctrl() failed=%d\n",
0302                     KBUILD_MODNAME, ret);
0303     }
0304 
0305     /* ask device to start streaming */
0306     if (d->props->streaming_ctrl) {
0307         ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 1);
0308         if (ret)
0309             dev_err(&d->udev->dev,
0310                     "%s: streaming_ctrl() failed=%d\n",
0311                     KBUILD_MODNAME, ret);
0312     }
0313 skip_feed_start:
0314 
0315     /* add PID to device HW PID filter */
0316     if (adap->pid_filtering && adap->props->pid_filter) {
0317         ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
0318                 dvbdmxfeed->pid, 1);
0319         if (ret)
0320             dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
0321                     KBUILD_MODNAME, ret);
0322     }
0323 
0324     if (ret)
0325         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0326     return ret;
0327 }
0328 
0329 static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
0330 {
0331     struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
0332     struct dvb_usb_device *d = adap_to_d(adap);
0333     int ret = 0;
0334     dev_dbg(&d->udev->dev,
0335             "%s: adap=%d active_fe=%d feed_type=%d setting pid [%s]: %04x (%04d) at index %d\n",
0336             __func__, adap->id, adap->active_fe, dvbdmxfeed->type,
0337             adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
0338             dvbdmxfeed->pid, dvbdmxfeed->index);
0339 
0340     if (adap->active_fe == -1)
0341         return -EINVAL;
0342 
0343     /* remove PID from device HW PID filter */
0344     if (adap->pid_filtering && adap->props->pid_filter) {
0345         ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
0346                 dvbdmxfeed->pid, 0);
0347         if (ret)
0348             dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
0349                     KBUILD_MODNAME, ret);
0350     }
0351 
0352     /* we cannot stop streaming until last PID is removed */
0353     if (--adap->feed_count > 0)
0354         goto skip_feed_stop;
0355 
0356     /* ask device to stop streaming */
0357     if (d->props->streaming_ctrl) {
0358         ret = d->props->streaming_ctrl(adap->fe[adap->active_fe], 0);
0359         if (ret)
0360             dev_err(&d->udev->dev,
0361                     "%s: streaming_ctrl() failed=%d\n",
0362                     KBUILD_MODNAME, ret);
0363     }
0364 
0365     /* disable HW PID filter */
0366     if (adap->pid_filtering && adap->props->pid_filter_ctrl) {
0367         ret = adap->props->pid_filter_ctrl(adap, 0);
0368         if (ret)
0369             dev_err(&d->udev->dev,
0370                     "%s: pid_filter_ctrl() failed=%d\n",
0371                     KBUILD_MODNAME, ret);
0372     }
0373 
0374     /* kill USB streaming packets */
0375     usb_urb_killv2(&adap->stream);
0376 
0377     /* clear 'streaming' status bit */
0378     clear_bit(ADAP_STREAMING, &adap->state_bits);
0379     smp_mb__after_atomic();
0380     wake_up_bit(&adap->state_bits, ADAP_STREAMING);
0381 skip_feed_stop:
0382 
0383     if (ret)
0384         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0385     return ret;
0386 }
0387 
0388 static int dvb_usbv2_media_device_init(struct dvb_usb_adapter *adap)
0389 {
0390 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0391     struct media_device *mdev;
0392     struct dvb_usb_device *d = adap_to_d(adap);
0393     struct usb_device *udev = d->udev;
0394 
0395     mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
0396     if (!mdev)
0397         return -ENOMEM;
0398 
0399     media_device_usb_init(mdev, udev, d->name);
0400 
0401     dvb_register_media_controller(&adap->dvb_adap, mdev);
0402 
0403     dev_info(&d->udev->dev, "media controller created\n");
0404 #endif
0405     return 0;
0406 }
0407 
0408 static int dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
0409 {
0410 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0411     return media_device_register(adap->dvb_adap.mdev);
0412 #else
0413     return 0;
0414 #endif
0415 }
0416 
0417 static void dvb_usbv2_media_device_unregister(struct dvb_usb_adapter *adap)
0418 {
0419 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0420 
0421     if (!adap->dvb_adap.mdev)
0422         return;
0423 
0424     media_device_unregister(adap->dvb_adap.mdev);
0425     media_device_cleanup(adap->dvb_adap.mdev);
0426     kfree(adap->dvb_adap.mdev);
0427     adap->dvb_adap.mdev = NULL;
0428 
0429 #endif
0430 }
0431 
0432 static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
0433 {
0434     int ret;
0435     struct dvb_usb_device *d = adap_to_d(adap);
0436 
0437     dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
0438 
0439     ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner,
0440             &d->udev->dev, d->props->adapter_nr);
0441     if (ret < 0) {
0442         dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n",
0443                 __func__, ret);
0444         goto err_dvb_register_adapter;
0445     }
0446 
0447     adap->dvb_adap.priv = adap;
0448 
0449     ret = dvb_usbv2_media_device_init(adap);
0450     if (ret < 0) {
0451         dev_dbg(&d->udev->dev, "%s: dvb_usbv2_media_device_init() failed=%d\n",
0452                 __func__, ret);
0453         goto err_dvb_register_mc;
0454     }
0455 
0456     if (d->props->read_mac_address) {
0457         ret = d->props->read_mac_address(adap,
0458                 adap->dvb_adap.proposed_mac);
0459         if (ret < 0)
0460             goto err_dvb_dmx_init;
0461 
0462         dev_info(&d->udev->dev, "%s: MAC address: %pM\n",
0463                 KBUILD_MODNAME, adap->dvb_adap.proposed_mac);
0464     }
0465 
0466     adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
0467     adap->demux.priv             = adap;
0468     adap->demux.filternum        = 0;
0469     adap->demux.filternum        = adap->max_feed_count;
0470     adap->demux.feednum          = adap->demux.filternum;
0471     adap->demux.start_feed       = dvb_usb_start_feed;
0472     adap->demux.stop_feed        = dvb_usb_stop_feed;
0473     adap->demux.write_to_decoder = NULL;
0474     ret = dvb_dmx_init(&adap->demux);
0475     if (ret < 0) {
0476         dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n",
0477                 KBUILD_MODNAME, ret);
0478         goto err_dvb_dmx_init;
0479     }
0480 
0481     adap->dmxdev.filternum       = adap->demux.filternum;
0482     adap->dmxdev.demux           = &adap->demux.dmx;
0483     adap->dmxdev.capabilities    = 0;
0484     ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
0485     if (ret < 0) {
0486         dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n",
0487                 KBUILD_MODNAME, ret);
0488         goto err_dvb_dmxdev_init;
0489     }
0490 
0491     ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
0492     if (ret < 0) {
0493         dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n",
0494                 KBUILD_MODNAME, ret);
0495         goto err_dvb_net_init;
0496     }
0497 
0498     return 0;
0499 err_dvb_net_init:
0500     dvb_dmxdev_release(&adap->dmxdev);
0501 err_dvb_dmxdev_init:
0502     dvb_dmx_release(&adap->demux);
0503 err_dvb_dmx_init:
0504     dvb_usbv2_media_device_unregister(adap);
0505 err_dvb_register_mc:
0506     dvb_unregister_adapter(&adap->dvb_adap);
0507 err_dvb_register_adapter:
0508     adap->dvb_adap.priv = NULL;
0509     return ret;
0510 }
0511 
0512 static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
0513 {
0514     dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
0515             adap->id);
0516 
0517     if (adap->dvb_adap.priv) {
0518         dvb_net_release(&adap->dvb_net);
0519         adap->demux.dmx.close(&adap->demux.dmx);
0520         dvb_dmxdev_release(&adap->dmxdev);
0521         dvb_dmx_release(&adap->demux);
0522         dvb_unregister_adapter(&adap->dvb_adap);
0523     }
0524 
0525     return 0;
0526 }
0527 
0528 static int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
0529 {
0530     int ret;
0531 
0532     if (onoff)
0533         d->powered++;
0534     else
0535         d->powered--;
0536 
0537     if (d->powered == 0 || (onoff && d->powered == 1)) {
0538         /* when switching from 1 to 0 or from 0 to 1 */
0539         dev_dbg(&d->udev->dev, "%s: power=%d\n", __func__, onoff);
0540         if (d->props->power_ctrl) {
0541             ret = d->props->power_ctrl(d, onoff);
0542             if (ret < 0)
0543                 goto err;
0544         }
0545     }
0546 
0547     return 0;
0548 err:
0549     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0550     return ret;
0551 }
0552 
0553 static int dvb_usb_fe_init(struct dvb_frontend *fe)
0554 {
0555     int ret;
0556     struct dvb_usb_adapter *adap = fe->dvb->priv;
0557     struct dvb_usb_device *d = adap_to_d(adap);
0558     dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
0559             fe->id);
0560 
0561     if (!adap->suspend_resume_active) {
0562         adap->active_fe = fe->id;
0563         set_bit(ADAP_INIT, &adap->state_bits);
0564     }
0565 
0566     ret = dvb_usbv2_device_power_ctrl(d, 1);
0567     if (ret < 0)
0568         goto err;
0569 
0570     if (d->props->frontend_ctrl) {
0571         ret = d->props->frontend_ctrl(fe, 1);
0572         if (ret < 0)
0573             goto err;
0574     }
0575 
0576     if (adap->fe_init[fe->id]) {
0577         ret = adap->fe_init[fe->id](fe);
0578         if (ret < 0)
0579             goto err;
0580     }
0581 err:
0582     if (!adap->suspend_resume_active) {
0583         clear_bit(ADAP_INIT, &adap->state_bits);
0584         smp_mb__after_atomic();
0585         wake_up_bit(&adap->state_bits, ADAP_INIT);
0586     }
0587 
0588     dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
0589     return ret;
0590 }
0591 
0592 static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
0593 {
0594     int ret;
0595     struct dvb_usb_adapter *adap = fe->dvb->priv;
0596     struct dvb_usb_device *d = adap_to_d(adap);
0597     dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
0598             fe->id);
0599 
0600     if (!adap->suspend_resume_active) {
0601         set_bit(ADAP_SLEEP, &adap->state_bits);
0602         wait_on_bit(&adap->state_bits, ADAP_STREAMING,
0603                 TASK_UNINTERRUPTIBLE);
0604     }
0605 
0606     if (adap->fe_sleep[fe->id]) {
0607         ret = adap->fe_sleep[fe->id](fe);
0608         if (ret < 0)
0609             goto err;
0610     }
0611 
0612     if (d->props->frontend_ctrl) {
0613         ret = d->props->frontend_ctrl(fe, 0);
0614         if (ret < 0)
0615             goto err;
0616     }
0617 
0618     ret = dvb_usbv2_device_power_ctrl(d, 0);
0619 
0620 err:
0621     if (!adap->suspend_resume_active) {
0622         adap->active_fe = -1;
0623         clear_bit(ADAP_SLEEP, &adap->state_bits);
0624         smp_mb__after_atomic();
0625         wake_up_bit(&adap->state_bits, ADAP_SLEEP);
0626     }
0627 
0628     dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
0629     return ret;
0630 }
0631 
0632 static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
0633 {
0634     int ret, i, count_registered = 0;
0635     struct dvb_usb_device *d = adap_to_d(adap);
0636     dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
0637 
0638     memset(adap->fe, 0, sizeof(adap->fe));
0639     adap->active_fe = -1;
0640 
0641     if (d->props->frontend_attach) {
0642         ret = d->props->frontend_attach(adap);
0643         if (ret < 0) {
0644             dev_dbg(&d->udev->dev,
0645                     "%s: frontend_attach() failed=%d\n",
0646                     __func__, ret);
0647             goto err_dvb_frontend_detach;
0648         }
0649     } else {
0650         dev_dbg(&d->udev->dev, "%s: frontend_attach() do not exists\n",
0651                 __func__);
0652         ret = 0;
0653         goto err;
0654     }
0655 
0656     for (i = 0; i < MAX_NO_OF_FE_PER_ADAP && adap->fe[i]; i++) {
0657         adap->fe[i]->id = i;
0658         /* re-assign sleep and wakeup functions */
0659         adap->fe_init[i] = adap->fe[i]->ops.init;
0660         adap->fe[i]->ops.init = dvb_usb_fe_init;
0661         adap->fe_sleep[i] = adap->fe[i]->ops.sleep;
0662         adap->fe[i]->ops.sleep = dvb_usb_fe_sleep;
0663 
0664         ret = dvb_register_frontend(&adap->dvb_adap, adap->fe[i]);
0665         if (ret < 0) {
0666             dev_err(&d->udev->dev,
0667                     "%s: frontend%d registration failed\n",
0668                     KBUILD_MODNAME, i);
0669             goto err_dvb_unregister_frontend;
0670         }
0671 
0672         count_registered++;
0673     }
0674 
0675     if (d->props->tuner_attach) {
0676         ret = d->props->tuner_attach(adap);
0677         if (ret < 0) {
0678             dev_dbg(&d->udev->dev, "%s: tuner_attach() failed=%d\n",
0679                     __func__, ret);
0680             goto err_dvb_unregister_frontend;
0681         }
0682     }
0683 
0684     ret = dvb_create_media_graph(&adap->dvb_adap, true);
0685     if (ret < 0)
0686         goto err_dvb_unregister_frontend;
0687 
0688     ret = dvb_usbv2_media_device_register(adap);
0689 
0690     return ret;
0691 
0692 err_dvb_unregister_frontend:
0693     for (i = count_registered - 1; i >= 0; i--)
0694         dvb_unregister_frontend(adap->fe[i]);
0695 
0696 err_dvb_frontend_detach:
0697     for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
0698         if (adap->fe[i]) {
0699             dvb_frontend_detach(adap->fe[i]);
0700             adap->fe[i] = NULL;
0701         }
0702     }
0703 
0704 err:
0705     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0706     return ret;
0707 }
0708 
0709 static int dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter *adap)
0710 {
0711     int ret, i;
0712     struct dvb_usb_device *d = adap_to_d(adap);
0713 
0714     dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
0715 
0716     for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
0717         if (adap->fe[i]) {
0718             dvb_unregister_frontend(adap->fe[i]);
0719             dvb_frontend_detach(adap->fe[i]);
0720         }
0721     }
0722 
0723     if (d->props->tuner_detach) {
0724         ret = d->props->tuner_detach(adap);
0725         if (ret < 0) {
0726             dev_dbg(&d->udev->dev, "%s: tuner_detach() failed=%d\n",
0727                     __func__, ret);
0728         }
0729     }
0730 
0731     if (d->props->frontend_detach) {
0732         ret = d->props->frontend_detach(adap);
0733         if (ret < 0) {
0734             dev_dbg(&d->udev->dev,
0735                     "%s: frontend_detach() failed=%d\n",
0736                     __func__, ret);
0737         }
0738     }
0739 
0740     return 0;
0741 }
0742 
0743 static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
0744 {
0745     struct dvb_usb_adapter *adap;
0746     int ret, i, adapter_count;
0747 
0748     /* resolve adapter count */
0749     adapter_count = d->props->num_adapters;
0750     if (d->props->get_adapter_count) {
0751         ret = d->props->get_adapter_count(d);
0752         if (ret < 0)
0753             goto err;
0754 
0755         adapter_count = ret;
0756     }
0757 
0758     for (i = 0; i < adapter_count; i++) {
0759         adap = &d->adapter[i];
0760         adap->id = i;
0761         adap->props = &d->props->adapter[i];
0762 
0763         /* speed - when running at FULL speed we need a HW PID filter */
0764         if (d->udev->speed == USB_SPEED_FULL &&
0765                 !(adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
0766             dev_err(&d->udev->dev,
0767                     "%s: this USB2.0 device cannot be run on a USB1.1 port (it lacks a hardware PID filter)\n",
0768                     KBUILD_MODNAME);
0769             ret = -ENODEV;
0770             goto err;
0771         } else if ((d->udev->speed == USB_SPEED_FULL &&
0772                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
0773                 (adap->props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
0774             dev_info(&d->udev->dev,
0775                     "%s: will use the device's hardware PID filter (table count: %d)\n",
0776                     KBUILD_MODNAME,
0777                     adap->props->pid_filter_count);
0778             adap->pid_filtering  = 1;
0779             adap->max_feed_count = adap->props->pid_filter_count;
0780         } else {
0781             dev_info(&d->udev->dev,
0782                     "%s: will pass the complete MPEG2 transport stream to the software demuxer\n",
0783                     KBUILD_MODNAME);
0784             adap->pid_filtering  = 0;
0785             adap->max_feed_count = 255;
0786         }
0787 
0788         if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
0789                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
0790             dev_info(&d->udev->dev,
0791                     "%s: PID filter enabled by module option\n",
0792                     KBUILD_MODNAME);
0793             adap->pid_filtering  = 1;
0794             adap->max_feed_count = adap->props->pid_filter_count;
0795         }
0796 
0797         ret = dvb_usbv2_adapter_stream_init(adap);
0798         if (ret)
0799             goto err;
0800 
0801         ret = dvb_usbv2_adapter_dvb_init(adap);
0802         if (ret)
0803             goto err;
0804 
0805         ret = dvb_usbv2_adapter_frontend_init(adap);
0806         if (ret)
0807             goto err;
0808 
0809         /* use exclusive FE lock if there is multiple shared FEs */
0810         if (adap->fe[1])
0811             adap->dvb_adap.mfe_shared = 1;
0812     }
0813 
0814     return 0;
0815 err:
0816     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0817     return ret;
0818 }
0819 
0820 static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
0821 {
0822     int i;
0823     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0824 
0825     for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
0826         if (d->adapter[i].props) {
0827             dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
0828             dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
0829             dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
0830             dvb_usbv2_media_device_unregister(&d->adapter[i]);
0831         }
0832     }
0833 
0834     return 0;
0835 }
0836 
0837 /* general initialization functions */
0838 static int dvb_usbv2_exit(struct dvb_usb_device *d)
0839 {
0840     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0841 
0842     dvb_usbv2_remote_exit(d);
0843     dvb_usbv2_adapter_exit(d);
0844     dvb_usbv2_i2c_exit(d);
0845 
0846     return 0;
0847 }
0848 
0849 static int dvb_usbv2_init(struct dvb_usb_device *d)
0850 {
0851     int ret;
0852     dev_dbg(&d->udev->dev, "%s:\n", __func__);
0853 
0854     dvb_usbv2_device_power_ctrl(d, 1);
0855 
0856     if (d->props->read_config) {
0857         ret = d->props->read_config(d);
0858         if (ret < 0)
0859             goto err;
0860     }
0861 
0862     ret = dvb_usbv2_i2c_init(d);
0863     if (ret < 0)
0864         goto err;
0865 
0866     ret = dvb_usbv2_adapter_init(d);
0867     if (ret < 0)
0868         goto err;
0869 
0870     if (d->props->init) {
0871         ret = d->props->init(d);
0872         if (ret < 0)
0873             goto err;
0874     }
0875 
0876     ret = dvb_usbv2_remote_init(d);
0877     if (ret < 0)
0878         goto err;
0879 
0880     dvb_usbv2_device_power_ctrl(d, 0);
0881 
0882     return 0;
0883 err:
0884     dvb_usbv2_device_power_ctrl(d, 0);
0885     dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
0886     return ret;
0887 }
0888 
0889 int dvb_usbv2_probe(struct usb_interface *intf,
0890         const struct usb_device_id *id)
0891 {
0892     int ret;
0893     struct dvb_usb_device *d;
0894     struct usb_device *udev = interface_to_usbdev(intf);
0895     struct dvb_usb_driver_info *driver_info =
0896             (struct dvb_usb_driver_info *) id->driver_info;
0897 
0898     dev_dbg(&udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
0899             intf->cur_altsetting->desc.bInterfaceNumber);
0900 
0901     if (!id->driver_info) {
0902         dev_err(&udev->dev, "%s: driver_info failed\n", KBUILD_MODNAME);
0903         ret = -ENODEV;
0904         goto err;
0905     }
0906 
0907     d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
0908     if (!d) {
0909         dev_err(&udev->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
0910         ret = -ENOMEM;
0911         goto err;
0912     }
0913 
0914     d->intf = intf;
0915     d->name = driver_info->name;
0916     d->rc_map = driver_info->rc_map;
0917     d->udev = udev;
0918     d->props = driver_info->props;
0919 
0920     if (intf->cur_altsetting->desc.bInterfaceNumber !=
0921             d->props->bInterfaceNumber) {
0922         ret = -ENODEV;
0923         goto err_kfree_d;
0924     }
0925 
0926     mutex_init(&d->usb_mutex);
0927     mutex_init(&d->i2c_mutex);
0928 
0929     if (d->props->size_of_priv) {
0930         d->priv = kzalloc(d->props->size_of_priv, GFP_KERNEL);
0931         if (!d->priv) {
0932             dev_err(&d->udev->dev, "%s: kzalloc() failed\n",
0933                     KBUILD_MODNAME);
0934             ret = -ENOMEM;
0935             goto err_kfree_d;
0936         }
0937     }
0938 
0939     if (d->props->probe) {
0940         ret = d->props->probe(d);
0941         if (ret)
0942             goto err_kfree_priv;
0943     }
0944 
0945     if (d->props->identify_state) {
0946         const char *name = NULL;
0947         ret = d->props->identify_state(d, &name);
0948         if (ret == COLD) {
0949             dev_info(&d->udev->dev,
0950                     "%s: found a '%s' in cold state\n",
0951                     KBUILD_MODNAME, d->name);
0952 
0953             if (!name)
0954                 name = d->props->firmware;
0955 
0956             ret = dvb_usbv2_download_firmware(d, name);
0957             if (ret == 0) {
0958                 /* device is warm, continue initialization */
0959                 ;
0960             } else if (ret == RECONNECTS_USB) {
0961                 /*
0962                  * USB core will call disconnect() and then
0963                  * probe() as device reconnects itself from the
0964                  * USB bus. disconnect() will release all driver
0965                  * resources and probe() is called for 'new'
0966                  * device. As 'new' device is warm we should
0967                  * never go here again.
0968                  */
0969                 goto exit;
0970             } else {
0971                 goto err_free_all;
0972             }
0973         } else if (ret != WARM) {
0974             goto err_free_all;
0975         }
0976     }
0977 
0978     dev_info(&d->udev->dev, "%s: found a '%s' in warm state\n",
0979             KBUILD_MODNAME, d->name);
0980 
0981     ret = dvb_usbv2_init(d);
0982     if (ret < 0)
0983         goto err_free_all;
0984 
0985     dev_info(&d->udev->dev,
0986             "%s: '%s' successfully initialized and connected\n",
0987             KBUILD_MODNAME, d->name);
0988 exit:
0989     usb_set_intfdata(intf, d);
0990 
0991     return 0;
0992 err_free_all:
0993     dvb_usbv2_exit(d);
0994     if (d->props->disconnect)
0995         d->props->disconnect(d);
0996 err_kfree_priv:
0997     kfree(d->priv);
0998 err_kfree_d:
0999     kfree(d);
1000 err:
1001     dev_dbg(&udev->dev, "%s: failed=%d\n", __func__, ret);
1002     return ret;
1003 }
1004 EXPORT_SYMBOL(dvb_usbv2_probe);
1005 
1006 void dvb_usbv2_disconnect(struct usb_interface *intf)
1007 {
1008     struct dvb_usb_device *d = usb_get_intfdata(intf);
1009     const char *devname = kstrdup(dev_name(&d->udev->dev), GFP_KERNEL);
1010     const char *drvname = d->name;
1011 
1012     dev_dbg(&d->udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
1013             intf->cur_altsetting->desc.bInterfaceNumber);
1014 
1015     if (d->props->exit)
1016         d->props->exit(d);
1017 
1018     dvb_usbv2_exit(d);
1019 
1020     if (d->props->disconnect)
1021         d->props->disconnect(d);
1022 
1023     kfree(d->priv);
1024     kfree(d);
1025 
1026     pr_info("%s: '%s:%s' successfully deinitialized and disconnected\n",
1027         KBUILD_MODNAME, drvname, devname);
1028     kfree(devname);
1029 }
1030 EXPORT_SYMBOL(dvb_usbv2_disconnect);
1031 
1032 int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
1033 {
1034     struct dvb_usb_device *d = usb_get_intfdata(intf);
1035     int ret = 0, i, active_fe;
1036     struct dvb_frontend *fe;
1037     dev_dbg(&d->udev->dev, "%s:\n", __func__);
1038 
1039     /* stop remote controller poll */
1040     if (d->rc_polling_active)
1041         cancel_delayed_work_sync(&d->rc_query_work);
1042 
1043     for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
1044         active_fe = d->adapter[i].active_fe;
1045         if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1046             fe = d->adapter[i].fe[active_fe];
1047             d->adapter[i].suspend_resume_active = true;
1048 
1049             if (d->props->streaming_ctrl)
1050                 d->props->streaming_ctrl(fe, 0);
1051 
1052             /* stop usb streaming */
1053             usb_urb_killv2(&d->adapter[i].stream);
1054 
1055             ret = dvb_frontend_suspend(fe);
1056         }
1057     }
1058 
1059     return ret;
1060 }
1061 EXPORT_SYMBOL(dvb_usbv2_suspend);
1062 
1063 static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
1064 {
1065     int ret = 0, i, active_fe;
1066     struct dvb_frontend *fe;
1067     dev_dbg(&d->udev->dev, "%s:\n", __func__);
1068 
1069     for (i = 0; i < MAX_NO_OF_ADAPTER_PER_DEVICE; i++) {
1070         active_fe = d->adapter[i].active_fe;
1071         if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1072             fe = d->adapter[i].fe[active_fe];
1073 
1074             ret = dvb_frontend_resume(fe);
1075 
1076             /* resume usb streaming */
1077             usb_urb_submitv2(&d->adapter[i].stream, NULL);
1078 
1079             if (d->props->streaming_ctrl)
1080                 d->props->streaming_ctrl(fe, 1);
1081 
1082             d->adapter[i].suspend_resume_active = false;
1083         }
1084     }
1085 
1086     /* start remote controller poll */
1087     if (d->rc_polling_active)
1088         schedule_delayed_work(&d->rc_query_work,
1089                 msecs_to_jiffies(d->rc.interval));
1090 
1091     return ret;
1092 }
1093 
1094 int dvb_usbv2_resume(struct usb_interface *intf)
1095 {
1096     struct dvb_usb_device *d = usb_get_intfdata(intf);
1097     dev_dbg(&d->udev->dev, "%s:\n", __func__);
1098 
1099     return dvb_usbv2_resume_common(d);
1100 }
1101 EXPORT_SYMBOL(dvb_usbv2_resume);
1102 
1103 int dvb_usbv2_reset_resume(struct usb_interface *intf)
1104 {
1105     struct dvb_usb_device *d = usb_get_intfdata(intf);
1106     int ret;
1107     dev_dbg(&d->udev->dev, "%s:\n", __func__);
1108 
1109     dvb_usbv2_device_power_ctrl(d, 1);
1110 
1111     if (d->props->init)
1112         d->props->init(d);
1113 
1114     ret = dvb_usbv2_resume_common(d);
1115 
1116     dvb_usbv2_device_power_ctrl(d, 0);
1117 
1118     return ret;
1119 }
1120 EXPORT_SYMBOL(dvb_usbv2_reset_resume);
1121 
1122 MODULE_VERSION("2.0");
1123 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
1124 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1125 MODULE_DESCRIPTION("DVB USB common");
1126 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!