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