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

   1 /*
   2  *  Driver for the Auvitek USB bridge
   3  *
   4  *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "au0828.h"
  23
  24 #include <linux/module.h>
  25 #include <linux/slab.h>
  26 #include <linux/init.h>
  27 #include <linux/device.h>
  28 #include <media/v4l2-common.h>
  29 #include <media/tuner.h>
  30
  31 #include "au8522.h"
  32 #include "xc5000.h"
  33 #include "mxl5007t.h"
  34 #include "tda18271.h"
  35
  36 static int preallocate_big_buffers;
  37 module_param_named(preallocate_big_buffers, preallocate_big_buffers, int, 0644);
  38 MODULE_PARM_DESC(preallocate_big_buffers, "Preallocate the larger transfer buffers at module load time");
  39
  40 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  41
  42 #define _AU0828_BULKPIPE 0x83
  43 #define _BULKPIPESIZE 0xe522
  44
  45 static u8 hauppauge_hvr950q_led_states[] = {
  46         0x00, /* off */
  47         0x02, /* yellow */
  48         0x04, /* green */
  49 };
  50
  51 static struct au8522_led_config hauppauge_hvr950q_led_cfg = {
  52         .gpio_output = 0x00e0,
  53         .gpio_output_enable  = 0x6006,
  54         .gpio_output_disable = 0x0660,
  55
  56         .gpio_leds = 0x00e2,
  57         .led_states  = hauppauge_hvr950q_led_states,
  58         .num_led_states = sizeof(hauppauge_hvr950q_led_states),
  59
  60         .vsb8_strong   = 20 /* dB */ * 10,
  61         .qam64_strong  = 25 /* dB */ * 10,
  62         .qam256_strong = 32 /* dB */ * 10,
  63 };
  64
  65 static struct au8522_config hauppauge_hvr950q_config = {
  66         .demod_address = 0x8e >> 1,
  67         .status_mode   = AU8522_DEMODLOCKING,
  68         .qam_if        = AU8522_IF_6MHZ,
  69         .vsb_if        = AU8522_IF_6MHZ,
  70         .led_cfg       = &hauppauge_hvr950q_led_cfg,
  71 };
  72
  73 static struct au8522_config fusionhdtv7usb_config = {
  74         .demod_address = 0x8e >> 1,
  75         .status_mode   = AU8522_DEMODLOCKING,
  76         .qam_if        = AU8522_IF_6MHZ,
  77         .vsb_if        = AU8522_IF_6MHZ,
  78 };
  79
  80 static struct au8522_config hauppauge_woodbury_config = {
  81         .demod_address = 0x8e >> 1,
  82         .status_mode   = AU8522_DEMODLOCKING,
  83         .qam_if        = AU8522_IF_4MHZ,
  84         .vsb_if        = AU8522_IF_3_25MHZ,
  85 };
  86
  87 static struct xc5000_config hauppauge_xc5000a_config = {
  88         .i2c_address      = 0x61,
  89         .if_khz           = 6000,
  90         .chip_id          = XC5000A,
  91 };
  92
  93 static struct xc5000_config hauppauge_xc5000c_config = {
  94         .i2c_address      = 0x61,
  95         .if_khz           = 6000,
  96         .chip_id          = XC5000C,
  97 };
  98
  99 static struct mxl5007t_config mxl5007t_hvr950q_config = {
 100         .xtal_freq_hz = MxL_XTAL_24_MHZ,
 101         .if_freq_hz = MxL_IF_6_MHZ,
 102 };
 103
 104 static struct tda18271_config hauppauge_woodbury_tunerconfig = {
 105         .gate    = TDA18271_GATE_DIGITAL,
 106 };
 107
 108 static void au0828_restart_dvb_streaming(struct work_struct *work);
 109
 110 /*-------------------------------------------------------------------*/
 111 static void urb_completion(struct urb *purb)
 112 {
 113         struct au0828_dev *dev = purb->context;
 114         int ptype = usb_pipetype(purb->pipe);
 115         unsigned char *ptr;
 116
 117         dprintk(2, "%s: %d\n", __func__, purb->actual_length);
 118
 119         if (!dev) {
 120                 dprintk(2, "%s: no dev!\n", __func__);
 121                 return;
 122         }
 123
 124         if (dev->urb_streaming == 0) {
 125                 dprintk(2, "%s: not streaming!\n", __func__);
 126                 return;
 127         }
 128
 129         if (ptype != PIPE_BULK) {
 130                 pr_err("%s: Unsupported URB type %d\n",
 131                        __func__, ptype);
 132                 return;
 133         }
 134
 135         /* See if the stream is corrupted (to work around a hardware
 136            bug where the stream gets misaligned */
 137         ptr = purb->transfer_buffer;
 138         if (purb->actual_length > 0 && ptr[0] != 0x47) {
 139                 dprintk(1, "Need to restart streaming %02x len=%d!\n",
 140                         ptr[0], purb->actual_length);
 141                 schedule_work(&dev->restart_streaming);
 142                 return;
 143         }
 144
 145         /* Feed the transport payload into the kernel demux */
 146         dvb_dmx_swfilter_packets(&dev->dvb.demux,
 147                 purb->transfer_buffer, purb->actual_length / 188);
 148
 149         /* Clean the buffer before we requeue */
 150         memset(purb->transfer_buffer, 0, URB_BUFSIZE);
 151
 152         /* Requeue URB */
 153         usb_submit_urb(purb, GFP_ATOMIC);
 154 }
 155
 156 static int stop_urb_transfer(struct au0828_dev *dev)
 157 {
 158         int i;
 159
 160         dprintk(2, "%s()\n", __func__);
 161
 162         dev->urb_streaming = 0;
 163         for (i = 0; i < URB_COUNT; i++) {
 164                 if (dev->urbs[i]) {
 165                         usb_kill_urb(dev->urbs[i]);
 166                         if (!preallocate_big_buffers)
 167                                 kfree(dev->urbs[i]->transfer_buffer);
 168
 169                         usb_free_urb(dev->urbs[i]);
 170                 }
 171         }
 172
 173         return 0;
 174 }
 175
 176 static int start_urb_transfer(struct au0828_dev *dev)
 177 {
 178         struct urb *purb;
 179         int i, ret = -ENOMEM;
 180
 181         dprintk(2, "%s()\n", __func__);
 182
 183         if (dev->urb_streaming) {
 184                 dprintk(2, "%s: bulk xfer already running!\n", __func__);
 185                 return 0;
 186         }
 187
 188         for (i = 0; i < URB_COUNT; i++) {
 189
 190                 dev->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
 191                 if (!dev->urbs[i])
 192                         goto err;
 193
 194                 purb = dev->urbs[i];
 195
 196                 if (preallocate_big_buffers)
 197                         purb->transfer_buffer = dev->dig_transfer_buffer[i];
 198                 else
 199                         purb->transfer_buffer = kzalloc(URB_BUFSIZE,
 200                                         GFP_KERNEL);
 201
 202                 if (!purb->transfer_buffer) {
 203                         usb_free_urb(purb);
 204                         dev->urbs[i] = NULL;
 205                         pr_err("%s: failed big buffer allocation, err = %d\n",
 206                                __func__, ret);
 207                         goto err;
 208                 }
 209
 210                 purb->status = -EINPROGRESS;
 211                 usb_fill_bulk_urb(purb,
 212                                   dev->usbdev,
 213                                   usb_rcvbulkpipe(dev->usbdev,
 214                                         _AU0828_BULKPIPE),
 215                                   purb->transfer_buffer,
 216                                   URB_BUFSIZE,
 217                                   urb_completion,
 218                                   dev);
 219
 220         }
 221
 222         for (i = 0; i < URB_COUNT; i++) {
 223                 ret = usb_submit_urb(dev->urbs[i], GFP_ATOMIC);
 224                 if (ret != 0) {
 225                         stop_urb_transfer(dev);
 226                         pr_err("%s: failed urb submission, err = %d\n",
 227                                __func__, ret);
 228                         return ret;
 229                 }
 230         }
 231
 232         dev->urb_streaming = 1;
 233         ret = 0;
 234
 235 err:
 236         return ret;
 237 }
 238
 239 static void au0828_start_transport(struct au0828_dev *dev)
 240 {
 241         au0828_write(dev, 0x608, 0x90);
 242         au0828_write(dev, 0x609, 0x72);
 243         au0828_write(dev, 0x60a, 0x71);
 244         au0828_write(dev, 0x60b, 0x01);
 245
 246 }
 247
 248 static void au0828_stop_transport(struct au0828_dev *dev, int full_stop)
 249 {
 250         if (full_stop) {
 251                 au0828_write(dev, 0x608, 0x00);
 252                 au0828_write(dev, 0x609, 0x00);
 253                 au0828_write(dev, 0x60a, 0x00);
 254         }
 255         au0828_write(dev, 0x60b, 0x00);
 256 }
 257
 258 static int au0828_dvb_start_feed(struct dvb_demux_feed *feed)
 259 {
 260         struct dvb_demux *demux = feed->demux;
 261         struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
 262         struct au0828_dvb *dvb = &dev->dvb;
 263         int ret = 0;
 264
 265         dprintk(1, "%s()\n", __func__);
 266
 267         if (!demux->dmx.frontend)
 268                 return -EINVAL;
 269
 270         if (dvb->frontend) {
 271                 mutex_lock(&dvb->lock);
 272                 dvb->start_count++;
 273                 dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
 274                         dvb->start_count, dvb->stop_count);
 275                 if (dvb->feeding++ == 0) {
 276                         /* Start transport */
 277                         au0828_start_transport(dev);
 278                         ret = start_urb_transfer(dev);
 279                         if (ret < 0) {
 280                                 au0828_stop_transport(dev, 0);
 281                                 dvb->feeding--; /* We ran out of memory... */
 282                         }
 283                 }
 284                 mutex_unlock(&dvb->lock);
 285         }
 286
 287         return ret;
 288 }
 289
 290 static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
 291 {
 292         struct dvb_demux *demux = feed->demux;
 293         struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
 294         struct au0828_dvb *dvb = &dev->dvb;
 295         int ret = 0;
 296
 297         dprintk(1, "%s()\n", __func__);
 298
 299         if (dvb->frontend) {
 300                 cancel_work_sync(&dev->restart_streaming);
 301
 302                 mutex_lock(&dvb->lock);
 303                 dvb->stop_count++;
 304                 dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
 305                         dvb->start_count, dvb->stop_count);
 306                 if (dvb->feeding > 0) {
 307                         dvb->feeding--;
 308                         if (dvb->feeding == 0) {
 309                                 /* Stop transport */
 310                                 ret = stop_urb_transfer(dev);
 311                                 au0828_stop_transport(dev, 0);
 312                         }
 313                 }
 314                 mutex_unlock(&dvb->lock);
 315         }
 316
 317         return ret;
 318 }
 319
 320 static void au0828_restart_dvb_streaming(struct work_struct *work)
 321 {
 322         struct au0828_dev *dev = container_of(work, struct au0828_dev,
 323                                               restart_streaming);
 324         struct au0828_dvb *dvb = &dev->dvb;
 325
 326         if (dev->urb_streaming == 0)
 327                 return;
 328
 329         dprintk(1, "Restarting streaming...!\n");
 330
 331         mutex_lock(&dvb->lock);
 332
 333         /* Stop transport */
 334         stop_urb_transfer(dev);
 335         au0828_stop_transport(dev, 1);
 336
 337         /* Start transport */
 338         au0828_start_transport(dev);
 339         start_urb_transfer(dev);
 340
 341         mutex_unlock(&dvb->lock);
 342 }
 343
 344 static int au0828_set_frontend(struct dvb_frontend *fe)
 345 {
 346         struct au0828_dev *dev = fe->dvb->priv;
 347         struct au0828_dvb *dvb = &dev->dvb;
 348         int ret, was_streaming;
 349
 350         mutex_lock(&dvb->lock);
 351         was_streaming = dev->urb_streaming;
 352         if (was_streaming) {
 353                 au0828_stop_transport(dev, 1);
 354
 355                 /*
 356                  * We can't hold a mutex here, as the restart_streaming
 357                  * kthread may also hold it.
 358                  */
 359                 mutex_unlock(&dvb->lock);
 360                 cancel_work_sync(&dev->restart_streaming);
 361                 mutex_lock(&dvb->lock);
 362
 363                 stop_urb_transfer(dev);
 364         }
 365         mutex_unlock(&dvb->lock);
 366
 367         ret = dvb->set_frontend(fe);
 368
 369         if (was_streaming) {
 370                 mutex_lock(&dvb->lock);
 371                 au0828_start_transport(dev);
 372                 start_urb_transfer(dev);
 373                 mutex_unlock(&dvb->lock);
 374         }
 375
 376         return ret;
 377 }
 378
 379 static int dvb_register(struct au0828_dev *dev)
 380 {
 381         struct au0828_dvb *dvb = &dev->dvb;
 382         int result;
 383
 384         dprintk(1, "%s()\n", __func__);
 385
 386         if (preallocate_big_buffers) {
 387                 int i;
 388                 for (i = 0; i < URB_COUNT; i++) {
 389                         dev->dig_transfer_buffer[i] = kzalloc(URB_BUFSIZE,
 390                                         GFP_KERNEL);
 391
 392                         if (!dev->dig_transfer_buffer[i]) {
 393                                 result = -ENOMEM;
 394
 395                                 pr_err("failed buffer allocation (errno = %d)\n",
 396                                        result);
 397                                 goto fail_adapter;
 398                         }
 399                 }
 400         }
 401
 402         INIT_WORK(&dev->restart_streaming, au0828_restart_dvb_streaming);
 403
 404         /* register adapter */
 405         result = dvb_register_adapter(&dvb->adapter,
 406                                       KBUILD_MODNAME, THIS_MODULE,
 407                                       &dev->usbdev->dev, adapter_nr);
 408         if (result < 0) {
 409                 pr_err("dvb_register_adapter failed (errno = %d)\n",
 410                        result);
 411                 goto fail_adapter;
 412         }
 413         dvb->adapter.priv = dev;
 414
 415         /* register frontend */
 416         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 417         if (result < 0) {
 418                 pr_err("dvb_register_frontend failed (errno = %d)\n",
 419                        result);
 420                 goto fail_frontend;
 421         }
 422
 423         /* Hook dvb frontend */
 424         dvb->set_frontend = dvb->frontend->ops.set_frontend;
 425         dvb->frontend->ops.set_frontend = au0828_set_frontend;
 426
 427         /* register demux stuff */
 428         dvb->demux.dmx.capabilities =
 429                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 430                 DMX_MEMORY_BASED_FILTERING;
 431         dvb->demux.priv       = dev;
 432         dvb->demux.filternum  = 256;
 433         dvb->demux.feednum    = 256;
 434         dvb->demux.start_feed = au0828_dvb_start_feed;
 435         dvb->demux.stop_feed  = au0828_dvb_stop_feed;
 436         result = dvb_dmx_init(&dvb->demux);
 437         if (result < 0) {
 438                 pr_err("dvb_dmx_init failed (errno = %d)\n", result);
 439                 goto fail_dmx;
 440         }
 441
 442         dvb->dmxdev.filternum    = 256;
 443         dvb->dmxdev.demux        = &dvb->demux.dmx;
 444         dvb->dmxdev.capabilities = 0;
 445         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 446         if (result < 0) {
 447                 pr_err("dvb_dmxdev_init failed (errno = %d)\n", result);
 448                 goto fail_dmxdev;
 449         }
 450
 451         dvb->fe_hw.source = DMX_FRONTEND_0;
 452         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 453         if (result < 0) {
 454                 pr_err("add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 455                        result);
 456                 goto fail_fe_hw;
 457         }
 458
 459         dvb->fe_mem.source = DMX_MEMORY_FE;
 460         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 461         if (result < 0) {
 462                 pr_err("add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 463                        result);
 464                 goto fail_fe_mem;
 465         }
 466
 467         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 468         if (result < 0) {
 469                 pr_err("connect_frontend failed (errno = %d)\n", result);
 470                 goto fail_fe_conn;
 471         }
 472
 473         /* register network adapter */
 474         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 475
 476         dvb->start_count = 0;
 477         dvb->stop_count = 0;
 478         return 0;
 479
 480 fail_fe_conn:
 481         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 482 fail_fe_mem:
 483         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 484 fail_fe_hw:
 485         dvb_dmxdev_release(&dvb->dmxdev);
 486 fail_dmxdev:
 487         dvb_dmx_release(&dvb->demux);
 488 fail_dmx:
 489         dvb_unregister_frontend(dvb->frontend);
 490 fail_frontend:
 491         dvb_frontend_detach(dvb->frontend);
 492         dvb_unregister_adapter(&dvb->adapter);
 493 fail_adapter:
 494
 495         if (preallocate_big_buffers) {
 496                 int i;
 497                 for (i = 0; i < URB_COUNT; i++)
 498                         kfree(dev->dig_transfer_buffer[i]);
 499         }
 500
 501         return result;
 502 }
 503
 504 void au0828_dvb_unregister(struct au0828_dev *dev)
 505 {
 506         struct au0828_dvb *dvb = &dev->dvb;
 507
 508         dprintk(1, "%s()\n", __func__);
 509
 510         if (dvb->frontend == NULL)
 511                 return;
 512
 513         cancel_work_sync(&dev->restart_streaming);
 514
 515         dvb_net_release(&dvb->net);
 516         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 517         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 518         dvb_dmxdev_release(&dvb->dmxdev);
 519         dvb_dmx_release(&dvb->demux);
 520         dvb_unregister_frontend(dvb->frontend);
 521         dvb_frontend_detach(dvb->frontend);
 522         dvb_unregister_adapter(&dvb->adapter);
 523
 524         if (preallocate_big_buffers) {
 525                 int i;
 526                 for (i = 0; i < URB_COUNT; i++)
 527                         kfree(dev->dig_transfer_buffer[i]);
 528         }
 529         dvb->frontend = NULL;
 530 }
 531
 532 /* All the DVB attach calls go here, this function get's modified
 533  * for each new card. No other function in this file needs
 534  * to change.
 535  */
 536 int au0828_dvb_register(struct au0828_dev *dev)
 537 {
 538         struct au0828_dvb *dvb = &dev->dvb;
 539         int ret;
 540
 541         dprintk(1, "%s()\n", __func__);
 542
 543         /* init frontend */
 544         switch (dev->boardnr) {
 545         case AU0828_BOARD_HAUPPAUGE_HVR850:
 546         case AU0828_BOARD_HAUPPAUGE_HVR950Q:
 547                 dvb->frontend = dvb_attach(au8522_attach,
 548                                 &hauppauge_hvr950q_config,
 549                                 &dev->i2c_adap);
 550                 if (dvb->frontend != NULL)
 551                         switch (dev->board.tuner_type) {
 552                         default:
 553                         case TUNER_XC5000:
 554                                 dvb_attach(xc5000_attach, dvb->frontend,
 555                                            &dev->i2c_adap,
 556                                            &hauppauge_xc5000a_config);
 557                                 break;
 558                         case TUNER_XC5000C:
 559                                 dvb_attach(xc5000_attach, dvb->frontend,
 560                                            &dev->i2c_adap,
 561                                            &hauppauge_xc5000c_config);
 562                                 break;
 563                         }
 564                 break;
 565         case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
 566                 dvb->frontend = dvb_attach(au8522_attach,
 567                                 &hauppauge_hvr950q_config,
 568                                 &dev->i2c_adap);
 569                 if (dvb->frontend != NULL)
 570                         dvb_attach(mxl5007t_attach, dvb->frontend,
 571                                    &dev->i2c_adap, 0x60,
 572                                    &mxl5007t_hvr950q_config);
 573                 break;
 574         case AU0828_BOARD_HAUPPAUGE_WOODBURY:
 575                 dvb->frontend = dvb_attach(au8522_attach,
 576                                 &hauppauge_woodbury_config,
 577                                 &dev->i2c_adap);
 578                 if (dvb->frontend != NULL)
 579                         dvb_attach(tda18271_attach, dvb->frontend,
 580                                    0x60, &dev->i2c_adap,
 581                                    &hauppauge_woodbury_tunerconfig);
 582                 break;
 583         case AU0828_BOARD_DVICO_FUSIONHDTV7:
 584                 dvb->frontend = dvb_attach(au8522_attach,
 585                                 &fusionhdtv7usb_config,
 586                                 &dev->i2c_adap);
 587                 if (dvb->frontend != NULL) {
 588                         dvb_attach(xc5000_attach, dvb->frontend,
 589                                 &dev->i2c_adap,
 590                                 &hauppauge_xc5000a_config);
 591                 }
 592                 break;
 593         default:
 594                 pr_warn("The frontend of your DVB/ATSC card isn't supported yet\n");
 595                 break;
 596         }
 597         if (NULL == dvb->frontend) {
 598                 pr_err("%s() Frontend initialization failed\n",
 599                        __func__);
 600                 return -1;
 601         }
 602         /* define general-purpose callback pointer */
 603         dvb->frontend->callback = au0828_tuner_callback;
 604
 605         /* register everything */
 606         ret = dvb_register(dev);
 607         if (ret < 0) {
 608                 if (dvb->frontend->ops.release)
 609                         dvb->frontend->ops.release(dvb->frontend);
 610                 dvb->frontend = NULL;
 611                 return ret;
 612         }
 613
 614         return 0;
 615 }
 616
 617 void au0828_dvb_suspend(struct au0828_dev *dev)
 618 {
 619         struct au0828_dvb *dvb = &dev->dvb;
 620
 621         if (dvb->frontend && dev->urb_streaming) {
 622                 pr_info("stopping DVB\n");
 623
 624                 cancel_work_sync(&dev->restart_streaming);
 625
 626                 /* Stop transport */
 627                 mutex_lock(&dvb->lock);
 628                 stop_urb_transfer(dev);
 629                 au0828_stop_transport(dev, 1);
 630                 mutex_unlock(&dvb->lock);
 631         }
 632 }
 633
 634 void au0828_dvb_resume(struct au0828_dev *dev)
 635 {
 636         struct au0828_dvb *dvb = &dev->dvb;
 637
 638         if (dvb->frontend && dev->urb_streaming) {
 639                 pr_info("resuming DVB\n");
 640
 641                 au0828_set_frontend(dvb->frontend);
 642
 643                 /* Start transport */
 644                 mutex_lock(&dvb->lock);
 645                 au0828_start_transport(dev);
 646                 start_urb_transfer(dev);
 647                 mutex_unlock(&dvb->lock);
 648         }
 649 }