drivers/media/usb/dvb-usb-v2/dvb_usb_core.c

   1 /*
   2  * DVB USB framework
   3  *
   4  * Copyright (C) 2004-6 Patrick Boettcher <patrick.boettcher@posteo.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
  24 static int dvb_usbv2_disable_rc_polling;
  25 module_param_named(disable_rc_polling, dvb_usbv2_disable_rc_polling, int, 0644);
  26 MODULE_PARM_DESC(disable_rc_polling,
  27                 "disable remote control polling (default: 0)");
  28 static int dvb_usb_force_pid_filter_usage;
  29 module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage,
  30                 int, 0444);
  31 MODULE_PARM_DESC(force_pid_filter_usage,
  32                 "force all DVB USB devices to use a PID filter, if any (default: 0)");
  33
  34 static 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;
  63 err:
  64         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  65         return ret;
  66 }
  67
  68 static 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;
  90 err:
  91         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  92         return ret;
  93 }
  94
  95 static 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)
 106 static 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
 133 static 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;
 193 err:
 194         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 195         return ret;
 196 }
 197
 198 static 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
 215 static 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
 222 static 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
 229 static 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
 236 static 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
 248 static 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
 256 static 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         }
 328 skip_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
 344 static 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);
 396 skip_feed_stop:
 397
 398         if (ret)
 399                 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 400         return ret;
 401 }
 402
 403 static int dvb_usbv2_media_device_init(struct dvb_usb_adapter *adap)
 404 {
 405 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 406         struct media_device *mdev;
 407         struct dvb_usb_device *d = adap_to_d(adap);
 408         struct usb_device *udev = d->udev;
 409
 410         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
 411         if (!mdev)
 412                 return -ENOMEM;
 413
 414         mdev->dev = &udev->dev;
 415         strlcpy(mdev->model, d->name, sizeof(mdev->model));
 416         if (udev->serial)
 417                 strlcpy(mdev->serial, udev->serial, sizeof(mdev->serial));
 418         strcpy(mdev->bus_info, udev->devpath);
 419         mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice);
 420         mdev->driver_version = LINUX_VERSION_CODE;
 421
 422         media_device_init(mdev);
 423
 424         dvb_register_media_controller(&adap->dvb_adap, mdev);
 425
 426         dev_info(&d->udev->dev, "media controller created\n");
 427 #endif
 428         return 0;
 429 }
 430
 431 static int dvb_usbv2_media_device_register(struct dvb_usb_adapter *adap)
 432 {
 433 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 434         return media_device_register(adap->dvb_adap.mdev);
 435 #else
 436         return 0;
 437 #endif
 438 }
 439
 440 static void dvb_usbv2_media_device_unregister(struct dvb_usb_adapter *adap)
 441 {
 442 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 443
 444         if (!adap->dvb_adap.mdev)
 445                 return;
 446
 447         media_device_unregister(adap->dvb_adap.mdev);
 448         media_device_cleanup(adap->dvb_adap.mdev);
 449         kfree(adap->dvb_adap.mdev);
 450         adap->dvb_adap.mdev = NULL;
 451
 452 #endif
 453 }
 454
 455 static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
 456 {
 457         int ret;
 458         struct dvb_usb_device *d = adap_to_d(adap);
 459
 460         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
 461
 462         ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner,
 463                         &d->udev->dev, d->props->adapter_nr);
 464         if (ret < 0) {
 465                 dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n",
 466                                 __func__, ret);
 467                 goto err_dvb_register_adapter;
 468         }
 469
 470         adap->dvb_adap.priv = adap;
 471
 472         ret = dvb_usbv2_media_device_init(adap);
 473         if (ret < 0) {
 474                 dev_dbg(&d->udev->dev, "%s: dvb_usbv2_media_device_init() failed=%d\n",
 475                                 __func__, ret);
 476                 goto err_dvb_register_mc;
 477         }
 478
 479         if (d->props->read_mac_address) {
 480                 ret = d->props->read_mac_address(adap,
 481                                 adap->dvb_adap.proposed_mac);
 482                 if (ret < 0)
 483                         goto err_dvb_dmx_init;
 484
 485                 dev_info(&d->udev->dev, "%s: MAC address: %pM\n",
 486                                 KBUILD_MODNAME, adap->dvb_adap.proposed_mac);
 487         }
 488
 489         adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
 490         adap->demux.priv             = adap;
 491         adap->demux.filternum        = 0;
 492         adap->demux.filternum        = adap->max_feed_count;
 493         adap->demux.feednum          = adap->demux.filternum;
 494         adap->demux.start_feed       = dvb_usb_start_feed;
 495         adap->demux.stop_feed        = dvb_usb_stop_feed;
 496         adap->demux.write_to_decoder = NULL;
 497         ret = dvb_dmx_init(&adap->demux);
 498         if (ret < 0) {
 499                 dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n",
 500                                 KBUILD_MODNAME, ret);
 501                 goto err_dvb_dmx_init;
 502         }
 503
 504         adap->dmxdev.filternum       = adap->demux.filternum;
 505         adap->dmxdev.demux           = &adap->demux.dmx;
 506         adap->dmxdev.capabilities    = 0;
 507         ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
 508         if (ret < 0) {
 509                 dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n",
 510                                 KBUILD_MODNAME, ret);
 511                 goto err_dvb_dmxdev_init;
 512         }
 513
 514         ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
 515         if (ret < 0) {
 516                 dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n",
 517                                 KBUILD_MODNAME, ret);
 518                 goto err_dvb_net_init;
 519         }
 520
 521         return 0;
 522 err_dvb_net_init:
 523         dvb_dmxdev_release(&adap->dmxdev);
 524 err_dvb_dmxdev_init:
 525         dvb_dmx_release(&adap->demux);
 526 err_dvb_dmx_init:
 527         dvb_usbv2_media_device_unregister(adap);
 528 err_dvb_register_mc:
 529         dvb_unregister_adapter(&adap->dvb_adap);
 530 err_dvb_register_adapter:
 531         adap->dvb_adap.priv = NULL;
 532         return ret;
 533 }
 534
 535 static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
 536 {
 537         dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
 538                         adap->id);
 539
 540         if (adap->dvb_adap.priv) {
 541                 dvb_net_release(&adap->dvb_net);
 542                 adap->demux.dmx.close(&adap->demux.dmx);
 543                 dvb_dmxdev_release(&adap->dmxdev);
 544                 dvb_dmx_release(&adap->demux);
 545                 dvb_unregister_adapter(&adap->dvb_adap);
 546         }
 547
 548         return 0;
 549 }
 550
 551 static int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
 552 {
 553         int ret;
 554
 555         if (onoff)
 556                 d->powered++;
 557         else
 558                 d->powered--;
 559
 560         if (d->powered == 0 || (onoff && d->powered == 1)) {
 561                 /* when switching from 1 to 0 or from 0 to 1 */
 562                 dev_dbg(&d->udev->dev, "%s: power=%d\n", __func__, onoff);
 563                 if (d->props->power_ctrl) {
 564                         ret = d->props->power_ctrl(d, onoff);
 565                         if (ret < 0)
 566                                 goto err;
 567                 }
 568         }
 569
 570         return 0;
 571 err:
 572         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 573         return ret;
 574 }
 575
 576 static int dvb_usb_fe_init(struct dvb_frontend *fe)
 577 {
 578         int ret;
 579         struct dvb_usb_adapter *adap = fe->dvb->priv;
 580         struct dvb_usb_device *d = adap_to_d(adap);
 581         dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
 582                         fe->id);
 583
 584         if (!adap->suspend_resume_active) {
 585                 adap->active_fe = fe->id;
 586                 set_bit(ADAP_INIT, &adap->state_bits);
 587         }
 588
 589         ret = dvb_usbv2_device_power_ctrl(d, 1);
 590         if (ret < 0)
 591                 goto err;
 592
 593         if (d->props->frontend_ctrl) {
 594                 ret = d->props->frontend_ctrl(fe, 1);
 595                 if (ret < 0)
 596                         goto err;
 597         }
 598
 599         if (adap->fe_init[fe->id]) {
 600                 ret = adap->fe_init[fe->id](fe);
 601                 if (ret < 0)
 602                         goto err;
 603         }
 604 err:
 605         if (!adap->suspend_resume_active) {
 606                 clear_bit(ADAP_INIT, &adap->state_bits);
 607                 smp_mb__after_atomic();
 608                 wake_up_bit(&adap->state_bits, ADAP_INIT);
 609         }
 610
 611         dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
 612         return ret;
 613 }
 614
 615 static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
 616 {
 617         int ret;
 618         struct dvb_usb_adapter *adap = fe->dvb->priv;
 619         struct dvb_usb_device *d = adap_to_d(adap);
 620         dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
 621                         fe->id);
 622
 623         if (!adap->suspend_resume_active) {
 624                 set_bit(ADAP_SLEEP, &adap->state_bits);
 625                 wait_on_bit(&adap->state_bits, ADAP_STREAMING,
 626                                 TASK_UNINTERRUPTIBLE);
 627         }
 628
 629         if (adap->fe_sleep[fe->id]) {
 630                 ret = adap->fe_sleep[fe->id](fe);
 631                 if (ret < 0)
 632                         goto err;
 633         }
 634
 635         if (d->props->frontend_ctrl) {
 636                 ret = d->props->frontend_ctrl(fe, 0);
 637                 if (ret < 0)
 638                         goto err;
 639         }
 640
 641         ret = dvb_usbv2_device_power_ctrl(d, 0);
 642         if (ret < 0)
 643                 goto err;
 644 err:
 645         if (!adap->suspend_resume_active) {
 646                 adap->active_fe = -1;
 647                 clear_bit(ADAP_SLEEP, &adap->state_bits);
 648                 smp_mb__after_atomic();
 649                 wake_up_bit(&adap->state_bits, ADAP_SLEEP);
 650         }
 651
 652         dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
 653         return ret;
 654 }
 655
 656 static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
 657 {
 658         int ret, i, count_registered = 0;
 659         struct dvb_usb_device *d = adap_to_d(adap);
 660         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
 661
 662         memset(adap->fe, 0, sizeof(adap->fe));
 663         adap->active_fe = -1;
 664
 665         if (d->props->frontend_attach) {
 666                 ret = d->props->frontend_attach(adap);
 667                 if (ret < 0) {
 668                         dev_dbg(&d->udev->dev,
 669                                         "%s: frontend_attach() failed=%d\n",
 670                                         __func__, ret);
 671                         goto err_dvb_frontend_detach;
 672                 }
 673         } else {
 674                 dev_dbg(&d->udev->dev, "%s: frontend_attach() do not exists\n",
 675                                 __func__);
 676                 ret = 0;
 677                 goto err;
 678         }
 679
 680         for (i = 0; i < MAX_NO_OF_FE_PER_ADAP && adap->fe[i]; i++) {
 681                 adap->fe[i]->id = i;
 682                 /* re-assign sleep and wakeup functions */
 683                 adap->fe_init[i] = adap->fe[i]->ops.init;
 684                 adap->fe[i]->ops.init = dvb_usb_fe_init;
 685                 adap->fe_sleep[i] = adap->fe[i]->ops.sleep;
 686                 adap->fe[i]->ops.sleep = dvb_usb_fe_sleep;
 687
 688                 ret = dvb_register_frontend(&adap->dvb_adap, adap->fe[i]);
 689                 if (ret < 0) {
 690                         dev_err(&d->udev->dev,
 691                                         "%s: frontend%d registration failed\n",
 692                                         KBUILD_MODNAME, i);
 693                         goto err_dvb_unregister_frontend;
 694                 }
 695
 696                 count_registered++;
 697         }
 698
 699         if (d->props->tuner_attach) {
 700                 ret = d->props->tuner_attach(adap);
 701                 if (ret < 0) {
 702                         dev_dbg(&d->udev->dev, "%s: tuner_attach() failed=%d\n",
 703                                         __func__, ret);
 704                         goto err_dvb_unregister_frontend;
 705                 }
 706         }
 707
 708         ret = dvb_create_media_graph(&adap->dvb_adap, true);
 709         if (ret < 0)
 710                 goto err_dvb_unregister_frontend;
 711
 712         ret = dvb_usbv2_media_device_register(adap);
 713
 714         return ret;
 715
 716 err_dvb_unregister_frontend:
 717         for (i = count_registered - 1; i >= 0; i--)
 718                 dvb_unregister_frontend(adap->fe[i]);
 719
 720 err_dvb_frontend_detach:
 721         for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
 722                 if (adap->fe[i]) {
 723                         dvb_frontend_detach(adap->fe[i]);
 724                         adap->fe[i] = NULL;
 725                 }
 726         }
 727
 728 err:
 729         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 730         return ret;
 731 }
 732
 733 static int dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter *adap)
 734 {
 735         int ret, i;
 736         struct dvb_usb_device *d = adap_to_d(adap);
 737
 738         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
 739
 740         for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
 741                 if (adap->fe[i]) {
 742                         dvb_unregister_frontend(adap->fe[i]);
 743                         dvb_frontend_detach(adap->fe[i]);
 744                 }
 745         }
 746
 747         if (d->props->tuner_detach) {
 748                 ret = d->props->tuner_detach(adap);
 749                 if (ret < 0) {
 750                         dev_dbg(&d->udev->dev, "%s: tuner_detach() failed=%d\n",
 751                                         __func__, ret);
 752                 }
 753         }
 754
 755         if (d->props->frontend_detach) {
 756                 ret = d->props->frontend_detach(adap);
 757                 if (ret < 0) {
 758                         dev_dbg(&d->udev->dev,
 759                                         "%s: frontend_detach() failed=%d\n",
 760                                         __func__, ret);
 761                 }
 762         }
 763
 764         return 0;
 765 }
 766
 767 static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
 768 {
 769         struct dvb_usb_adapter *adap;
 770         int ret, i, adapter_count;
 771
 772         /* resolve adapter count */
 773         adapter_count = d->props->num_adapters;
 774         if (d->props->get_adapter_count) {
 775                 ret = d->props->get_adapter_count(d);
 776                 if (ret < 0)
 777                         goto err;
 778
 779                 adapter_count = ret;
 780         }
 781
 782         for (i = 0; i < adapter_count; i++) {
 783                 adap = &d->adapter[i];
 784                 adap->id = i;
 785                 adap->props = &d->props->adapter[i];
 786
 787                 /* speed - when running at FULL speed we need a HW PID filter */
 788                 if (d->udev->speed == USB_SPEED_FULL &&
 789                                 !(adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
 790                         dev_err(&d->udev->dev,
 791                                         "%s: this USB2.0 device cannot be run on a USB1.1 port (it lacks a hardware PID filter)\n",
 792                                         KBUILD_MODNAME);
 793                         ret = -ENODEV;
 794                         goto err;
 795                 } else if ((d->udev->speed == USB_SPEED_FULL &&
 796                                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
 797                                 (adap->props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
 798                         dev_info(&d->udev->dev,
 799                                         "%s: will use the device's hardware PID filter (table count: %d)\n",
 800                                         KBUILD_MODNAME,
 801                                         adap->props->pid_filter_count);
 802                         adap->pid_filtering  = 1;
 803                         adap->max_feed_count = adap->props->pid_filter_count;
 804                 } else {
 805                         dev_info(&d->udev->dev,
 806                                         "%s: will pass the complete MPEG2 transport stream to the software demuxer\n",
 807                                         KBUILD_MODNAME);
 808                         adap->pid_filtering  = 0;
 809                         adap->max_feed_count = 255;
 810                 }
 811
 812                 if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
 813                                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
 814                         dev_info(&d->udev->dev,
 815                                         "%s: PID filter enabled by module option\n",
 816                                         KBUILD_MODNAME);
 817                         adap->pid_filtering  = 1;
 818                         adap->max_feed_count = adap->props->pid_filter_count;
 819                 }
 820
 821                 ret = dvb_usbv2_adapter_stream_init(adap);
 822                 if (ret)
 823                         goto err;
 824
 825                 ret = dvb_usbv2_adapter_dvb_init(adap);
 826                 if (ret)
 827                         goto err;
 828
 829                 ret = dvb_usbv2_adapter_frontend_init(adap);
 830                 if (ret)
 831                         goto err;
 832
 833                 /* use exclusive FE lock if there is multiple shared FEs */
 834                 if (adap->fe[1])
 835                         adap->dvb_adap.mfe_shared = 1;
 836         }
 837
 838         return 0;
 839 err:
 840         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 841         return ret;
 842 }
 843
 844 static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
 845 {
 846         int i;
 847         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 848
 849         for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
 850                 if (d->adapter[i].props) {
 851                         dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
 852                         dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
 853                         dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
 854                         dvb_usbv2_media_device_unregister(&d->adapter[i]);
 855                 }
 856         }
 857
 858         return 0;
 859 }
 860
 861 /* general initialization functions */
 862 static int dvb_usbv2_exit(struct dvb_usb_device *d)
 863 {
 864         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 865
 866         dvb_usbv2_remote_exit(d);
 867         dvb_usbv2_adapter_exit(d);
 868         dvb_usbv2_i2c_exit(d);
 869         kfree(d->priv);
 870         kfree(d);
 871
 872         return 0;
 873 }
 874
 875 static int dvb_usbv2_init(struct dvb_usb_device *d)
 876 {
 877         int ret;
 878         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 879
 880         dvb_usbv2_device_power_ctrl(d, 1);
 881
 882         if (d->props->read_config) {
 883                 ret = d->props->read_config(d);
 884                 if (ret < 0)
 885                         goto err;
 886         }
 887
 888         ret = dvb_usbv2_i2c_init(d);
 889         if (ret < 0)
 890                 goto err;
 891
 892         ret = dvb_usbv2_adapter_init(d);
 893         if (ret < 0)
 894                 goto err;
 895
 896         if (d->props->init) {
 897                 ret = d->props->init(d);
 898                 if (ret < 0)
 899                         goto err;
 900         }
 901
 902         ret = dvb_usbv2_remote_init(d);
 903         if (ret < 0)
 904                 goto err;
 905
 906         dvb_usbv2_device_power_ctrl(d, 0);
 907
 908         return 0;
 909 err:
 910         dvb_usbv2_device_power_ctrl(d, 0);
 911         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 912         return ret;
 913 }
 914
 915 int dvb_usbv2_probe(struct usb_interface *intf,
 916                 const struct usb_device_id *id)
 917 {
 918         int ret;
 919         struct dvb_usb_device *d;
 920         struct usb_device *udev = interface_to_usbdev(intf);
 921         struct dvb_usb_driver_info *driver_info =
 922                         (struct dvb_usb_driver_info *) id->driver_info;
 923
 924         dev_dbg(&udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
 925                         intf->cur_altsetting->desc.bInterfaceNumber);
 926
 927         if (!id->driver_info) {
 928                 dev_err(&udev->dev, "%s: driver_info failed\n", KBUILD_MODNAME);
 929                 ret = -ENODEV;
 930                 goto err;
 931         }
 932
 933         d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
 934         if (!d) {
 935                 dev_err(&udev->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
 936                 ret = -ENOMEM;
 937                 goto err;
 938         }
 939
 940         d->intf = intf;
 941         d->name = driver_info->name;
 942         d->rc_map = driver_info->rc_map;
 943         d->udev = udev;
 944         d->props = driver_info->props;
 945
 946         if (intf->cur_altsetting->desc.bInterfaceNumber !=
 947                         d->props->bInterfaceNumber) {
 948                 ret = -ENODEV;
 949                 goto err_free_all;
 950         }
 951
 952         mutex_init(&d->usb_mutex);
 953         mutex_init(&d->i2c_mutex);
 954
 955         if (d->props->size_of_priv) {
 956                 d->priv = kzalloc(d->props->size_of_priv, GFP_KERNEL);
 957                 if (!d->priv) {
 958                         dev_err(&d->udev->dev, "%s: kzalloc() failed\n",
 959                                         KBUILD_MODNAME);
 960                         ret = -ENOMEM;
 961                         goto err_free_all;
 962                 }
 963         }
 964
 965         if (d->props->identify_state) {
 966                 const char *name = NULL;
 967                 ret = d->props->identify_state(d, &name);
 968                 if (ret == 0) {
 969                         ;
 970                 } else if (ret == COLD) {
 971                         dev_info(&d->udev->dev,
 972                                         "%s: found a '%s' in cold state\n",
 973                                         KBUILD_MODNAME, d->name);
 974
 975                         if (!name)
 976                                 name = d->props->firmware;
 977
 978                         ret = dvb_usbv2_download_firmware(d, name);
 979                         if (ret == 0) {
 980                                 /* device is warm, continue initialization */
 981                                 ;
 982                         } else if (ret == RECONNECTS_USB) {
 983                                 /*
 984                                  * USB core will call disconnect() and then
 985                                  * probe() as device reconnects itself from the
 986                                  * USB bus. disconnect() will release all driver
 987                                  * resources and probe() is called for 'new'
 988                                  * device. As 'new' device is warm we should
 989                                  * never go here again.
 990                                  */
 991                                 goto exit;
 992                         } else {
 993                                 goto err_free_all;
 994                         }
 995                 } else {
 996                         goto err_free_all;
 997                 }
 998         }
 999
1000         dev_info(&d->udev->dev, "%s: found a '%s' in warm state\n",
1001                         KBUILD_MODNAME, d->name);
1002
1003         ret = dvb_usbv2_init(d);
1004         if (ret < 0)
1005                 goto err_free_all;
1006
1007         dev_info(&d->udev->dev,
1008                         "%s: '%s' successfully initialized and connected\n",
1009                         KBUILD_MODNAME, d->name);
1010 exit:
1011         usb_set_intfdata(intf, d);
1012
1013         return 0;
1014 err_free_all:
1015         dvb_usbv2_exit(d);
1016 err:
1017         dev_dbg(&udev->dev, "%s: failed=%d\n", __func__, ret);
1018         return ret;
1019 }
1020 EXPORT_SYMBOL(dvb_usbv2_probe);
1021
1022 void dvb_usbv2_disconnect(struct usb_interface *intf)
1023 {
1024         struct dvb_usb_device *d = usb_get_intfdata(intf);
1025         const char *name = d->name;
1026         struct device dev = d->udev->dev;
1027
1028         dev_dbg(&d->udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
1029                         intf->cur_altsetting->desc.bInterfaceNumber);
1030
1031         if (d->props->exit)
1032                 d->props->exit(d);
1033
1034         dvb_usbv2_exit(d);
1035
1036         dev_info(&dev, "%s: '%s' successfully deinitialized and disconnected\n",
1037                         KBUILD_MODNAME, name);
1038 }
1039 EXPORT_SYMBOL(dvb_usbv2_disconnect);
1040
1041 int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
1042 {
1043         struct dvb_usb_device *d = usb_get_intfdata(intf);
1044         int ret = 0, i, active_fe;
1045         struct dvb_frontend *fe;
1046         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1047
1048         /* stop remote controller poll */
1049         if (d->rc_polling_active)
1050                 cancel_delayed_work_sync(&d->rc_query_work);
1051
1052         for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
1053                 active_fe = d->adapter[i].active_fe;
1054                 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1055                         fe = d->adapter[i].fe[active_fe];
1056                         d->adapter[i].suspend_resume_active = true;
1057
1058                         if (d->props->streaming_ctrl)
1059                                 d->props->streaming_ctrl(fe, 0);
1060
1061                         /* stop usb streaming */
1062                         usb_urb_killv2(&d->adapter[i].stream);
1063
1064                         ret = dvb_frontend_suspend(fe);
1065                 }
1066         }
1067
1068         return ret;
1069 }
1070 EXPORT_SYMBOL(dvb_usbv2_suspend);
1071
1072 static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
1073 {
1074         int ret = 0, i, active_fe;
1075         struct dvb_frontend *fe;
1076         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1077
1078         for (i = 0; i < MAX_NO_OF_ADAPTER_PER_DEVICE; i++) {
1079                 active_fe = d->adapter[i].active_fe;
1080                 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1081                         fe = d->adapter[i].fe[active_fe];
1082
1083                         ret = dvb_frontend_resume(fe);
1084
1085                         /* resume usb streaming */
1086                         usb_urb_submitv2(&d->adapter[i].stream, NULL);
1087
1088                         if (d->props->streaming_ctrl)
1089                                 d->props->streaming_ctrl(fe, 1);
1090
1091                         d->adapter[i].suspend_resume_active = false;
1092                 }
1093         }
1094
1095         /* start remote controller poll */
1096         if (d->rc_polling_active)
1097                 schedule_delayed_work(&d->rc_query_work,
1098                                 msecs_to_jiffies(d->rc.interval));
1099
1100         return ret;
1101 }
1102
1103 int dvb_usbv2_resume(struct usb_interface *intf)
1104 {
1105         struct dvb_usb_device *d = usb_get_intfdata(intf);
1106         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1107
1108         return dvb_usbv2_resume_common(d);
1109 }
1110 EXPORT_SYMBOL(dvb_usbv2_resume);
1111
1112 int dvb_usbv2_reset_resume(struct usb_interface *intf)
1113 {
1114         struct dvb_usb_device *d = usb_get_intfdata(intf);
1115         int ret;
1116         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1117
1118         dvb_usbv2_device_power_ctrl(d, 1);
1119
1120         if (d->props->init)
1121                 d->props->init(d);
1122
1123         ret = dvb_usbv2_resume_common(d);
1124
1125         dvb_usbv2_device_power_ctrl(d, 0);
1126
1127         return ret;
1128 }
1129 EXPORT_SYMBOL(dvb_usbv2_reset_resume);
1130
1131 MODULE_VERSION("2.0");
1132 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
1133 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1134 MODULE_DESCRIPTION("DVB USB common");
1135 MODULE_LICENSE("GPL");