usb/pvrusb2/pvrusb2-dvb.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  pvrusb2-dvb.c - linux-dvb api interface to the pvrusb2 driver.
0004  *
0005  *  Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
0006  */
0007
0008 #include <linux/kthread.h>
0009 #include <linux/freezer.h>
0010 #include <linux/slab.h>
0011 #include <linux/mm.h>
0012 #include <media/dvbdev.h>
0013 #include "pvrusb2-debug.h"
0014 #include "pvrusb2-hdw-internal.h"
0015 #include "pvrusb2-hdw.h"
0016 #include "pvrusb2-io.h"
0017 #include "pvrusb2-dvb.h"
0018
0019 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0020
0021 static int pvr2_dvb_feed_func(struct pvr2_dvb_adapter *adap)
0022 {
0023     int ret;
0024     unsigned int count;
0025     struct pvr2_buffer *bp;
0026     struct pvr2_stream *stream;
0027
0028     pvr2_trace(PVR2_TRACE_DVB_FEED, "dvb feed thread started");
0029     set_freezable();
0030
0031     stream = adap->channel.stream->stream;
0032
0033     for (;;) {
0034         if (kthread_should_stop()) break;
0035
0036         /* Not sure about this... */
0037         try_to_freeze();
0038
0039         bp = pvr2_stream_get_ready_buffer(stream);
0040         if (bp != NULL) {
0041             count = pvr2_buffer_get_count(bp);
0042             if (count) {
0043                 dvb_dmx_swfilter(
0044                     &adap->demux,
0045                     adap->buffer_storage[
0046                         pvr2_buffer_get_id(bp)],
0047                     count);
0048             } else {
0049                 ret = pvr2_buffer_get_status(bp);
0050                 if (ret < 0) break;
0051             }
0052             ret = pvr2_buffer_queue(bp);
0053             if (ret < 0) break;
0054
0055             /* Since we know we did something to a buffer,
0056                just go back and try again.  No point in
0057                blocking unless we really ran out of
0058                buffers to process. */
0059             continue;
0060         }
0061
0062
0063         /* Wait until more buffers become available or we're
0064            told not to wait any longer. */
0065         ret = wait_event_interruptible(
0066             adap->buffer_wait_data,
0067             (pvr2_stream_get_ready_count(stream) > 0) ||
0068             kthread_should_stop());
0069         if (ret < 0) break;
0070     }
0071
0072     /* If we get here and ret is < 0, then an error has occurred.
0073        Probably would be a good idea to communicate that to DVB core... */
0074
0075     pvr2_trace(PVR2_TRACE_DVB_FEED, "dvb feed thread stopped");
0076
0077     return 0;
0078 }
0079
0080 static int pvr2_dvb_feed_thread(void *data)
0081 {
0082     int stat = pvr2_dvb_feed_func(data);
0083     /* from videobuf-dvb.c: */
0084     while (!kthread_should_stop()) {
0085         set_current_state(TASK_INTERRUPTIBLE);
0086         schedule();
0087     }
0088     return stat;
0089 }
0090
0091 static void pvr2_dvb_notify(struct pvr2_dvb_adapter *adap)
0092 {
0093     wake_up(&adap->buffer_wait_data);
0094 }
0095
0096 static void pvr2_dvb_stream_end(struct pvr2_dvb_adapter *adap)
0097 {
0098     unsigned int idx;
0099     struct pvr2_stream *stream;
0100
0101     if (adap->thread) {
0102         kthread_stop(adap->thread);
0103         adap->thread = NULL;
0104     }
0105
0106     if (adap->channel.stream) {
0107         stream = adap->channel.stream->stream;
0108     } else {
0109         stream = NULL;
0110     }
0111     if (stream) {
0112         pvr2_hdw_set_streaming(adap->channel.hdw, 0);
0113         pvr2_stream_set_callback(stream, NULL, NULL);
0114         pvr2_stream_kill(stream);
0115         pvr2_stream_set_buffer_count(stream, 0);
0116         pvr2_channel_claim_stream(&adap->channel, NULL);
0117     }
0118
0119     if (adap->stream_run) {
0120         for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) {
0121             if (!(adap->buffer_storage[idx])) continue;
0122             kfree(adap->buffer_storage[idx]);
0123             adap->buffer_storage[idx] = NULL;
0124         }
0125         adap->stream_run = 0;
0126     }
0127 }
0128
0129 static int pvr2_dvb_stream_do_start(struct pvr2_dvb_adapter *adap)
0130 {
0131     struct pvr2_context *pvr = adap->channel.mc_head;
0132     unsigned int idx;
0133     int ret;
0134     struct pvr2_buffer *bp;
0135     struct pvr2_stream *stream = NULL;
0136
0137     if (adap->stream_run) return -EIO;
0138
0139     ret = pvr2_channel_claim_stream(&adap->channel, &pvr->video_stream);
0140     /* somebody else already has the stream */
0141     if (ret < 0) return ret;
0142
0143     stream = adap->channel.stream->stream;
0144
0145     for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) {
0146         adap->buffer_storage[idx] = kmalloc(PVR2_DVB_BUFFER_SIZE,
0147                             GFP_KERNEL);
0148         if (!(adap->buffer_storage[idx])) return -ENOMEM;
0149     }
0150
0151     pvr2_stream_set_callback(pvr->video_stream.stream,
0152                  (pvr2_stream_callback) pvr2_dvb_notify, adap);
0153
0154     ret = pvr2_stream_set_buffer_count(stream, PVR2_DVB_BUFFER_COUNT);
0155     if (ret < 0) return ret;
0156
0157     for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) {
0158         bp = pvr2_stream_get_buffer(stream, idx);
0159         pvr2_buffer_set_buffer(bp,
0160                        adap->buffer_storage[idx],
0161                        PVR2_DVB_BUFFER_SIZE);
0162     }
0163
0164     ret = pvr2_hdw_set_streaming(adap->channel.hdw, 1);
0165     if (ret < 0) return ret;
0166
0167     while ((bp = pvr2_stream_get_idle_buffer(stream)) != NULL) {
0168         ret = pvr2_buffer_queue(bp);
0169         if (ret < 0) return ret;
0170     }
0171
0172     adap->thread = kthread_run(pvr2_dvb_feed_thread, adap, "pvrusb2-dvb");
0173
0174     if (IS_ERR(adap->thread)) {
0175         ret = PTR_ERR(adap->thread);
0176         adap->thread = NULL;
0177         return ret;
0178     }
0179
0180     adap->stream_run = !0;
0181
0182     return 0;
0183 }
0184
0185 static int pvr2_dvb_stream_start(struct pvr2_dvb_adapter *adap)
0186 {
0187     int ret = pvr2_dvb_stream_do_start(adap);
0188     if (ret < 0) pvr2_dvb_stream_end(adap);
0189     return ret;
0190 }
0191
0192 static int pvr2_dvb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff)
0193 {
0194     struct pvr2_dvb_adapter *adap = dvbdmxfeed->demux->priv;
0195     int ret = 0;
0196
0197     if (adap == NULL) return -ENODEV;
0198
0199     mutex_lock(&adap->lock);
0200     do {
0201         if (onoff) {
0202             if (!adap->feedcount) {
0203                 pvr2_trace(PVR2_TRACE_DVB_FEED,
0204                        "start feeding demux");
0205                 ret = pvr2_dvb_stream_start(adap);
0206                 if (ret < 0) break;
0207             }
0208             (adap->feedcount)++;
0209         } else if (adap->feedcount > 0) {
0210             (adap->feedcount)--;
0211             if (!adap->feedcount) {
0212                 pvr2_trace(PVR2_TRACE_DVB_FEED,
0213                        "stop feeding demux");
0214                 pvr2_dvb_stream_end(adap);
0215             }
0216         }
0217     } while (0);
0218     mutex_unlock(&adap->lock);
0219
0220     return ret;
0221 }
0222
0223 static int pvr2_dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
0224 {
0225     pvr2_trace(PVR2_TRACE_DVB_FEED, "start pid: 0x%04x", dvbdmxfeed->pid);
0226     return pvr2_dvb_ctrl_feed(dvbdmxfeed, 1);
0227 }
0228
0229 static int pvr2_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
0230 {
0231     pvr2_trace(PVR2_TRACE_DVB_FEED, "stop pid: 0x%04x", dvbdmxfeed->pid);
0232     return pvr2_dvb_ctrl_feed(dvbdmxfeed, 0);
0233 }
0234
0235 static int pvr2_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
0236 {
0237     struct pvr2_dvb_adapter *adap = fe->dvb->priv;
0238     return pvr2_channel_limit_inputs(
0239         &adap->channel,
0240         (acquire ? (1 << PVR2_CVAL_INPUT_DTV) : 0));
0241 }
0242
0243 static int pvr2_dvb_adapter_init(struct pvr2_dvb_adapter *adap)
0244 {
0245     int ret;
0246
0247     ret = dvb_register_adapter(&adap->dvb_adap, "pvrusb2-dvb",
0248                    THIS_MODULE/*&hdw->usb_dev->owner*/,
0249                    &adap->channel.hdw->usb_dev->dev,
0250                    adapter_nr);
0251     if (ret < 0) {
0252         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0253                "dvb_register_adapter failed: error %d", ret);
0254         goto err;
0255     }
0256     adap->dvb_adap.priv = adap;
0257
0258     adap->demux.dmx.capabilities = DMX_TS_FILTERING |
0259                        DMX_SECTION_FILTERING |
0260                        DMX_MEMORY_BASED_FILTERING;
0261     adap->demux.priv             = adap;
0262     adap->demux.filternum        = 256;
0263     adap->demux.feednum          = 256;
0264     adap->demux.start_feed       = pvr2_dvb_start_feed;
0265     adap->demux.stop_feed        = pvr2_dvb_stop_feed;
0266     adap->demux.write_to_decoder = NULL;
0267
0268     ret = dvb_dmx_init(&adap->demux);
0269     if (ret < 0) {
0270         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0271                "dvb_dmx_init failed: error %d", ret);
0272         goto err_dmx;
0273     }
0274
0275     adap->dmxdev.filternum       = adap->demux.filternum;
0276     adap->dmxdev.demux           = &adap->demux.dmx;
0277     adap->dmxdev.capabilities    = 0;
0278
0279     ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap);
0280     if (ret < 0) {
0281         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0282                "dvb_dmxdev_init failed: error %d", ret);
0283         goto err_dmx_dev;
0284     }
0285
0286     dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
0287
0288     return 0;
0289
0290 err_dmx_dev:
0291     dvb_dmx_release(&adap->demux);
0292 err_dmx:
0293     dvb_unregister_adapter(&adap->dvb_adap);
0294 err:
0295     return ret;
0296 }
0297
0298 static int pvr2_dvb_adapter_exit(struct pvr2_dvb_adapter *adap)
0299 {
0300     pvr2_trace(PVR2_TRACE_INFO, "unregistering DVB devices");
0301     dvb_net_release(&adap->dvb_net);
0302     adap->demux.dmx.close(&adap->demux.dmx);
0303     dvb_dmxdev_release(&adap->dmxdev);
0304     dvb_dmx_release(&adap->demux);
0305     dvb_unregister_adapter(&adap->dvb_adap);
0306     return 0;
0307 }
0308
0309 static int pvr2_dvb_frontend_init(struct pvr2_dvb_adapter *adap)
0310 {
0311     struct pvr2_hdw *hdw = adap->channel.hdw;
0312     const struct pvr2_dvb_props *dvb_props = hdw->hdw_desc->dvb_props;
0313     int ret = 0;
0314
0315     if (dvb_props == NULL) {
0316         pvr2_trace(PVR2_TRACE_ERROR_LEGS, "fe_props not defined!");
0317         return -EINVAL;
0318     }
0319
0320     ret = pvr2_channel_limit_inputs(
0321         &adap->channel,
0322         (1 << PVR2_CVAL_INPUT_DTV));
0323     if (ret) {
0324         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0325                "failed to grab control of dtv input (code=%d)",
0326             ret);
0327         return ret;
0328     }
0329
0330     if (dvb_props->frontend_attach == NULL) {
0331         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0332                "frontend_attach not defined!");
0333         ret = -EINVAL;
0334         goto done;
0335     }
0336
0337     if (dvb_props->frontend_attach(adap) == 0 && adap->fe[0]) {
0338         if (dvb_register_frontend(&adap->dvb_adap, adap->fe[0])) {
0339             pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0340                    "frontend registration failed!");
0341             ret = -ENODEV;
0342             goto fail_frontend0;
0343         }
0344         if (adap->fe[0]->ops.analog_ops.standby)
0345             adap->fe[0]->ops.analog_ops.standby(adap->fe[0]);
0346
0347         pvr2_trace(PVR2_TRACE_INFO, "transferring fe[%d] ts_bus_ctrl() to pvr2_dvb_bus_ctrl()",
0348                adap->fe[0]->id);
0349         adap->fe[0]->ops.ts_bus_ctrl = pvr2_dvb_bus_ctrl;
0350     } else {
0351         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0352                "no frontend was attached!");
0353         ret = -ENODEV;
0354         return ret;
0355     }
0356
0357     if (dvb_props->tuner_attach && dvb_props->tuner_attach(adap)) {
0358         pvr2_trace(PVR2_TRACE_ERROR_LEGS, "tuner attach failed");
0359         ret = -ENODEV;
0360         goto fail_tuner;
0361     }
0362
0363     if (adap->fe[1]) {
0364         adap->fe[1]->id = 1;
0365         adap->fe[1]->tuner_priv = adap->fe[0]->tuner_priv;
0366         memcpy(&adap->fe[1]->ops.tuner_ops,
0367                &adap->fe[0]->ops.tuner_ops,
0368                sizeof(struct dvb_tuner_ops));
0369
0370         if (dvb_register_frontend(&adap->dvb_adap, adap->fe[1])) {
0371             pvr2_trace(PVR2_TRACE_ERROR_LEGS,
0372                    "frontend registration failed!");
0373             ret = -ENODEV;
0374             goto fail_frontend1;
0375         }
0376         /* MFE lock */
0377         adap->dvb_adap.mfe_shared = 1;
0378
0379         if (adap->fe[1]->ops.analog_ops.standby)
0380             adap->fe[1]->ops.analog_ops.standby(adap->fe[1]);
0381
0382         pvr2_trace(PVR2_TRACE_INFO, "transferring fe[%d] ts_bus_ctrl() to pvr2_dvb_bus_ctrl()",
0383                adap->fe[1]->id);
0384         adap->fe[1]->ops.ts_bus_ctrl = pvr2_dvb_bus_ctrl;
0385     }
0386 done:
0387     pvr2_channel_limit_inputs(&adap->channel, 0);
0388     return ret;
0389
0390 fail_frontend1:
0391     dvb_frontend_detach(adap->fe[1]);
0392     adap->fe[1] = NULL;
0393 fail_tuner:
0394     dvb_unregister_frontend(adap->fe[0]);
0395 fail_frontend0:
0396     dvb_frontend_detach(adap->fe[0]);
0397     adap->fe[0] = NULL;
0398     dvb_module_release(adap->i2c_client_tuner);
0399     dvb_module_release(adap->i2c_client_demod[1]);
0400     dvb_module_release(adap->i2c_client_demod[0]);
0401
0402     return ret;
0403 }
0404
0405 static int pvr2_dvb_frontend_exit(struct pvr2_dvb_adapter *adap)
0406 {
0407     if (adap->fe[1]) {
0408         dvb_unregister_frontend(adap->fe[1]);
0409         dvb_frontend_detach(adap->fe[1]);
0410         adap->fe[1] = NULL;
0411     }
0412     if (adap->fe[0]) {
0413         dvb_unregister_frontend(adap->fe[0]);
0414         dvb_frontend_detach(adap->fe[0]);
0415         adap->fe[0] = NULL;
0416     }
0417
0418     dvb_module_release(adap->i2c_client_tuner);
0419     adap->i2c_client_tuner = NULL;
0420     dvb_module_release(adap->i2c_client_demod[1]);
0421     adap->i2c_client_demod[1] = NULL;
0422     dvb_module_release(adap->i2c_client_demod[0]);
0423     adap->i2c_client_demod[0] = NULL;
0424
0425     return 0;
0426 }
0427
0428 static void pvr2_dvb_destroy(struct pvr2_dvb_adapter *adap)
0429 {
0430     pvr2_dvb_stream_end(adap);
0431     pvr2_dvb_frontend_exit(adap);
0432     pvr2_dvb_adapter_exit(adap);
0433     pvr2_channel_done(&adap->channel);
0434     kfree(adap);
0435 }
0436
0437 static void pvr2_dvb_internal_check(struct pvr2_channel *chp)
0438 {
0439     struct pvr2_dvb_adapter *adap;
0440     adap = container_of(chp, struct pvr2_dvb_adapter, channel);
0441     if (!adap->channel.mc_head->disconnect_flag) return;
0442     pvr2_dvb_destroy(adap);
0443 }
0444
0445 struct pvr2_dvb_adapter *pvr2_dvb_create(struct pvr2_context *pvr)
0446 {
0447     int ret = 0;
0448     struct pvr2_dvb_adapter *adap;
0449     if (!pvr->hdw->hdw_desc->dvb_props) {
0450         /* Device lacks a digital interface so don't set up
0451            the DVB side of the driver either.  For now. */
0452         return NULL;
0453     }
0454     adap = kzalloc(sizeof(*adap), GFP_KERNEL);
0455     if (!adap) return adap;
0456     pvr2_channel_init(&adap->channel, pvr);
0457     adap->channel.check_func = pvr2_dvb_internal_check;
0458     init_waitqueue_head(&adap->buffer_wait_data);
0459     mutex_init(&adap->lock);
0460     ret = pvr2_dvb_adapter_init(adap);
0461     if (ret < 0) goto fail1;
0462     ret = pvr2_dvb_frontend_init(adap);
0463     if (ret < 0) goto fail2;
0464     return adap;
0465
0466 fail2:
0467     pvr2_dvb_adapter_exit(adap);
0468 fail1:
0469     pvr2_channel_done(&adap->channel);
0470     return NULL;
0471 }
0472