drivers/media/dvb/dvb-usb/dvb_usb_init.c

   1 /*
   2  * DVB USB library - provides a generic interface for a DVB USB device driver.
   3  *
   4  * dvb-usb-init.c
   5  *
   6  * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
   7  *
   8  *      This program is free software; you can redistribute it and/or modify it
   9  *      under the terms of the GNU General Public License as published by the
  10  *      Free Software Foundation, version 2.
  11  *
  12  * see Documentation/dvb/README.dvb-usb for more information
  13  */
  14 #include "dvb_usb_common.h"
  15
  16 int dvb_usbv2_disable_rc_polling;
  17 module_param_named(disable_rc_polling, dvb_usbv2_disable_rc_polling, int, 0644);
  18 MODULE_PARM_DESC(disable_rc_polling,
  19                 "disable remote control polling (default: 0).");
  20 static int dvb_usb_force_pid_filter_usage;
  21 module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage,
  22                 int, 0444);
  23 MODULE_PARM_DESC(force_pid_filter_usage, "force all dvb-usb-devices to use a" \
  24                 " PID filter, if any (default: 0).");
  25
  26 static int dvb_usbv2_download_firmware(struct dvb_usb_device *d)
  27 {
  28         int ret;
  29         const struct firmware *fw = NULL;
  30         const char *name;
  31
  32         /* resolve firmware name */
  33         name = d->props.firmware;
  34         if (d->props.get_firmware_name) {
  35                 ret = d->props.get_firmware_name(d, &name);
  36                 if (ret < 0)
  37                         goto err;
  38         }
  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                 pr_err("%s: did not find the firmware file. (%s) " \
  48                                 "Please see linux/Documentation/dvb/ for " \
  49                                 "more details on firmware-problems. (%d)\n",
  50                                 KBUILD_MODNAME, name, ret);
  51                 goto err;
  52         }
  53
  54         pr_info("%s: downloading firmware from file '%s'\n", KBUILD_MODNAME,
  55                         name);
  56
  57         ret = d->props.download_firmware(d, fw);
  58
  59         release_firmware(fw);
  60
  61         if (ret < 0)
  62                 goto err;
  63
  64         return 0;
  65 err:
  66         pr_debug("%s: failed=%d\n", __func__, ret);
  67         return ret;
  68 }
  69
  70 static int dvb_usbv2_i2c_init(struct dvb_usb_device *d)
  71 {
  72         int ret;
  73
  74         if (!d->props.i2c_algo) {
  75                 ret = 0;
  76                 goto err;
  77         }
  78
  79         strlcpy(d->i2c_adap.name, d->name, sizeof(d->i2c_adap.name));
  80         d->i2c_adap.algo = d->props.i2c_algo;
  81         d->i2c_adap.algo_data = NULL;
  82         d->i2c_adap.dev.parent = &d->udev->dev;
  83
  84         i2c_set_adapdata(&d->i2c_adap, d);
  85
  86         ret = i2c_add_adapter(&d->i2c_adap);
  87         if (ret < 0) {
  88                 pr_err("%s: i2c_add_adapter() failed\n", KBUILD_MODNAME);
  89                 goto err;
  90         }
  91
  92         d->state |= DVB_USB_STATE_I2C;
  93
  94         return 0;
  95 err:
  96         pr_debug("%s: failed=%d\n", __func__, ret);
  97         return ret;
  98 }
  99
 100 static int dvb_usbv2_i2c_exit(struct dvb_usb_device *d)
 101 {
 102         if (d->state & DVB_USB_STATE_I2C)
 103                 i2c_del_adapter(&d->i2c_adap);
 104
 105         d->state &= ~DVB_USB_STATE_I2C;
 106
 107         return 0;
 108 }
 109
 110 static int dvb_usbv2_adapter_init(struct dvb_usb_device *d)
 111 {
 112         struct dvb_usb_adapter *adap;
 113         int ret, i, adapter_count;
 114
 115         /* resolve adapter count */
 116         adapter_count = d->props.num_adapters;
 117         if (d->props.get_adapter_count) {
 118                 ret = d->props.get_adapter_count(d);
 119                 if (ret < 0)
 120                         goto err;
 121
 122                 adapter_count = ret;
 123         }
 124
 125         for (i = 0; i < adapter_count; i++) {
 126                 adap = &d->adapter[i];
 127                 adap->dev = d;
 128                 adap->id  = i;
 129
 130                 memcpy(&adap->props, &d->props.adapter[i],
 131                                 sizeof(struct dvb_usb_adapter_properties));
 132
 133                 /* speed - when running at FULL speed we need a HW PID filter */
 134                 if (d->udev->speed == USB_SPEED_FULL &&
 135                                 !(adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
 136                         pr_err("%s: this USB2.0 device cannot be run on a " \
 137                                         "USB1.1 port (it lacks a hardware " \
 138                                         "PID filter)\n", KBUILD_MODNAME);
 139                         ret = -ENODEV;
 140                         goto err;
 141                 } else if ((d->udev->speed == USB_SPEED_FULL &&
 142                                 adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
 143                                 (adap->props.caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
 144                         pr_info("%s: will use the device's hardware PID " \
 145                                         "filter (table count: %d)\n",
 146                                         KBUILD_MODNAME,
 147                                         adap->props.pid_filter_count);
 148                         adap->pid_filtering  = 1;
 149                         adap->max_feed_count = adap->props.pid_filter_count;
 150                 } else {
 151                         pr_info("%s: will pass the complete MPEG2 transport " \
 152                                         "stream to the software demuxer\n",
 153                                         KBUILD_MODNAME);
 154                         adap->pid_filtering  = 0;
 155                         adap->max_feed_count = 255;
 156                 }
 157
 158                 if (!adap->pid_filtering && dvb_usb_force_pid_filter_usage &&
 159                                 adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) {
 160                         pr_info("%s: pid filter enabled by module option\n",
 161                                         KBUILD_MODNAME);
 162                         adap->pid_filtering  = 1;
 163                         adap->max_feed_count = adap->props.pid_filter_count;
 164                 }
 165
 166                 ret = dvb_usbv2_adapter_stream_init(adap);
 167                 if (ret)
 168                         goto err;
 169
 170                 ret = dvb_usbv2_adapter_dvb_init(adap);
 171                 if (ret)
 172                         goto err;
 173
 174                 ret = dvb_usbv2_adapter_frontend_init(adap);
 175                 if (ret)
 176                         goto err;
 177
 178                 /* use exclusive FE lock if there is multiple shared FEs */
 179                 if (adap->fe[1])
 180                         adap->dvb_adap.mfe_shared = 1;
 181
 182                 d->num_adapters_initialized++;
 183                 d->state |= DVB_USB_STATE_DVB;
 184         }
 185
 186         return 0;
 187 err:
 188         pr_debug("%s: failed=%d\n", __func__, ret);
 189         return ret;
 190 }
 191
 192 static int dvb_usbv2_adapter_exit(struct dvb_usb_device *d)
 193 {
 194         int i;
 195
 196         for (i = d->num_adapters_initialized - 1; i >= 0; i--) {
 197                 dvb_usbv2_adapter_frontend_exit(&d->adapter[i]);
 198                 dvb_usbv2_adapter_dvb_exit(&d->adapter[i]);
 199                 dvb_usbv2_adapter_stream_exit(&d->adapter[i]);
 200         }
 201
 202         d->num_adapters_initialized = 0;
 203         d->state &= ~DVB_USB_STATE_DVB;
 204
 205         return 0;
 206 }
 207
 208 /* general initialization functions */
 209 static int dvb_usbv2_exit(struct dvb_usb_device *d)
 210 {
 211         pr_debug("%s: state before exiting everything: %x\n", __func__, d->state);
 212         dvb_usbv2_remote_exit(d);
 213         dvb_usbv2_adapter_exit(d);
 214         dvb_usbv2_i2c_exit(d);
 215         pr_debug("%s: state should be zero now: %x\n", __func__, d->state);
 216         d->state = DVB_USB_STATE_INIT;
 217         kfree(d->priv);
 218         kfree(d);
 219
 220         return 0;
 221 }
 222
 223 static int dvb_usbv2_init(struct dvb_usb_device *d)
 224 {
 225         int ret = 0;
 226
 227         d->state = DVB_USB_STATE_INIT;
 228
 229         /* check the capabilities and set appropriate variables */
 230         dvb_usbv2_device_power_ctrl(d, 1);
 231
 232         if (d->props.read_config) {
 233                 ret = d->props.read_config(d);
 234                 if (ret < 0)
 235                         goto err;
 236         }
 237
 238         ret = dvb_usbv2_i2c_init(d);
 239         if (ret < 0)
 240                 goto err;
 241
 242         ret = dvb_usbv2_adapter_init(d);
 243         if (ret < 0)
 244                 goto err;
 245
 246         if (d->props.init) {
 247                 ret = d->props.init(d);
 248                 if (ret < 0)
 249                         goto err;
 250         }
 251
 252         ret = dvb_usbv2_remote_init(d);
 253         if (ret < 0)
 254                 goto err;
 255
 256         dvb_usbv2_device_power_ctrl(d, 0);
 257
 258         return 0;
 259 err:
 260         dvb_usbv2_device_power_ctrl(d, 0);
 261         pr_debug("%s: failed=%d\n", __func__, ret);
 262         return ret;
 263 }
 264
 265 int dvb_usbv2_device_power_ctrl(struct dvb_usb_device *d, int onoff)
 266 {
 267         int ret;
 268
 269         if (onoff)
 270                 d->powered++;
 271         else
 272                 d->powered--;
 273
 274         if (d->powered == 0 || (onoff && d->powered == 1)) {
 275                 /* when switching from 1 to 0 or from 0 to 1 */
 276                 pr_debug("%s: power control=%d\n", __func__, onoff);
 277                 if (d->props.power_ctrl) {
 278                         ret = d->props.power_ctrl(d, onoff);
 279                         goto err;
 280                 }
 281         }
 282
 283         return 0;
 284 err:
 285         pr_debug("%s: failed=%d\n", __func__, ret);
 286         return ret;
 287 }
 288
 289 /*
 290  * udev, which is used for the firmware downloading, requires we cannot
 291  * block during module_init(). module_init() calls USB probe() which
 292  * is this routine. Due to that we delay actual operation using workqueue
 293  * and return always success here.
 294  */
 295
 296 static void dvb_usbv2_init_work(struct work_struct *work)
 297 {
 298         int ret;
 299         struct dvb_usb_device *d =
 300                         container_of(work, struct dvb_usb_device, probe_work);
 301         bool cold = false;
 302
 303         d->work_pid = current->pid;
 304
 305         pr_debug("%s: work_pid=%d\n", __func__, d->work_pid);
 306
 307         if (d->props.size_of_priv) {
 308                 d->priv = kzalloc(d->props.size_of_priv, GFP_KERNEL);
 309                 if (!d->priv) {
 310                         pr_err("%s: kzalloc() failed\n", KBUILD_MODNAME);
 311                         ret = -ENOMEM;
 312                         goto err_usb_driver_release_interface;
 313                 }
 314         }
 315
 316         if (d->props.identify_state) {
 317                 ret = d->props.identify_state(d);
 318                 if (ret == 0) {
 319                         ;
 320                 } else if (ret == COLD) {
 321                         cold = true;
 322                         ret = 0;
 323                 } else {
 324                         goto err_usb_driver_release_interface;
 325                 }
 326         }
 327
 328         if (cold) {
 329                 pr_info("%s: found a '%s' in cold state\n",
 330                                 KBUILD_MODNAME, d->name);
 331                 ret = dvb_usbv2_download_firmware(d);
 332                 if (ret == 0) {
 333                         ;
 334                 } else if (ret == RECONNECTS_USB) {
 335                         ret = 0;
 336                         goto exit_usb_driver_release_interface;
 337                 } else {
 338                         goto err_usb_driver_release_interface;
 339                 }
 340         }
 341
 342         pr_info("%s: found a '%s' in warm state\n", KBUILD_MODNAME, d->name);
 343
 344         ret = dvb_usbv2_init(d);
 345         if (ret < 0)
 346                 goto err_usb_driver_release_interface;
 347
 348         pr_info("%s: '%s' successfully initialized and connected\n",
 349                         KBUILD_MODNAME, d->name);
 350
 351         return;
 352 err_usb_driver_release_interface:
 353         pr_info("%s: '%s' error while loading driver (%d)\n", KBUILD_MODNAME,
 354                         d->name, ret);
 355 exit_usb_driver_release_interface:
 356         /* it finally calls .disconnect() which frees mem */
 357         usb_driver_release_interface(to_usb_driver(d->intf->dev.driver),
 358                         d->intf);
 359         pr_debug("%s: failed=%d\n", __func__, ret);
 360         return;
 361 }
 362
 363 int dvb_usbv2_probe(struct usb_interface *intf,
 364                 const struct usb_device_id *id)
 365 {
 366         int ret;
 367         struct dvb_usb_device *d;
 368         struct dvb_usb_driver_info *driver_info =
 369                         (struct dvb_usb_driver_info *) id->driver_info;
 370
 371         pr_debug("%s: bInterfaceNumber=%d\n", __func__,
 372                         intf->cur_altsetting->desc.bInterfaceNumber);
 373
 374         if (!id->driver_info) {
 375                 pr_err("%s: driver_info failed\n", KBUILD_MODNAME);
 376                 ret = -ENODEV;
 377                 goto err;
 378         }
 379
 380         d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
 381         if (!d) {
 382                 pr_err("%s: kzalloc() failed\n", KBUILD_MODNAME);
 383                 ret = -ENOMEM;
 384                 goto err;
 385         }
 386
 387         d->name = driver_info->name;
 388         d->rc_map = driver_info->rc_map;
 389         d->udev = interface_to_usbdev(intf);
 390         d->intf = intf;
 391         memcpy(&d->props, driver_info->props,
 392                         sizeof(struct dvb_usb_device_properties));
 393
 394         if (d->intf->cur_altsetting->desc.bInterfaceNumber !=
 395                         d->props.bInterfaceNumber) {
 396                 ret = -ENODEV;
 397                 goto err_kfree;
 398         }
 399
 400         mutex_init(&d->usb_mutex);
 401         mutex_init(&d->i2c_mutex);
 402         INIT_WORK(&d->probe_work, dvb_usbv2_init_work);
 403         usb_set_intfdata(intf, d);
 404         ret = schedule_work(&d->probe_work);
 405         if (ret < 0) {
 406                 pr_err("%s: schedule_work() failed\n", KBUILD_MODNAME);
 407                 goto err_kfree;
 408         }
 409
 410         return 0;
 411 err_kfree:
 412         kfree(d);
 413 err:
 414         pr_debug("%s: failed=%d\n", __func__, ret);
 415         return ret;
 416 }
 417 EXPORT_SYMBOL(dvb_usbv2_probe);
 418
 419 void dvb_usbv2_disconnect(struct usb_interface *intf)
 420 {
 421         struct dvb_usb_device *d = usb_get_intfdata(intf);
 422         const char *name;
 423
 424         pr_debug("%s: pid=%d work_pid=%d\n", __func__, current->pid,
 425                         d->work_pid);
 426
 427         /* ensure initialization work is finished until release resources */
 428         if (d->work_pid != current->pid)
 429                 cancel_work_sync(&d->probe_work);
 430
 431         if (d->props.disconnect)
 432                 d->props.disconnect(d);
 433
 434         name = d->name;
 435         dvb_usbv2_exit(d);
 436
 437         pr_info("%s: '%s' successfully deinitialized and disconnected\n",
 438                         KBUILD_MODNAME, name);
 439 }
 440 EXPORT_SYMBOL(dvb_usbv2_disconnect);
 441
 442 int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
 443 {
 444         struct dvb_usb_device *d = usb_get_intfdata(intf);
 445         int i;
 446
 447         pr_debug("%s:\n", __func__);
 448
 449         /* stop remote controller poll */
 450         if (d->rc.query && !d->rc.bulk_mode)
 451                 cancel_delayed_work_sync(&d->rc_query_work);
 452
 453         /* stop streaming */
 454         for (i = d->num_adapters_initialized - 1; i >= 0; i--) {
 455                 if (d->adapter[i].active_fe != -1)
 456                         usb_urb_killv2(&d->adapter[i].stream);
 457         }
 458
 459         return 0;
 460 }
 461 EXPORT_SYMBOL(dvb_usbv2_suspend);
 462
 463 int dvb_usbv2_resume(struct usb_interface *intf)
 464 {
 465         struct dvb_usb_device *d = usb_get_intfdata(intf);
 466         int i;
 467
 468         pr_debug("%s:\n", __func__);
 469
 470         /* start streaming */
 471         for (i = 0; i < d->num_adapters_initialized; i++) {
 472                 if (d->adapter[i].active_fe != -1)
 473                         usb_urb_submitv2(&d->adapter[i].stream, NULL);
 474         }
 475
 476         /* start remote controller poll */
 477         if (d->rc.query && !d->rc.bulk_mode)
 478                 schedule_delayed_work(&d->rc_query_work,
 479                                 msecs_to_jiffies(d->rc.interval));
 480
 481         return 0;
 482 }
 483 EXPORT_SYMBOL(dvb_usbv2_resume);
 484
 485 MODULE_VERSION("1.0");
 486 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
 487 MODULE_DESCRIPTION("A library module containing commonly used USB and DVB function USB DVB devices");
 488 MODULE_LICENSE("GPL");