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