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

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