usb/dvb-usb/dvb-usb-dvb.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* dvb-usb-dvb.c is part of the DVB USB library.
0003  *
0004  * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.de)
0005  * see dvb-usb-init.c for copyright information.
0006  *
0007  * This file contains functions for initializing and handling the
0008  * linux-dvb API.
0009  */
0010 #include "dvb-usb-common.h"
0011 #include <media/media-device.h>
0012
0013 /* does the complete input transfer handling */
0014 static int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff)
0015 {
0016     struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
0017     int newfeedcount, ret;
0018
0019     if (adap == NULL)
0020         return -ENODEV;
0021
0022     if ((adap->active_fe < 0) ||
0023         (adap->active_fe >= adap->num_frontends_initialized)) {
0024         return -EINVAL;
0025     }
0026
0027     newfeedcount = adap->feedcount + (onoff ? 1 : -1);
0028
0029     /* stop feed before setting a new pid if there will be no pid anymore */
0030     if (newfeedcount == 0) {
0031         deb_ts("stop feeding\n");
0032         usb_urb_kill(&adap->fe_adap[adap->active_fe].stream);
0033
0034         if (adap->props.fe[adap->active_fe].streaming_ctrl != NULL) {
0035             ret = adap->props.fe[adap->active_fe].streaming_ctrl(adap, 0);
0036             if (ret < 0) {
0037                 err("error while stopping stream.");
0038                 return ret;
0039             }
0040         }
0041     }
0042
0043     adap->feedcount = newfeedcount;
0044
0045     /* activate the pid on the device specific pid_filter */
0046     deb_ts("setting pid (%s): %5d %04x at index %d '%s'\n",
0047         adap->fe_adap[adap->active_fe].pid_filtering ?
0048         "yes" : "no", dvbdmxfeed->pid, dvbdmxfeed->pid,
0049         dvbdmxfeed->index, onoff ? "on" : "off");
0050     if (adap->props.fe[adap->active_fe].caps & DVB_USB_ADAP_HAS_PID_FILTER &&
0051         adap->fe_adap[adap->active_fe].pid_filtering &&
0052         adap->props.fe[adap->active_fe].pid_filter != NULL)
0053         adap->props.fe[adap->active_fe].pid_filter(adap, dvbdmxfeed->index, dvbdmxfeed->pid, onoff);
0054
0055     /* start the feed if this was the first feed and there is still a feed
0056      * for reception.
0057      */
0058     if (adap->feedcount == onoff && adap->feedcount > 0) {
0059         deb_ts("controlling pid parser\n");
0060         if (adap->props.fe[adap->active_fe].caps & DVB_USB_ADAP_HAS_PID_FILTER &&
0061             adap->props.fe[adap->active_fe].caps &
0062             DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF &&
0063             adap->props.fe[adap->active_fe].pid_filter_ctrl != NULL) {
0064             ret = adap->props.fe[adap->active_fe].pid_filter_ctrl(adap,
0065                 adap->fe_adap[adap->active_fe].pid_filtering);
0066             if (ret < 0) {
0067                 err("could not handle pid_parser");
0068                 return ret;
0069             }
0070         }
0071         deb_ts("start feeding\n");
0072         if (adap->props.fe[adap->active_fe].streaming_ctrl != NULL) {
0073             ret = adap->props.fe[adap->active_fe].streaming_ctrl(adap, 1);
0074             if (ret < 0) {
0075                 err("error while enabling fifo.");
0076                 return ret;
0077             }
0078         }
0079
0080         deb_ts("submitting all URBs\n");
0081         usb_urb_submit(&adap->fe_adap[adap->active_fe].stream);
0082     }
0083     return 0;
0084 }
0085
0086 static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
0087 {
0088     deb_ts("start pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid,
0089            dvbdmxfeed->type);
0090     return dvb_usb_ctrl_feed(dvbdmxfeed, 1);
0091 }
0092
0093 static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
0094 {
0095     deb_ts("stop pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid, dvbdmxfeed->type);
0096     return dvb_usb_ctrl_feed(dvbdmxfeed, 0);
0097 }
0098
0099 static int dvb_usb_media_device_init(struct dvb_usb_adapter *adap)
0100 {
0101 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0102     struct media_device *mdev;
0103     struct dvb_usb_device *d = adap->dev;
0104     struct usb_device *udev = d->udev;
0105
0106     mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
0107     if (!mdev)
0108         return -ENOMEM;
0109
0110     media_device_usb_init(mdev, udev, d->desc->name);
0111
0112     dvb_register_media_controller(&adap->dvb_adap, mdev);
0113
0114     dev_info(&d->udev->dev, "media controller created\n");
0115 #endif
0116     return 0;
0117 }
0118
0119 static int  dvb_usb_media_device_register(struct dvb_usb_adapter *adap)
0120 {
0121 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0122     return media_device_register(adap->dvb_adap.mdev);
0123 #else
0124     return 0;
0125 #endif
0126 }
0127
0128 static void dvb_usb_media_device_unregister(struct dvb_usb_adapter *adap)
0129 {
0130 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0131     if (!adap->dvb_adap.mdev)
0132         return;
0133
0134     mutex_lock(&adap->dvb_adap.mdev_lock);
0135
0136     media_device_unregister(adap->dvb_adap.mdev);
0137     media_device_cleanup(adap->dvb_adap.mdev);
0138     kfree(adap->dvb_adap.mdev);
0139     adap->dvb_adap.mdev = NULL;
0140
0141     mutex_unlock(&adap->dvb_adap.mdev_lock);
0142 #endif
0143 }
0144
0145 int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums)
0146 {
0147     int i;
0148     int ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name,
0149                        adap->dev->owner, &adap->dev->udev->dev,
0150                        adapter_nums);
0151
0152     if (ret < 0) {
0153         deb_info("dvb_register_adapter failed: error %d", ret);
0154         goto err;
0155     }
0156     adap->dvb_adap.priv = adap;
0157
0158     ret = dvb_usb_media_device_init(adap);
0159     if (ret < 0) {
0160         deb_info("dvb_usb_media_device_init failed: error %d", ret);
0161         goto err_mc;
0162     }
0163
0164     if (adap->dev->props.read_mac_address) {
0165         if (adap->dev->props.read_mac_address(adap->dev, adap->dvb_adap.proposed_mac) == 0)
0166             info("MAC address: %pM", adap->dvb_adap.proposed_mac);
0167         else
0168             err("MAC address reading failed.");
0169     }
0170
0171
0172     adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
0173     adap->demux.priv             = adap;
0174
0175     adap->demux.filternum        = 0;
0176     for (i = 0; i < adap->props.num_frontends; i++) {
0177         if (adap->demux.filternum < adap->fe_adap[i].max_feed_count)
0178             adap->demux.filternum = adap->fe_adap[i].max_feed_count;
0179     }
0180     adap->demux.feednum          = adap->demux.filternum;
0181     adap->demux.start_feed       = dvb_usb_start_feed;
0182     adap->demux.stop_feed        = dvb_usb_stop_feed;
0183     adap->demux.write_to_decoder = NULL;
0184     if ((ret = dvb_dmx_init(&adap->demux)) < 0) {
0185         err("dvb_dmx_init failed: error %d", ret);
0186         goto err_dmx;
0187     }
0188
0189     adap->dmxdev.filternum       = adap->demux.filternum;
0190     adap->dmxdev.demux           = &adap->demux.dmx;
0191     adap->dmxdev.capabilities    = 0;
0192     if ((ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap)) < 0) {
0193         err("dvb_dmxdev_init failed: error %d", ret);
0194         goto err_dmx_dev;
0195     }
0196
0197     if ((ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net,
0198                         &adap->demux.dmx)) < 0) {
0199         err("dvb_net_init failed: error %d", ret);
0200         goto err_net_init;
0201     }
0202
0203     adap->state |= DVB_USB_ADAP_STATE_DVB;
0204     return 0;
0205
0206 err_net_init:
0207     dvb_dmxdev_release(&adap->dmxdev);
0208 err_dmx_dev:
0209     dvb_dmx_release(&adap->demux);
0210 err_dmx:
0211     dvb_usb_media_device_unregister(adap);
0212 err_mc:
0213     dvb_unregister_adapter(&adap->dvb_adap);
0214 err:
0215     return ret;
0216 }
0217
0218 int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap)
0219 {
0220     if (adap->state & DVB_USB_ADAP_STATE_DVB) {
0221         deb_info("unregistering DVB part\n");
0222         dvb_net_release(&adap->dvb_net);
0223         adap->demux.dmx.close(&adap->demux.dmx);
0224         dvb_dmxdev_release(&adap->dmxdev);
0225         dvb_dmx_release(&adap->demux);
0226         dvb_usb_media_device_unregister(adap);
0227         dvb_unregister_adapter(&adap->dvb_adap);
0228         adap->state &= ~DVB_USB_ADAP_STATE_DVB;
0229     }
0230     return 0;
0231 }
0232
0233 static int dvb_usb_set_active_fe(struct dvb_frontend *fe, int onoff)
0234 {
0235     struct dvb_usb_adapter *adap = fe->dvb->priv;
0236
0237     int ret = (adap->props.frontend_ctrl) ?
0238         adap->props.frontend_ctrl(fe, onoff) : 0;
0239
0240     if (ret < 0) {
0241         err("frontend_ctrl request failed");
0242         return ret;
0243     }
0244     if (onoff)
0245         adap->active_fe = fe->id;
0246
0247     return 0;
0248 }
0249
0250 static int dvb_usb_fe_wakeup(struct dvb_frontend *fe)
0251 {
0252     struct dvb_usb_adapter *adap = fe->dvb->priv;
0253
0254     dvb_usb_device_power_ctrl(adap->dev, 1);
0255
0256     dvb_usb_set_active_fe(fe, 1);
0257
0258     if (adap->fe_adap[fe->id].fe_init)
0259         adap->fe_adap[fe->id].fe_init(fe);
0260
0261     return 0;
0262 }
0263
0264 static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
0265 {
0266     struct dvb_usb_adapter *adap = fe->dvb->priv;
0267
0268     if (adap->fe_adap[fe->id].fe_sleep)
0269         adap->fe_adap[fe->id].fe_sleep(fe);
0270
0271     dvb_usb_set_active_fe(fe, 0);
0272
0273     return dvb_usb_device_power_ctrl(adap->dev, 0);
0274 }
0275
0276 int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap)
0277 {
0278     int ret, i;
0279
0280     /* register all given adapter frontends */
0281     for (i = 0; i < adap->props.num_frontends; i++) {
0282
0283         if (adap->props.fe[i].frontend_attach == NULL) {
0284             err("strange: '%s' #%d,%d doesn't want to attach a frontend.",
0285                 adap->dev->desc->name, adap->id, i);
0286
0287             return 0;
0288         }
0289
0290         ret = adap->props.fe[i].frontend_attach(adap);
0291         if (ret || adap->fe_adap[i].fe == NULL) {
0292             /* only print error when there is no FE at all */
0293             if (i == 0)
0294                 err("no frontend was attached by '%s'",
0295                     adap->dev->desc->name);
0296
0297             return 0;
0298         }
0299
0300         adap->fe_adap[i].fe->id = i;
0301
0302         /* re-assign sleep and wakeup functions */
0303         adap->fe_adap[i].fe_init = adap->fe_adap[i].fe->ops.init;
0304         adap->fe_adap[i].fe->ops.init  = dvb_usb_fe_wakeup;
0305         adap->fe_adap[i].fe_sleep = adap->fe_adap[i].fe->ops.sleep;
0306         adap->fe_adap[i].fe->ops.sleep = dvb_usb_fe_sleep;
0307
0308         if (dvb_register_frontend(&adap->dvb_adap, adap->fe_adap[i].fe)) {
0309             err("Frontend %d registration failed.", i);
0310             dvb_frontend_detach(adap->fe_adap[i].fe);
0311             adap->fe_adap[i].fe = NULL;
0312             /* In error case, do not try register more FEs,
0313              * still leaving already registered FEs alive. */
0314             if (i == 0)
0315                 return -ENODEV;
0316             else
0317                 return 0;
0318         }
0319
0320         /* only attach the tuner if the demod is there */
0321         if (adap->props.fe[i].tuner_attach != NULL)
0322             adap->props.fe[i].tuner_attach(adap);
0323
0324         adap->num_frontends_initialized++;
0325     }
0326
0327     ret = dvb_create_media_graph(&adap->dvb_adap, true);
0328     if (ret)
0329         return ret;
0330
0331     ret = dvb_usb_media_device_register(adap);
0332
0333     return ret;
0334 }
0335
0336 int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap)
0337 {
0338     int i = adap->num_frontends_initialized - 1;
0339
0340     /* unregister all given adapter frontends */
0341     for (; i >= 0; i--) {
0342         if (adap->fe_adap[i].fe != NULL) {
0343             dvb_unregister_frontend(adap->fe_adap[i].fe);
0344             dvb_frontend_detach(adap->fe_adap[i].fe);
0345         }
0346     }
0347     adap->num_frontends_initialized = 0;
0348
0349     return 0;
0350 }