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