Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Driver for the Auvitek USB bridge
0004  *
0005  *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
0006  */
0007 
0008 #include "au0828.h"
0009 
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include <linux/init.h>
0013 #include <linux/device.h>
0014 #include <media/v4l2-common.h>
0015 #include <media/tuner.h>
0016 
0017 #include "au8522.h"
0018 #include "xc5000.h"
0019 #include "mxl5007t.h"
0020 #include "tda18271.h"
0021 
0022 static int preallocate_big_buffers;
0023 module_param_named(preallocate_big_buffers, preallocate_big_buffers, int, 0644);
0024 MODULE_PARM_DESC(preallocate_big_buffers, "Preallocate the larger transfer buffers at module load time");
0025 
0026 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0027 
0028 #define _AU0828_BULKPIPE 0x83
0029 #define _BULKPIPESIZE 0xe522
0030 
0031 static u8 hauppauge_hvr950q_led_states[] = {
0032     0x00, /* off */
0033     0x02, /* yellow */
0034     0x04, /* green */
0035 };
0036 
0037 static struct au8522_led_config hauppauge_hvr950q_led_cfg = {
0038     .gpio_output = 0x00e0,
0039     .gpio_output_enable  = 0x6006,
0040     .gpio_output_disable = 0x0660,
0041 
0042     .gpio_leds = 0x00e2,
0043     .led_states  = hauppauge_hvr950q_led_states,
0044     .num_led_states = sizeof(hauppauge_hvr950q_led_states),
0045 
0046     .vsb8_strong   = 20 /* dB */ * 10,
0047     .qam64_strong  = 25 /* dB */ * 10,
0048     .qam256_strong = 32 /* dB */ * 10,
0049 };
0050 
0051 static struct au8522_config hauppauge_hvr950q_config = {
0052     .demod_address = 0x8e >> 1,
0053     .status_mode   = AU8522_DEMODLOCKING,
0054     .qam_if        = AU8522_IF_6MHZ,
0055     .vsb_if        = AU8522_IF_6MHZ,
0056     .led_cfg       = &hauppauge_hvr950q_led_cfg,
0057 };
0058 
0059 static struct au8522_config fusionhdtv7usb_config = {
0060     .demod_address = 0x8e >> 1,
0061     .status_mode   = AU8522_DEMODLOCKING,
0062     .qam_if        = AU8522_IF_6MHZ,
0063     .vsb_if        = AU8522_IF_6MHZ,
0064 };
0065 
0066 static struct au8522_config hauppauge_woodbury_config = {
0067     .demod_address = 0x8e >> 1,
0068     .status_mode   = AU8522_DEMODLOCKING,
0069     .qam_if        = AU8522_IF_4MHZ,
0070     .vsb_if        = AU8522_IF_3_25MHZ,
0071 };
0072 
0073 static struct xc5000_config hauppauge_xc5000a_config = {
0074     .i2c_address      = 0x61,
0075     .if_khz           = 6000,
0076     .chip_id          = XC5000A,
0077     .output_amp       = 0x8f,
0078 };
0079 
0080 static struct xc5000_config hauppauge_xc5000c_config = {
0081     .i2c_address      = 0x61,
0082     .if_khz           = 6000,
0083     .chip_id          = XC5000C,
0084     .output_amp       = 0x8f,
0085 };
0086 
0087 static struct mxl5007t_config mxl5007t_hvr950q_config = {
0088     .xtal_freq_hz = MxL_XTAL_24_MHZ,
0089     .if_freq_hz = MxL_IF_6_MHZ,
0090 };
0091 
0092 static struct tda18271_config hauppauge_woodbury_tunerconfig = {
0093     .gate    = TDA18271_GATE_DIGITAL,
0094 };
0095 
0096 static void au0828_restart_dvb_streaming(struct work_struct *work);
0097 
0098 static void au0828_bulk_timeout(struct timer_list *t)
0099 {
0100     struct au0828_dev *dev = from_timer(dev, t, bulk_timeout);
0101 
0102     dprintk(1, "%s called\n", __func__);
0103     dev->bulk_timeout_running = 0;
0104     schedule_work(&dev->restart_streaming);
0105 }
0106 
0107 /*-------------------------------------------------------------------*/
0108 static void urb_completion(struct urb *purb)
0109 {
0110     struct au0828_dev *dev = purb->context;
0111     int ptype = usb_pipetype(purb->pipe);
0112     unsigned char *ptr;
0113 
0114     dprintk(2, "%s: %d\n", __func__, purb->actual_length);
0115 
0116     if (!dev) {
0117         dprintk(2, "%s: no dev!\n", __func__);
0118         return;
0119     }
0120 
0121     if (!dev->urb_streaming) {
0122         dprintk(2, "%s: not streaming!\n", __func__);
0123         return;
0124     }
0125 
0126     if (ptype != PIPE_BULK) {
0127         pr_err("%s: Unsupported URB type %d\n",
0128                __func__, ptype);
0129         return;
0130     }
0131 
0132     /* See if the stream is corrupted (to work around a hardware
0133        bug where the stream gets misaligned */
0134     ptr = purb->transfer_buffer;
0135     if (purb->actual_length > 0 && ptr[0] != 0x47) {
0136         dprintk(1, "Need to restart streaming %02x len=%d!\n",
0137             ptr[0], purb->actual_length);
0138         schedule_work(&dev->restart_streaming);
0139         return;
0140     } else if (dev->bulk_timeout_running == 1) {
0141         /* The URB handler has fired, so cancel timer which would
0142          * restart endpoint if we hadn't
0143          */
0144         dprintk(1, "%s cancelling bulk timeout\n", __func__);
0145         dev->bulk_timeout_running = 0;
0146         del_timer(&dev->bulk_timeout);
0147     }
0148 
0149     /* Feed the transport payload into the kernel demux */
0150     dvb_dmx_swfilter_packets(&dev->dvb.demux,
0151         purb->transfer_buffer, purb->actual_length / 188);
0152 
0153     /* Clean the buffer before we requeue */
0154     memset(purb->transfer_buffer, 0, URB_BUFSIZE);
0155 
0156     /* Requeue URB */
0157     usb_submit_urb(purb, GFP_ATOMIC);
0158 }
0159 
0160 static int stop_urb_transfer(struct au0828_dev *dev)
0161 {
0162     int i;
0163 
0164     dprintk(2, "%s()\n", __func__);
0165 
0166     if (!dev->urb_streaming)
0167         return 0;
0168 
0169     if (dev->bulk_timeout_running == 1) {
0170         dev->bulk_timeout_running = 0;
0171         del_timer(&dev->bulk_timeout);
0172     }
0173 
0174     dev->urb_streaming = false;
0175     for (i = 0; i < URB_COUNT; i++) {
0176         if (dev->urbs[i]) {
0177             usb_kill_urb(dev->urbs[i]);
0178             if (!preallocate_big_buffers)
0179                 kfree(dev->urbs[i]->transfer_buffer);
0180 
0181             usb_free_urb(dev->urbs[i]);
0182         }
0183     }
0184 
0185     return 0;
0186 }
0187 
0188 static int start_urb_transfer(struct au0828_dev *dev)
0189 {
0190     struct urb *purb;
0191     int i, ret;
0192 
0193     dprintk(2, "%s()\n", __func__);
0194 
0195     if (dev->urb_streaming) {
0196         dprintk(2, "%s: bulk xfer already running!\n", __func__);
0197         return 0;
0198     }
0199 
0200     for (i = 0; i < URB_COUNT; i++) {
0201 
0202         dev->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
0203         if (!dev->urbs[i])
0204             return -ENOMEM;
0205 
0206         purb = dev->urbs[i];
0207 
0208         if (preallocate_big_buffers)
0209             purb->transfer_buffer = dev->dig_transfer_buffer[i];
0210         else
0211             purb->transfer_buffer = kzalloc(URB_BUFSIZE,
0212                     GFP_KERNEL);
0213 
0214         if (!purb->transfer_buffer) {
0215             usb_free_urb(purb);
0216             dev->urbs[i] = NULL;
0217             ret = -ENOMEM;
0218             pr_err("%s: failed big buffer allocation, err = %d\n",
0219                    __func__, ret);
0220             return ret;
0221         }
0222 
0223         purb->status = -EINPROGRESS;
0224         usb_fill_bulk_urb(purb,
0225                   dev->usbdev,
0226                   usb_rcvbulkpipe(dev->usbdev,
0227                     _AU0828_BULKPIPE),
0228                   purb->transfer_buffer,
0229                   URB_BUFSIZE,
0230                   urb_completion,
0231                   dev);
0232 
0233     }
0234 
0235     for (i = 0; i < URB_COUNT; i++) {
0236         ret = usb_submit_urb(dev->urbs[i], GFP_ATOMIC);
0237         if (ret != 0) {
0238             stop_urb_transfer(dev);
0239             pr_err("%s: failed urb submission, err = %d\n",
0240                    __func__, ret);
0241             return ret;
0242         }
0243     }
0244 
0245     dev->urb_streaming = true;
0246 
0247     /* If we don't valid data within 1 second, restart stream */
0248     mod_timer(&dev->bulk_timeout, jiffies + (HZ));
0249     dev->bulk_timeout_running = 1;
0250 
0251     return 0;
0252 }
0253 
0254 static void au0828_start_transport(struct au0828_dev *dev)
0255 {
0256     au0828_write(dev, 0x608, 0x90);
0257     au0828_write(dev, 0x609, 0x72);
0258     au0828_write(dev, 0x60a, 0x71);
0259     au0828_write(dev, 0x60b, 0x01);
0260 
0261 }
0262 
0263 static void au0828_stop_transport(struct au0828_dev *dev, int full_stop)
0264 {
0265     if (full_stop) {
0266         au0828_write(dev, 0x608, 0x00);
0267         au0828_write(dev, 0x609, 0x00);
0268         au0828_write(dev, 0x60a, 0x00);
0269     }
0270     au0828_write(dev, 0x60b, 0x00);
0271 }
0272 
0273 static int au0828_dvb_start_feed(struct dvb_demux_feed *feed)
0274 {
0275     struct dvb_demux *demux = feed->demux;
0276     struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
0277     struct au0828_dvb *dvb = &dev->dvb;
0278     int ret = 0;
0279 
0280     dprintk(1, "%s()\n", __func__);
0281 
0282     if (!demux->dmx.frontend)
0283         return -EINVAL;
0284 
0285     if (dvb->frontend) {
0286         mutex_lock(&dvb->lock);
0287         dvb->start_count++;
0288         dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
0289             dvb->start_count, dvb->stop_count);
0290         if (dvb->feeding++ == 0) {
0291             /* Start transport */
0292             au0828_start_transport(dev);
0293             ret = start_urb_transfer(dev);
0294             if (ret < 0) {
0295                 au0828_stop_transport(dev, 0);
0296                 dvb->feeding--; /* We ran out of memory... */
0297             }
0298         }
0299         mutex_unlock(&dvb->lock);
0300     }
0301 
0302     return ret;
0303 }
0304 
0305 static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
0306 {
0307     struct dvb_demux *demux = feed->demux;
0308     struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
0309     struct au0828_dvb *dvb = &dev->dvb;
0310     int ret = 0;
0311 
0312     dprintk(1, "%s()\n", __func__);
0313 
0314     if (dvb->frontend) {
0315         cancel_work_sync(&dev->restart_streaming);
0316 
0317         mutex_lock(&dvb->lock);
0318         dvb->stop_count++;
0319         dprintk(1, "%s(), start_count: %d, stop_count: %d\n", __func__,
0320             dvb->start_count, dvb->stop_count);
0321         if (dvb->feeding > 0) {
0322             dvb->feeding--;
0323             if (dvb->feeding == 0) {
0324                 /* Stop transport */
0325                 ret = stop_urb_transfer(dev);
0326                 au0828_stop_transport(dev, 0);
0327             }
0328         }
0329         mutex_unlock(&dvb->lock);
0330     }
0331 
0332     return ret;
0333 }
0334 
0335 static void au0828_restart_dvb_streaming(struct work_struct *work)
0336 {
0337     struct au0828_dev *dev = container_of(work, struct au0828_dev,
0338                           restart_streaming);
0339     struct au0828_dvb *dvb = &dev->dvb;
0340 
0341     if (!dev->urb_streaming)
0342         return;
0343 
0344     dprintk(1, "Restarting streaming...!\n");
0345 
0346     mutex_lock(&dvb->lock);
0347 
0348     /* Stop transport */
0349     stop_urb_transfer(dev);
0350     au0828_stop_transport(dev, 1);
0351 
0352     /* Start transport */
0353     au0828_start_transport(dev);
0354     start_urb_transfer(dev);
0355 
0356     mutex_unlock(&dvb->lock);
0357 }
0358 
0359 static int au0828_set_frontend(struct dvb_frontend *fe)
0360 {
0361     struct au0828_dev *dev = fe->dvb->priv;
0362     struct au0828_dvb *dvb = &dev->dvb;
0363     int ret, was_streaming;
0364 
0365     mutex_lock(&dvb->lock);
0366     was_streaming = dev->urb_streaming;
0367     if (was_streaming) {
0368         au0828_stop_transport(dev, 1);
0369 
0370         /*
0371          * We can't hold a mutex here, as the restart_streaming
0372          * kthread may also hold it.
0373          */
0374         mutex_unlock(&dvb->lock);
0375         cancel_work_sync(&dev->restart_streaming);
0376         mutex_lock(&dvb->lock);
0377 
0378         stop_urb_transfer(dev);
0379     }
0380     mutex_unlock(&dvb->lock);
0381 
0382     ret = dvb->set_frontend(fe);
0383 
0384     if (was_streaming) {
0385         mutex_lock(&dvb->lock);
0386         au0828_start_transport(dev);
0387         start_urb_transfer(dev);
0388         mutex_unlock(&dvb->lock);
0389     }
0390 
0391     return ret;
0392 }
0393 
0394 static int dvb_register(struct au0828_dev *dev)
0395 {
0396     struct au0828_dvb *dvb = &dev->dvb;
0397     int result;
0398 
0399     dprintk(1, "%s()\n", __func__);
0400 
0401     if (preallocate_big_buffers) {
0402         int i;
0403         for (i = 0; i < URB_COUNT; i++) {
0404             dev->dig_transfer_buffer[i] = kzalloc(URB_BUFSIZE,
0405                     GFP_KERNEL);
0406 
0407             if (!dev->dig_transfer_buffer[i]) {
0408                 result = -ENOMEM;
0409 
0410                 pr_err("failed buffer allocation (errno = %d)\n",
0411                        result);
0412                 goto fail_adapter;
0413             }
0414         }
0415     }
0416 
0417     INIT_WORK(&dev->restart_streaming, au0828_restart_dvb_streaming);
0418 
0419     /* register adapter */
0420     result = dvb_register_adapter(&dvb->adapter,
0421                       KBUILD_MODNAME, THIS_MODULE,
0422                       &dev->usbdev->dev, adapter_nr);
0423     if (result < 0) {
0424         pr_err("dvb_register_adapter failed (errno = %d)\n",
0425                result);
0426         goto fail_adapter;
0427     }
0428 
0429 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0430     dvb->adapter.mdev = dev->media_dev;
0431 #endif
0432 
0433     dvb->adapter.priv = dev;
0434 
0435     /* register frontend */
0436     result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
0437     if (result < 0) {
0438         pr_err("dvb_register_frontend failed (errno = %d)\n",
0439                result);
0440         goto fail_frontend;
0441     }
0442 
0443     /* Hook dvb frontend */
0444     dvb->set_frontend = dvb->frontend->ops.set_frontend;
0445     dvb->frontend->ops.set_frontend = au0828_set_frontend;
0446 
0447     /* register demux stuff */
0448     dvb->demux.dmx.capabilities =
0449         DMX_TS_FILTERING | DMX_SECTION_FILTERING |
0450         DMX_MEMORY_BASED_FILTERING;
0451     dvb->demux.priv       = dev;
0452     dvb->demux.filternum  = 256;
0453     dvb->demux.feednum    = 256;
0454     dvb->demux.start_feed = au0828_dvb_start_feed;
0455     dvb->demux.stop_feed  = au0828_dvb_stop_feed;
0456     result = dvb_dmx_init(&dvb->demux);
0457     if (result < 0) {
0458         pr_err("dvb_dmx_init failed (errno = %d)\n", result);
0459         goto fail_dmx;
0460     }
0461 
0462     dvb->dmxdev.filternum    = 256;
0463     dvb->dmxdev.demux        = &dvb->demux.dmx;
0464     dvb->dmxdev.capabilities = 0;
0465     result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
0466     if (result < 0) {
0467         pr_err("dvb_dmxdev_init failed (errno = %d)\n", result);
0468         goto fail_dmxdev;
0469     }
0470 
0471     dvb->fe_hw.source = DMX_FRONTEND_0;
0472     result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0473     if (result < 0) {
0474         pr_err("add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
0475                result);
0476         goto fail_fe_hw;
0477     }
0478 
0479     dvb->fe_mem.source = DMX_MEMORY_FE;
0480     result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0481     if (result < 0) {
0482         pr_err("add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
0483                result);
0484         goto fail_fe_mem;
0485     }
0486 
0487     result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0488     if (result < 0) {
0489         pr_err("connect_frontend failed (errno = %d)\n", result);
0490         goto fail_fe_conn;
0491     }
0492 
0493     /* register network adapter */
0494     dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
0495 
0496     dvb->start_count = 0;
0497     dvb->stop_count = 0;
0498 
0499     result = dvb_create_media_graph(&dvb->adapter, false);
0500     if (result < 0)
0501         goto fail_create_graph;
0502 
0503     return 0;
0504 
0505 fail_create_graph:
0506     dvb_net_release(&dvb->net);
0507 fail_fe_conn:
0508     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0509 fail_fe_mem:
0510     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0511 fail_fe_hw:
0512     dvb_dmxdev_release(&dvb->dmxdev);
0513 fail_dmxdev:
0514     dvb_dmx_release(&dvb->demux);
0515 fail_dmx:
0516     dvb_unregister_frontend(dvb->frontend);
0517 fail_frontend:
0518     dvb_frontend_detach(dvb->frontend);
0519     dvb_unregister_adapter(&dvb->adapter);
0520 fail_adapter:
0521 
0522     if (preallocate_big_buffers) {
0523         int i;
0524         for (i = 0; i < URB_COUNT; i++)
0525             kfree(dev->dig_transfer_buffer[i]);
0526     }
0527 
0528     return result;
0529 }
0530 
0531 void au0828_dvb_unregister(struct au0828_dev *dev)
0532 {
0533     struct au0828_dvb *dvb = &dev->dvb;
0534 
0535     dprintk(1, "%s()\n", __func__);
0536 
0537     if (dvb->frontend == NULL)
0538         return;
0539 
0540     cancel_work_sync(&dev->restart_streaming);
0541 
0542     dvb_net_release(&dvb->net);
0543     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0544     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0545     dvb_dmxdev_release(&dvb->dmxdev);
0546     dvb_dmx_release(&dvb->demux);
0547     dvb_unregister_frontend(dvb->frontend);
0548     dvb_frontend_detach(dvb->frontend);
0549     dvb_unregister_adapter(&dvb->adapter);
0550 
0551     if (preallocate_big_buffers) {
0552         int i;
0553         for (i = 0; i < URB_COUNT; i++)
0554             kfree(dev->dig_transfer_buffer[i]);
0555     }
0556     dvb->frontend = NULL;
0557 }
0558 
0559 /* All the DVB attach calls go here, this function gets modified
0560  * for each new card. No other function in this file needs
0561  * to change.
0562  */
0563 int au0828_dvb_register(struct au0828_dev *dev)
0564 {
0565     struct au0828_dvb *dvb = &dev->dvb;
0566     int ret;
0567 
0568     dprintk(1, "%s()\n", __func__);
0569 
0570     /* init frontend */
0571     switch (dev->boardnr) {
0572     case AU0828_BOARD_HAUPPAUGE_HVR850:
0573     case AU0828_BOARD_HAUPPAUGE_HVR950Q:
0574         dvb->frontend = dvb_attach(au8522_attach,
0575                 &hauppauge_hvr950q_config,
0576                 &dev->i2c_adap);
0577         if (dvb->frontend != NULL)
0578             switch (dev->board.tuner_type) {
0579             default:
0580             case TUNER_XC5000:
0581                 dvb_attach(xc5000_attach, dvb->frontend,
0582                        &dev->i2c_adap,
0583                        &hauppauge_xc5000a_config);
0584                 break;
0585             case TUNER_XC5000C:
0586                 dvb_attach(xc5000_attach, dvb->frontend,
0587                        &dev->i2c_adap,
0588                        &hauppauge_xc5000c_config);
0589                 break;
0590             }
0591         break;
0592     case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
0593         dvb->frontend = dvb_attach(au8522_attach,
0594                 &hauppauge_hvr950q_config,
0595                 &dev->i2c_adap);
0596         if (dvb->frontend != NULL)
0597             dvb_attach(mxl5007t_attach, dvb->frontend,
0598                    &dev->i2c_adap, 0x60,
0599                    &mxl5007t_hvr950q_config);
0600         break;
0601     case AU0828_BOARD_HAUPPAUGE_WOODBURY:
0602         dvb->frontend = dvb_attach(au8522_attach,
0603                 &hauppauge_woodbury_config,
0604                 &dev->i2c_adap);
0605         if (dvb->frontend != NULL)
0606             dvb_attach(tda18271_attach, dvb->frontend,
0607                    0x60, &dev->i2c_adap,
0608                    &hauppauge_woodbury_tunerconfig);
0609         break;
0610     case AU0828_BOARD_DVICO_FUSIONHDTV7:
0611         dvb->frontend = dvb_attach(au8522_attach,
0612                 &fusionhdtv7usb_config,
0613                 &dev->i2c_adap);
0614         if (dvb->frontend != NULL) {
0615             dvb_attach(xc5000_attach, dvb->frontend,
0616                 &dev->i2c_adap,
0617                 &hauppauge_xc5000a_config);
0618         }
0619         break;
0620     default:
0621         pr_warn("The frontend of your DVB/ATSC card isn't supported yet\n");
0622         break;
0623     }
0624     if (NULL == dvb->frontend) {
0625         pr_err("%s() Frontend initialization failed\n",
0626                __func__);
0627         return -1;
0628     }
0629     /* define general-purpose callback pointer */
0630     dvb->frontend->callback = au0828_tuner_callback;
0631 
0632     /* register everything */
0633     ret = dvb_register(dev);
0634     if (ret < 0) {
0635         if (dvb->frontend->ops.release)
0636             dvb->frontend->ops.release(dvb->frontend);
0637         dvb->frontend = NULL;
0638         return ret;
0639     }
0640 
0641     timer_setup(&dev->bulk_timeout, au0828_bulk_timeout, 0);
0642 
0643     return 0;
0644 }
0645 
0646 void au0828_dvb_suspend(struct au0828_dev *dev)
0647 {
0648     struct au0828_dvb *dvb = &dev->dvb;
0649     int rc;
0650 
0651     if (dvb->frontend) {
0652         if (dev->urb_streaming) {
0653             cancel_work_sync(&dev->restart_streaming);
0654             /* Stop transport */
0655             mutex_lock(&dvb->lock);
0656             stop_urb_transfer(dev);
0657             au0828_stop_transport(dev, 1);
0658             mutex_unlock(&dvb->lock);
0659             dev->need_urb_start = true;
0660         }
0661         /* suspend frontend - does tuner and fe to sleep */
0662         rc = dvb_frontend_suspend(dvb->frontend);
0663         pr_info("au0828_dvb_suspend(): Suspending DVB fe %d\n", rc);
0664     }
0665 }
0666 
0667 void au0828_dvb_resume(struct au0828_dev *dev)
0668 {
0669     struct au0828_dvb *dvb = &dev->dvb;
0670     int rc;
0671 
0672     if (dvb->frontend) {
0673         /* resume frontend - does fe and tuner init */
0674         rc = dvb_frontend_resume(dvb->frontend);
0675         pr_info("au0828_dvb_resume(): Resuming DVB fe %d\n", rc);
0676         if (dev->need_urb_start) {
0677             /* Start transport */
0678             mutex_lock(&dvb->lock);
0679             au0828_start_transport(dev);
0680             start_urb_transfer(dev);
0681             mutex_unlock(&dvb->lock);
0682         }
0683     }
0684 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!