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@desy.de>
   5  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License along
  18  *    with this program; if not, write to the Free Software Foundation, Inc.,
  19  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "dvb_usb_common.h"
  23
  24 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, "force all DVB USB devices to use a " \
  32                 "PID filter, if any (default: 0)");
  33
  34 static int dvb_usbv2_download_firmware(struct dvb_usb_device *d, const char *name)
  35 {
  36         int ret;
  37         const struct firmware *fw;
  38         dev_dbg(&d->udev->dev, "%s:\n", __func__);
  39
  40         if (!d->props->download_firmware) {
  41                 ret = -EINVAL;
  42                 goto err;
  43         }
  44
  45         ret = request_firmware(&fw, name, &d->udev->dev);
  46         if (ret < 0) {
  47                 dev_err(&d->udev->dev, "%s: Did not find the firmware file "\
  48                                 "'%s'. Please see linux/Documentation/dvb/ " \
  49                                 "for more details on firmware-problems. " \
  50                                 "Status %d\n", 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 defined(CONFIG_RC_CORE) || defined(CONFIG_RC_CORE_MODULE)
 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_protos = 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, "%s: schedule remote query interval " \
 185                                 "to %d msecs\n", KBUILD_MODNAME,
 186                                 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 inline int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed,
 257                 int count)
 258 {
 259         struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
 260         struct dvb_usb_device *d = adap_to_d(adap);
 261         int ret;
 262         dev_dbg(&d->udev->dev, "%s: adap=%d active_fe=%d feed_type=%d " \
 263                         "setting pid [%s]: %04x (%04d) at index %d '%s'\n",
 264                         __func__, adap->id, adap->active_fe, dvbdmxfeed->type,
 265                         adap->pid_filtering ? "yes" : "no", dvbdmxfeed->pid,
 266                         dvbdmxfeed->pid, dvbdmxfeed->index,
 267                         (count == 1) ? "on" : "off");
 268
 269         if (adap->active_fe == -1)
 270                 return -EINVAL;
 271
 272         adap->feed_count += count;
 273
 274         /* stop feeding if it is last pid */
 275         if (adap->feed_count == 0) {
 276                 dev_dbg(&d->udev->dev, "%s: stop feeding\n", __func__);
 277
 278                 if (d->props->streaming_ctrl) {
 279                         ret = d->props->streaming_ctrl(
 280                                         adap->fe[adap->active_fe], 0);
 281                         if (ret < 0) {
 282                                 dev_err(&d->udev->dev, "%s: streaming_ctrl() " \
 283                                                 "failed=%d\n", KBUILD_MODNAME,
 284                                                 ret);
 285                                 usb_urb_killv2(&adap->stream);
 286                                 goto err_mutex_unlock;
 287                         }
 288                 }
 289                 usb_urb_killv2(&adap->stream);
 290                 mutex_unlock(&adap->sync_mutex);
 291         }
 292
 293         /* activate the pid on the device pid filter */
 294         if (adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER &&
 295                         adap->pid_filtering && adap->props->pid_filter) {
 296                 ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
 297                                 dvbdmxfeed->pid, (count == 1) ? 1 : 0);
 298                 if (ret < 0)
 299                         dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
 300                                         KBUILD_MODNAME, ret);
 301         }
 302
 303         /* start feeding if it is first pid */
 304         if (adap->feed_count == 1 && count == 1) {
 305                 struct usb_data_stream_properties stream_props;
 306                 mutex_lock(&adap->sync_mutex);
 307                 dev_dbg(&d->udev->dev, "%s: start feeding\n", __func__);
 308
 309                 /* resolve input and output streaming paramters */
 310                 if (d->props->get_stream_config) {
 311                         memcpy(&stream_props, &adap->props->stream,
 312                                 sizeof(struct usb_data_stream_properties));
 313                         ret = d->props->get_stream_config(
 314                                         adap->fe[adap->active_fe],
 315                                         &adap->ts_type, &stream_props);
 316                         if (ret < 0)
 317                                 goto err_mutex_unlock;
 318                 } else {
 319                         stream_props = adap->props->stream;
 320                 }
 321
 322                 switch (adap->ts_type) {
 323                 case DVB_USB_FE_TS_TYPE_204:
 324                         adap->stream.complete = dvb_usb_data_complete_204;
 325                         break;
 326                 case DVB_USB_FE_TS_TYPE_RAW:
 327                         adap->stream.complete = dvb_usb_data_complete_raw;
 328                         break;
 329                 case DVB_USB_FE_TS_TYPE_188:
 330                 default:
 331                         adap->stream.complete = dvb_usb_data_complete;
 332                         break;
 333                 }
 334
 335                 usb_urb_submitv2(&adap->stream, &stream_props);
 336
 337                 if (adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER &&
 338                                 adap->props->caps &
 339                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF &&
 340                                 adap->props->pid_filter_ctrl) {
 341                         ret = adap->props->pid_filter_ctrl(adap,
 342                                         adap->pid_filtering);
 343                         if (ret < 0) {
 344                                 dev_err(&d->udev->dev, "%s: " \
 345                                                 "pid_filter_ctrl() failed=%d\n",
 346                                                 KBUILD_MODNAME, ret);
 347                                 goto err_mutex_unlock;
 348                         }
 349                 }
 350
 351                 if (d->props->streaming_ctrl) {
 352                         ret = d->props->streaming_ctrl(
 353                                         adap->fe[adap->active_fe], 1);
 354                         if (ret < 0) {
 355                                 dev_err(&d->udev->dev, "%s: streaming_ctrl() " \
 356                                                 "failed=%d\n", KBUILD_MODNAME,
 357                                                 ret);
 358                                 goto err_mutex_unlock;
 359                         }
 360                 }
 361         }
 362
 363         return 0;
 364 err_mutex_unlock:
 365         mutex_unlock(&adap->sync_mutex);
 366         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 367         return ret;
 368 }
 369
 370 static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 371 {
 372         return dvb_usb_ctrl_feed(dvbdmxfeed, 1);
 373 }
 374
 375 static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 376 {
 377         return dvb_usb_ctrl_feed(dvbdmxfeed, -1);
 378 }
 379
 380 static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap)
 381 {
 382         int ret;
 383         struct dvb_usb_device *d = adap_to_d(adap);
 384         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
 385
 386         ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner,
 387                         &d->udev->dev, d->props->adapter_nr);
 388         if (ret < 0) {
 389                 dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n",
 390                                 __func__, ret);
 391                 goto err_dvb_register_adapter;
 392         }
 393
 394         adap->dvb_adap.priv = adap;
 395
 396         if (d->props->read_mac_address) {
 397                 ret = d->props->read_mac_address(adap,
 398                                 adap->dvb_adap.proposed_mac);
 399                 if (ret < 0)
 400                         goto err_dvb_dmx_init;
 401
 402                 dev_info(&d->udev->dev, "%s: MAC address: %pM\n",
 403                                 KBUILD_MODNAME, adap->dvb_adap.proposed_mac);
 404         }
 405
 406         adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
 407         adap->demux.priv             = adap;
 408         adap->demux.filternum        = 0;
 409         adap->demux.filternum        = adap->max_feed_count;
 410         adap->demux.feednum          = adap->demux.filternum;
 411         adap->demux.start_feed       = dvb_usb_start_feed;
 412         adap->demux.stop_feed        = dvb_usb_stop_feed;
 413         adap->demux.write_to_decoder = NULL;
 414         ret = dvb_dmx_init(&adap->demux);
 415         if (ret < 0) {
 416                 dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n",
 417                                 KBUILD_MODNAME, ret);
 418                 goto err_dvb_dmx_init;
 419         }
 420
 421         adap->dmxdev.filternum       = adap->demux.filternum;
 422         adap->dmxdev.demux           = &adap->demux.dmx;
 423         adap->dmxdev.capabilities    = 0;
 424         ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
 425         if (ret < 0) {
 426                 dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n",
 427                                 KBUILD_MODNAME, ret);
 428                 goto err_dvb_dmxdev_init;
 429         }
 430
 431         ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
 432         if (ret < 0) {
 433                 dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n",
 434                                 KBUILD_MODNAME, ret);
 435                 goto err_dvb_net_init;
 436         }
 437
 438         mutex_init(&adap->sync_mutex);
 439
 440         return 0;
 441 err_dvb_net_init:
 442         dvb_dmxdev_release(&adap->dmxdev);
 443 err_dvb_dmxdev_init:
 444         dvb_dmx_release(&adap->demux);
 445 err_dvb_dmx_init:
 446         dvb_unregister_adapter(&adap->dvb_adap);
 447 err_dvb_register_adapter:
 448         adap->dvb_adap.priv = NULL;
 449         return ret;
 450 }
 451
 452 static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap)
 453 {
 454         dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
 455                         adap->id);
 456
 457         if (adap->dvb_adap.priv) {
 458                 dvb_net_release(&adap->dvb_net);
 459                 adap->demux.dmx.close(&adap->demux.dmx);
 460                 dvb_dmxdev_release(&adap->dmxdev);
 461                 dvb_dmx_release(&adap->demux);
 462                 dvb_unregister_adapter(&adap->dvb_adap);
 463         }
 464
 465         return 0;
 466 }
 467
 468 static int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
 469 {
 470         int ret;
 471
 472         if (onoff)
 473                 d->powered++;
 474         else
 475                 d->powered--;
 476
 477         if (d->powered == 0 || (onoff && d->powered == 1)) {
 478                 /* when switching from 1 to 0 or from 0 to 1 */
 479                 dev_dbg(&d->udev->dev, "%s: power=%d\n", __func__, onoff);
 480                 if (d->props->power_ctrl) {
 481                         ret = d->props->power_ctrl(d, onoff);
 482                         if (ret < 0)
 483                                 goto err;
 484                 }
 485         }
 486
 487         return 0;
 488 err:
 489         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 490         return ret;
 491 }
 492
 493 static int dvb_usb_fe_init(struct dvb_frontend *fe)
 494 {
 495         int ret;
 496         struct dvb_usb_adapter *adap = fe->dvb->priv;
 497         struct dvb_usb_device *d = adap_to_d(adap);
 498         dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
 499                         fe->id);
 500
 501         if (!adap->suspend_resume_active) {
 502                 adap->active_fe = fe->id;
 503                 mutex_lock(&adap->sync_mutex);
 504         }
 505
 506         ret = dvb_usbv2_device_power_ctrl(d, 1);
 507         if (ret < 0)
 508                 goto err;
 509
 510         if (d->props->frontend_ctrl) {
 511                 ret = d->props->frontend_ctrl(fe, 1);
 512                 if (ret < 0)
 513                         goto err;
 514         }
 515
 516         if (adap->fe_init[fe->id]) {
 517                 ret = adap->fe_init[fe->id](fe);
 518                 if (ret < 0)
 519                         goto err;
 520         }
 521 err:
 522         if (!adap->suspend_resume_active)
 523                 mutex_unlock(&adap->sync_mutex);
 524
 525         dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
 526         return ret;
 527 }
 528
 529 static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
 530 {
 531         int ret;
 532         struct dvb_usb_adapter *adap = fe->dvb->priv;
 533         struct dvb_usb_device *d = adap_to_d(adap);
 534         dev_dbg(&d->udev->dev, "%s: adap=%d fe=%d\n", __func__, adap->id,
 535                         fe->id);
 536
 537         if (!adap->suspend_resume_active)
 538                 mutex_lock(&adap->sync_mutex);
 539
 540         if (adap->fe_sleep[fe->id]) {
 541                 ret = adap->fe_sleep[fe->id](fe);
 542                 if (ret < 0)
 543                         goto err;
 544         }
 545
 546         if (d->props->frontend_ctrl) {
 547                 ret = d->props->frontend_ctrl(fe, 0);
 548                 if (ret < 0)
 549                         goto err;
 550         }
 551
 552         ret = dvb_usbv2_device_power_ctrl(d, 0);
 553         if (ret < 0)
 554                 goto err;
 555 err:
 556         if (!adap->suspend_resume_active) {
 557                 adap->active_fe = -1;
 558                 mutex_unlock(&adap->sync_mutex);
 559         }
 560
 561         dev_dbg(&d->udev->dev, "%s: ret=%d\n", __func__, ret);
 562         return ret;
 563 }
 564
 565 static int dvb_usbv2_adapter_frontend_init(struct dvb_usb_adapter *adap)
 566 {
 567         int ret, i, count_registered = 0;
 568         struct dvb_usb_device *d = adap_to_d(adap);
 569         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id);
 570
 571         memset(adap->fe, 0, sizeof(adap->fe));
 572         adap->active_fe = -1;
 573
 574         if (d->props->frontend_attach) {
 575                 ret = d->props->frontend_attach(adap);
 576                 if (ret < 0) {
 577                         dev_dbg(&d->udev->dev, "%s: frontend_attach() " \
 578                                         "failed=%d\n", __func__, ret);
 579                         goto err_dvb_frontend_detach;
 580                 }
 581         } else {
 582                 dev_dbg(&d->udev->dev, "%s: frontend_attach() do not exists\n",
 583                                 __func__);
 584                 ret = 0;
 585                 goto err;
 586         }
 587
 588         for (i = 0; i < MAX_NO_OF_FE_PER_ADAP && adap->fe[i]; i++) {
 589                 adap->fe[i]->id = i;
 590                 /* re-assign sleep and wakeup functions */
 591                 adap->fe_init[i] = adap->fe[i]->ops.init;
 592                 adap->fe[i]->ops.init = dvb_usb_fe_init;
 593                 adap->fe_sleep[i] = adap->fe[i]->ops.sleep;
 594                 adap->fe[i]->ops.sleep = dvb_usb_fe_sleep;
 595
 596                 ret = dvb_register_frontend(&adap->dvb_adap, adap->fe[i]);
 597                 if (ret < 0) {
 598                         dev_err(&d->udev->dev, "%s: frontend%d registration " \
 599                                         "failed\n", KBUILD_MODNAME, i);
 600                         goto err_dvb_unregister_frontend;
 601                 }
 602
 603                 count_registered++;
 604         }
 605
 606         if (d->props->tuner_attach) {
 607                 ret = d->props->tuner_attach(adap);
 608                 if (ret < 0) {
 609                         dev_dbg(&d->udev->dev, "%s: tuner_attach() failed=%d\n",
 610                                         __func__, ret);
 611                         goto err_dvb_unregister_frontend;
 612                 }
 613         }
 614
 615         return 0;
 616
 617 err_dvb_unregister_frontend:
 618         for (i = count_registered - 1; i >= 0; i--)
 619                 dvb_unregister_frontend(adap->fe[i]);
 620
 621 err_dvb_frontend_detach:
 622         for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
 623                 if (adap->fe[i]) {
 624                         dvb_frontend_detach(adap->fe[i]);
 625                         adap->fe[i] = NULL;
 626                 }
 627         }
 628
 629 err:
 630         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 631         return ret;
 632 }
 633
 634 static int dvb_usbv2_adapter_frontend_exit(struct dvb_usb_adapter *adap)
 635 {
 636         int i;
 637         dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__,
 638                         adap->id);
 639
 640         for (i = MAX_NO_OF_FE_PER_ADAP - 1; i >= 0; i--) {
 641                 if (adap->fe[i]) {
 642                         dvb_unregister_frontend(adap->fe[i]);
 643                         dvb_frontend_detach(adap->fe[i]);
 644                 }
 645         }
 646
 647         return 0;
 648 }
 649
 650 static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
 651 {
 652         struct dvb_usb_adapter *adap;
 653         int ret, i, adapter_count;
 654
 655         /* resolve adapter count */
 656         adapter_count = d->props->num_adapters;
 657         if (d->props->get_adapter_count) {
 658                 ret = d->props->get_adapter_count(d);
 659                 if (ret < 0)
 660                         goto err;
 661
 662                 adapter_count = ret;
 663         }
 664
 665         for (i = 0; i < adapter_count; i++) {
 666                 adap = &d->adapter[i];
 667                 adap->id = i;
 668                 adap->props = &d->props->adapter[i];
 669
 670                 /* speed - when running at FULL speed we need a HW PID filter */
 671                 if (d->udev->speed == USB_SPEED_FULL &&
 672                                 !(adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
 673                         dev_err(&d->udev->dev, "%s: this USB2.0 device " \
 674                                         "cannot be run on a USB1.1 port (it " \
 675                                         "lacks a hardware PID filter)\n",
 676                                         KBUILD_MODNAME);
 677                         ret = -ENODEV;
 678                         goto err;
 679                 } else if ((d->udev->speed == USB_SPEED_FULL &&
 680                                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
 681                                 (adap->props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
 682                         dev_info(&d->udev->dev, "%s: will use the device's " \
 683                                         "hardware PID filter " \
 684                                         "(table count: %d)\n", KBUILD_MODNAME,
 685                                         adap->props->pid_filter_count);
 686                         adap->pid_filtering  = 1;
 687                         adap->max_feed_count = adap->props->pid_filter_count;
 688                 } else {
 689                         dev_info(&d->udev->dev, "%s: will pass the complete " \
 690                                         "MPEG2 transport stream to the " \
 691                                         "software demuxer\n", KBUILD_MODNAME);
 692                         adap->pid_filtering  = 0;
 693                         adap->max_feed_count = 255;
 694                 }
 695
 696                 if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
 697                                 adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
 698                         dev_info(&d->udev->dev, "%s: PID filter enabled by " \
 699                                         "module option\n", KBUILD_MODNAME);
 700                         adap->pid_filtering  = 1;
 701                         adap->max_feed_count = adap->props->pid_filter_count;
 702                 }
 703
 704                 ret = dvb_usbv2_adapter_stream_init(adap);
 705                 if (ret)
 706                         goto err;
 707
 708                 ret = dvb_usbv2_adapter_dvb_init(adap);
 709                 if (ret)
 710                         goto err;
 711
 712                 ret = dvb_usbv2_adapter_frontend_init(adap);
 713                 if (ret)
 714                         goto err;
 715
 716                 /* use exclusive FE lock if there is multiple shared FEs */
 717                 if (adap->fe[1])
 718                         adap->dvb_adap.mfe_shared = 1;
 719         }
 720
 721         return 0;
 722 err:
 723         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 724         return ret;
 725 }
 726
 727 static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
 728 {
 729         int i;
 730         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 731
 732         for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
 733                 if (d->adapter[i].props) {
 734                         dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
 735                         dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
 736                         dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
 737                 }
 738         }
 739
 740         return 0;
 741 }
 742
 743 /* general initialization functions */
 744 static int dvb_usbv2_exit(struct dvb_usb_device *d)
 745 {
 746         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 747
 748         dvb_usbv2_remote_exit(d);
 749         dvb_usbv2_adapter_exit(d);
 750         dvb_usbv2_i2c_exit(d);
 751         kfree(d->priv);
 752         kfree(d);
 753
 754         return 0;
 755 }
 756
 757 static int dvb_usbv2_init(struct dvb_usb_device *d)
 758 {
 759         int ret;
 760         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 761
 762         dvb_usbv2_device_power_ctrl(d, 1);
 763
 764         if (d->props->read_config) {
 765                 ret = d->props->read_config(d);
 766                 if (ret < 0)
 767                         goto err;
 768         }
 769
 770         ret = dvb_usbv2_i2c_init(d);
 771         if (ret < 0)
 772                 goto err;
 773
 774         ret = dvb_usbv2_adapter_init(d);
 775         if (ret < 0)
 776                 goto err;
 777
 778         if (d->props->init) {
 779                 ret = d->props->init(d);
 780                 if (ret < 0)
 781                         goto err;
 782         }
 783
 784         ret = dvb_usbv2_remote_init(d);
 785         if (ret < 0)
 786                 goto err;
 787
 788         dvb_usbv2_device_power_ctrl(d, 0);
 789
 790         return 0;
 791 err:
 792         dvb_usbv2_device_power_ctrl(d, 0);
 793         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 794         return ret;
 795 }
 796
 797 /*
 798  * udev, which is used for the firmware downloading, requires we cannot
 799  * block during module_init(). module_init() calls USB probe() which
 800  * is this routine. Due to that we delay actual operation using workqueue
 801  * and return always success here.
 802  */
 803 static void dvb_usbv2_init_work(struct work_struct *work)
 804 {
 805         int ret;
 806         struct dvb_usb_device *d =
 807                         container_of(work, struct dvb_usb_device, probe_work);
 808
 809         d->work_pid = current->pid;
 810         dev_dbg(&d->udev->dev, "%s: work_pid=%d\n", __func__, d->work_pid);
 811
 812         if (d->props->size_of_priv) {
 813                 d->priv = kzalloc(d->props->size_of_priv, GFP_KERNEL);
 814                 if (!d->priv) {
 815                         dev_err(&d->udev->dev, "%s: kzalloc() failed\n",
 816                                         KBUILD_MODNAME);
 817                         ret = -ENOMEM;
 818                         goto err_usb_driver_release_interface;
 819                 }
 820         }
 821
 822         if (d->props->identify_state) {
 823                 const char *name = NULL;
 824                 ret = d->props->identify_state(d, &name);
 825                 if (ret == 0) {
 826                         ;
 827                 } else if (ret == COLD) {
 828                         dev_info(&d->udev->dev, "%s: found a '%s' in cold " \
 829                                         "state\n", KBUILD_MODNAME, d->name);
 830
 831                         if (!name)
 832                                 name = d->props->firmware;
 833
 834                         ret = dvb_usbv2_download_firmware(d, name);
 835                         if (ret == 0) {
 836                                 /* device is warm, continue initialization */
 837                                 ;
 838                         } else if (ret == RECONNECTS_USB) {
 839                                 /*
 840                                  * USB core will call disconnect() and then
 841                                  * probe() as device reconnects itself from the
 842                                  * USB bus. disconnect() will release all driver
 843                                  * resources and probe() is called for 'new'
 844                                  * device. As 'new' device is warm we should
 845                                  * never go here again.
 846                                  */
 847                                 return;
 848                         } else {
 849                                 /*
 850                                  * Unexpected error. We must unregister driver
 851                                  * manually from the device, because device is
 852                                  * already register by returning from probe()
 853                                  * with success. usb_driver_release_interface()
 854                                  * finally calls disconnect() in order to free
 855                                  * resources.
 856                                  */
 857                                 goto err_usb_driver_release_interface;
 858                         }
 859                 } else {
 860                         goto err_usb_driver_release_interface;
 861                 }
 862         }
 863
 864         dev_info(&d->udev->dev, "%s: found a '%s' in warm state\n",
 865                         KBUILD_MODNAME, d->name);
 866
 867         ret = dvb_usbv2_init(d);
 868         if (ret < 0)
 869                 goto err_usb_driver_release_interface;
 870
 871         dev_info(&d->udev->dev, "%s: '%s' successfully initialized and " \
 872                         "connected\n", KBUILD_MODNAME, d->name);
 873
 874         return;
 875 err_usb_driver_release_interface:
 876         dev_info(&d->udev->dev, "%s: '%s' error while loading driver (%d)\n",
 877                         KBUILD_MODNAME, d->name, ret);
 878         usb_driver_release_interface(to_usb_driver(d->intf->dev.driver),
 879                         d->intf);
 880         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 881         return;
 882 }
 883
 884 int dvb_usbv2_probe(struct usb_interface *intf,
 885                 const struct usb_device_id *id)
 886 {
 887         int ret;
 888         struct dvb_usb_device *d;
 889         struct usb_device *udev = interface_to_usbdev(intf);
 890         struct dvb_usb_driver_info *driver_info =
 891                         (struct dvb_usb_driver_info *) id->driver_info;
 892
 893         dev_dbg(&udev->dev, "%s: bInterfaceNumber=%d\n", __func__,
 894                         intf->cur_altsetting->desc.bInterfaceNumber);
 895
 896         if (!id->driver_info) {
 897                 dev_err(&udev->dev, "%s: driver_info failed\n", KBUILD_MODNAME);
 898                 ret = -ENODEV;
 899                 goto err;
 900         }
 901
 902         d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
 903         if (!d) {
 904                 dev_err(&udev->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
 905                 ret = -ENOMEM;
 906                 goto err;
 907         }
 908
 909         d->name = driver_info->name;
 910         d->rc_map = driver_info->rc_map;
 911         d->udev = udev;
 912         d->intf = intf;
 913         d->props = driver_info->props;
 914
 915         if (d->intf->cur_altsetting->desc.bInterfaceNumber !=
 916                         d->props->bInterfaceNumber) {
 917                 ret = -ENODEV;
 918                 goto err_kfree;
 919         }
 920
 921         mutex_init(&d->usb_mutex);
 922         mutex_init(&d->i2c_mutex);
 923         INIT_WORK(&d->probe_work, dvb_usbv2_init_work);
 924         usb_set_intfdata(intf, d);
 925         ret = schedule_work(&d->probe_work);
 926         if (ret < 0) {
 927                 dev_err(&d->udev->dev, "%s: schedule_work() failed\n",
 928                                 KBUILD_MODNAME);
 929                 goto err_kfree;
 930         }
 931
 932         return 0;
 933 err_kfree:
 934         kfree(d);
 935 err:
 936         dev_dbg(&udev->dev, "%s: failed=%d\n", __func__, ret);
 937         return ret;
 938 }
 939 EXPORT_SYMBOL(dvb_usbv2_probe);
 940
 941 void dvb_usbv2_disconnect(struct usb_interface *intf)
 942 {
 943         struct dvb_usb_device *d = usb_get_intfdata(intf);
 944         const char *name = d->name;
 945         struct device dev = d->udev->dev;
 946         dev_dbg(&d->udev->dev, "%s: pid=%d work_pid=%d\n", __func__,
 947                         current->pid, d->work_pid);
 948
 949         /* ensure initialization work is finished until release resources */
 950         if (d->work_pid != current->pid)
 951                 cancel_work_sync(&d->probe_work);
 952
 953         if (d->props->exit)
 954                 d->props->exit(d);
 955
 956         dvb_usbv2_exit(d);
 957
 958         dev_info(&dev, "%s: '%s' successfully deinitialized and disconnected\n",
 959                         KBUILD_MODNAME, name);
 960 }
 961 EXPORT_SYMBOL(dvb_usbv2_disconnect);
 962
 963 int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
 964 {
 965         struct dvb_usb_device *d = usb_get_intfdata(intf);
 966         int ret = 0, i, active_fe;
 967         struct dvb_frontend *fe;
 968         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 969
 970         /* stop remote controller poll */
 971         if (d->rc_polling_active)
 972                 cancel_delayed_work_sync(&d->rc_query_work);
 973
 974         for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
 975                 active_fe = d->adapter[i].active_fe;
 976                 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
 977                         fe = d->adapter[i].fe[active_fe];
 978                         d->adapter[i].suspend_resume_active = true;
 979
 980                         if (d->props->streaming_ctrl)
 981                                 d->props->streaming_ctrl(fe, 0);
 982
 983                         /* stop usb streaming */
 984                         usb_urb_killv2(&d->adapter[i].stream);
 985
 986                         ret = dvb_frontend_suspend(fe);
 987                 }
 988         }
 989
 990         return ret;
 991 }
 992 EXPORT_SYMBOL(dvb_usbv2_suspend);
 993
 994 static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
 995 {
 996         int ret = 0, i, active_fe;
 997         struct dvb_frontend *fe;
 998         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 999
1000         for (i = 0; i < MAX_NO_OF_ADAPTER_PER_DEVICE; i++) {
1001                 active_fe = d->adapter[i].active_fe;
1002                 if (d->adapter[i].dvb_adap.priv && active_fe != -1) {
1003                         fe = d->adapter[i].fe[active_fe];
1004
1005                         ret = dvb_frontend_resume(fe);
1006
1007                         /* resume usb streaming */
1008                         usb_urb_submitv2(&d->adapter[i].stream, NULL);
1009
1010                         if (d->props->streaming_ctrl)
1011                                 d->props->streaming_ctrl(fe, 1);
1012
1013                         d->adapter[i].suspend_resume_active = false;
1014                 }
1015         }
1016
1017         /* start remote controller poll */
1018         if (d->rc_polling_active)
1019                 schedule_delayed_work(&d->rc_query_work,
1020                                 msecs_to_jiffies(d->rc.interval));
1021
1022         return ret;
1023 }
1024
1025 int dvb_usbv2_resume(struct usb_interface *intf)
1026 {
1027         struct dvb_usb_device *d = usb_get_intfdata(intf);
1028         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1029
1030         return dvb_usbv2_resume_common(d);
1031 }
1032 EXPORT_SYMBOL(dvb_usbv2_resume);
1033
1034 int dvb_usbv2_reset_resume(struct usb_interface *intf)
1035 {
1036         struct dvb_usb_device *d = usb_get_intfdata(intf);
1037         int ret;
1038         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1039
1040         dvb_usbv2_device_power_ctrl(d, 1);
1041
1042         if (d->props->init)
1043                 d->props->init(d);
1044
1045         ret = dvb_usbv2_resume_common(d);
1046
1047         dvb_usbv2_device_power_ctrl(d, 0);
1048
1049         return ret;
1050 }
1051 EXPORT_SYMBOL(dvb_usbv2_reset_resume);
1052
1053 MODULE_VERSION("2.0");
1054 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
1055 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1056 MODULE_DESCRIPTION("DVB USB common");
1057 MODULE_LICENSE("GPL");