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