void fdtv_dvb_unregister(struct firedtv *fdtv) { fdtv_ca_release(fdtv); dvb_unregister_frontend(&fdtv->fe); dvb_net_release(&fdtv->dvbnet); fdtv->demux.dmx.close(&fdtv->demux.dmx); fdtv->demux.dmx.remove_frontend(&fdtv->demux.dmx, &fdtv->frontend); dvb_dmxdev_release(&fdtv->dmxdev); dvb_dmx_release(&fdtv->demux); dvb_unregister_adapter(&fdtv->adapter); }
static void unregister_dvb(struct em28xx_dvb *dvb) { dvb_net_release(&dvb->net); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); dvb_dmxdev_release(&dvb->dmxdev); dvb_dmx_release(&dvb->demux); dvb_unregister_frontend(dvb->frontend); dvb_frontend_detach(dvb->frontend); dvb_unregister_adapter(&dvb->adapter); }
static void __exit StmUnloadModule (void) { int i; BackendDelete (); for (i = 0; i < DVB_MAX_DEVICES_PER_ADAPTER; i++) { struct DeviceContext_s* DeviceContext = &DvbContext->DeviceContext[i]; struct dvb_demux* DvbDemux = &DeviceContext->DvbDemux; struct dmxdev* DmxDevice = &DeviceContext->DmxDevice; #if defined (USE_KERNEL_DEMUX) if (DmxDevice != NULL) { /* We don't need to unregister DmxDevice->dvr_dvbdev as this will be done by dvb_dmxdev_release */ dvb_dmxdev_release (DmxDevice); } if (DvbDemux != NULL) { DvbDemux->dmx.remove_frontend (&DvbDemux->dmx, &DeviceContext->MemoryFrontend); dvb_dmx_release (DvbDemux); } #else dvb_unregister_device (DeviceContext->DemuxDevice); dvb_unregister_device (DeviceContext->DvrDevice); #endif if (DeviceContext->AudioDevice != NULL) dvb_unregister_device (DeviceContext->AudioDevice); if (DeviceContext->VideoDevice != NULL) dvb_unregister_device (DeviceContext->VideoDevice); PlaybackDelete (DeviceContext->Playback); DeviceContext->AudioStream = NULL; DeviceContext->VideoStream = NULL; DeviceContext->Playback = NULL; kfree(DeviceContext->dvr_in); kfree(DeviceContext->dvr_out); } if (DvbContext != NULL) { dvb_unregister_adapter (&DvbContext->DvbAdapter); kfree (DvbContext); } DvbContext = NULL; DVB_DEBUG("STM stream device unloaded\n"); return; }
static void smsdvb_unregister_client(struct smsdvb_client_t *client) { /* must be called under clientslock */ list_del(&client->entry); smscore_unregister_client(client->smsclient); dvb_unregister_frontend(&client->frontend); dvb_dmxdev_release(&client->dmxdev); dvb_dmx_release(&client->demux); dvb_unregister_adapter(&client->adapter); kfree(client); }
int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap) { if (adap->state & DVB_USB_ADAP_STATE_DVB) { deb_info("unregistering DVB part\n"); dvb_net_release(&adap->dvb_net); adap->demux.dmx.close(&adap->demux.dmx); dvb_dmxdev_release(&adap->dmxdev); dvb_dmx_release(&adap->demux); dvb_unregister_adapter(&adap->dvb_adap); adap->state &= ~DVB_USB_ADAP_STATE_DVB; } return 0; }
void as102_dvb_unregister(struct as102_dev_t *as102_dev) { /* unregister as102 frontend */ as102_dvb_unregister_fe(&as102_dev->dvb_fe); /* unregister demux device */ dvb_dmxdev_release(&as102_dev->dvb_dmxdev); dvb_dmx_release(&as102_dev->dvb_dmx); /* unregister dvb adapter */ dvb_unregister_adapter(&as102_dev->dvb_adap); pr_info("Unregistered device %s", as102_dev->name); }
void pd_dvb_usb_device_exit(struct poseidon *pd) { struct pd_dvb_adapter *pd_dvb = &pd->dvb_data; while (atomic_read(&pd_dvb->users) != 0 || atomic_read(&pd_dvb->active_feed) != 0) { set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(HZ); } dvb_dmxdev_release(&pd_dvb->dmxdev); dvb_unregister_frontend(&pd_dvb->dvb_fe); dvb_unregister_adapter(&pd_dvb->dvb_adap); pd_dvb_usb_device_cleanup(pd); }
static void budget_unregister(struct budget *budget) { struct dvb_demux *dvbdemux = &budget->demux; dprintk(2, "budget: %p\n", budget); dvb_net_release(&budget->dvb_net); dvbdemux->dmx.close(&dvbdemux->dmx); dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &budget->hw_frontend); dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &budget->mem_frontend); dvb_dmxdev_release(&budget->dmxdev); dvb_dmx_release(&budget->demux); }
static void em28xx_unregister_dvb(struct em28xx_dvb *dvb) { dvb_net_release(&dvb->net); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); dvb_dmxdev_release(&dvb->dmxdev); dvb_dmx_release(&dvb->demux); if (dvb->fe[1]) dvb_unregister_frontend(dvb->fe[1]); dvb_unregister_frontend(dvb->fe[0]); if (dvb->fe[1] && !dvb->dont_attach_fe1) dvb_frontend_detach(dvb->fe[1]); dvb_frontend_detach(dvb->fe[0]); dvb_unregister_adapter(&dvb->adapter); }
static int dvb_usbv2_adapter_dvb_exit(struct dvb_usb_adapter *adap) { dev_dbg(&adap_to_d(adap)->udev->dev, "%s: adap=%d\n", __func__, adap->id); if (adap->dvb_adap.priv) { dvb_net_release(&adap->dvb_net); adap->demux.dmx.close(&adap->demux.dmx); dvb_dmxdev_release(&adap->dmxdev); dvb_dmx_release(&adap->demux); dvb_unregister_adapter(&adap->dvb_adap); } return 0; }
void as102_dvb_unregister(struct as102_dev_t *as102_dev) { ENTER(); /* unregister as102 frontend */ as102_dvb_unregister_fe(&as102_dev->dvb_fe); /* unregister demux device */ dvb_dmxdev_release(&as102_dev->dvb_dmxdev); dvb_dmx_release(&as102_dev->dvb_dmx); /* unregister dvb adapter */ dvb_unregister_adapter(&as102_dev->dvb_adap); LEAVE(); }
static void aml_dvb_dmx_release(struct aml_dvb *advb, struct aml_dmx *dmx) { int i; dvb_net_release(&dmx->dvb_net); aml_dmx_hw_deinit(dmx); dmx->demux.dmx.close(&dmx->demux.dmx); dmx->demux.dmx.remove_frontend(&dmx->demux.dmx, &dmx->mem_fe); for (i=0; i<DMX_DEV_COUNT; i++) { dmx->demux.dmx.remove_frontend(&dmx->demux.dmx, &dmx->hw_fe[i]); } dvb_dmxdev_release(&dmx->dmxdev); dvb_dmx_release(&dmx->demux); }
static void flexcop_dvb_exit(struct flexcop_device *fc) { if (fc->init_state & FC_STATE_DVB_INIT) { dvb_net_release(&fc->dvbnet); fc->demux.dmx.close(&fc->demux.dmx); fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->mem_frontend); fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->hw_frontend); dvb_dmxdev_release(&fc->dmxdev); dvb_dmx_release(&fc->demux); dvb_unregister_adapter(&fc->dvb_adapter); deb_info("deinitialized dvb stuff\n"); } fc->init_state &= ~FC_STATE_DVB_INIT; }
void as102_dvb_unregister(struct as102_dev_t *as102_dev) { ENTER(); #if defined(CONFIG_DVB_CORE) || defined(CONFIG_DVB_CORE_MODULE) /* unregister as102 frontend */ as102_dvb_unregister_fe(&as102_dev->dvb_fe); /* unregister demux device */ dvb_dmxdev_release(&as102_dev->dvb_dmxdev); dvb_dmx_release(&as102_dev->dvb_dmx); /* unregister dvb adapter */ dvb_unregister_adapter(&as102_dev->dvb_adap); #endif LEAVE(); }
void au0828_dvb_unregister(struct au0828_dev *dev) { struct au0828_dvb *dvb = &dev->dvb; dprintk(1, "%s()\n", __func__); if (dvb->frontend == NULL) return; dvb_net_release(&dvb->net); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); dvb_dmxdev_release(&dvb->dmxdev); dvb_dmx_release(&dvb->demux); dvb_unregister_frontend(dvb->frontend); dvb_frontend_detach(dvb->frontend); dvb_unregister_adapter(&dvb->adapter); }
static void __exit vtunerc_exit(void) { struct dvb_demux *dvbdemux; struct dmx_demux *dmx; int idx; vtunerc_unregister_ctrldev(&config); for (idx = 0; idx < config.devices; idx++) { struct vtunerc_ctx *ctx = vtunerc_tbl[idx]; if(!ctx) continue; vtunerc_tbl[idx] = NULL; #ifdef CONFIG_PROC_FS remove_proc_entry(ctx->procname, NULL); kfree(ctx->procname); #endif vtunerc_frontend_clear(ctx); dvbdemux = &ctx->demux; dmx = &dvbdemux->dmx; dmx->disconnect_frontend(dmx); dmx->remove_frontend(dmx, &ctx->mem_frontend); dmx->remove_frontend(dmx, &ctx->hw_frontend); dvb_dmxdev_release(&ctx->dmxdev); dvb_dmx_release(dvbdemux); dvb_unregister_adapter(&ctx->dvb_adapter); // free allocated buffer if(ctx->kernel_buf != NULL) { kfree(ctx->kernel_buf); printk(KERN_INFO "vtunerc%d: deallocated buffer of %Zu bytes\n", idx, ctx->kernel_buf_size); ctx->kernel_buf = NULL; ctx->kernel_buf_size = 0; } kfree(ctx); } printk(KERN_NOTICE "vtunerc: unloaded successfully\n"); }
void cx18_dvb_unregister(struct cx18_stream *stream) { struct cx18 *cx = stream->cx; struct cx18_dvb *dvb = &stream->dvb; struct dvb_adapter *dvb_adapter; struct dvb_demux *dvbdemux; struct dmx_demux *dmx; CX18_INFO("unregister DVB\n"); dvb_adapter = &dvb->dvb_adapter; dvbdemux = &dvb->demux; dmx = &dvbdemux->dmx; dmx->close(dmx); dvb_net_release(&dvb->dvbnet); dmx->remove_frontend(dmx, &dvb->mem_frontend); dmx->remove_frontend(dmx, &dvb->hw_frontend); dvb_dmxdev_release(&dvb->dmxdev); dvb_dmx_release(dvbdemux); dvb_unregister_frontend(dvb->fe); dvb_frontend_detach(dvb->fe); dvb_unregister_adapter(dvb_adapter); }
int as102_dvb_register(struct as102_dev_t *as102_dev) { struct device *dev = &as102_dev->bus_adap.usb_dev->dev; int ret; ret = dvb_register_adapter(&as102_dev->dvb_adap, as102_dev->name, THIS_MODULE, dev, adapter_nr); if (ret < 0) { dev_err(dev, "%s: dvb_register_adapter() failed: %d\n", __func__, ret); return ret; } as102_dev->dvb_dmx.priv = as102_dev; as102_dev->dvb_dmx.filternum = pid_filtering ? 16 : 256; as102_dev->dvb_dmx.feednum = 256; as102_dev->dvb_dmx.start_feed = as102_dvb_dmx_start_feed; as102_dev->dvb_dmx.stop_feed = as102_dvb_dmx_stop_feed; as102_dev->dvb_dmx.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; as102_dev->dvb_dmxdev.filternum = as102_dev->dvb_dmx.filternum; as102_dev->dvb_dmxdev.demux = &as102_dev->dvb_dmx.dmx; as102_dev->dvb_dmxdev.capabilities = 0; ret = dvb_dmx_init(&as102_dev->dvb_dmx); if (ret < 0) { dev_err(dev, "%s: dvb_dmx_init() failed: %d\n", __func__, ret); goto edmxinit; } ret = dvb_dmxdev_init(&as102_dev->dvb_dmxdev, &as102_dev->dvb_adap); if (ret < 0) { dev_err(dev, "%s: dvb_dmxdev_init() failed: %d\n", __func__, ret); goto edmxdinit; } ret = as102_dvb_register_fe(as102_dev, &as102_dev->dvb_fe); if (ret < 0) { dev_err(dev, "%s: as102_dvb_register_frontend() failed: %d", __func__, ret); goto efereg; } /* init bus mutex for token locking */ mutex_init(&as102_dev->bus_adap.lock); /* init start / stop stream mutex */ mutex_init(&as102_dev->sem); /* * try to load as102 firmware. If firmware upload failed, we'll be * able to upload it later. */ if (fw_upload) try_then_request_module(as102_fw_upload(&as102_dev->bus_adap), "firmware_class"); pr_info("Registered device %s", as102_dev->name); return 0; efereg: dvb_dmxdev_release(&as102_dev->dvb_dmxdev); edmxdinit: dvb_dmx_release(&as102_dev->dvb_dmx); edmxinit: dvb_unregister_adapter(&as102_dev->dvb_adap); return ret; }
static int dvb_usbv2_adapter_dvb_init(struct dvb_usb_adapter *adap) { int ret; struct dvb_usb_device *d = adap_to_d(adap); dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, adap->id); ret = dvb_register_adapter(&adap->dvb_adap, d->name, d->props->owner, &d->udev->dev, d->props->adapter_nr); if (ret < 0) { dev_dbg(&d->udev->dev, "%s: dvb_register_adapter() failed=%d\n", __func__, ret); goto err_dvb_register_adapter; } adap->dvb_adap.priv = adap; if (d->props->read_mac_address) { ret = d->props->read_mac_address(adap, adap->dvb_adap.proposed_mac); if (ret < 0) goto err_dvb_dmx_init; dev_info(&d->udev->dev, "%s: MAC address: %pM\n", KBUILD_MODNAME, adap->dvb_adap.proposed_mac); } adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; adap->demux.priv = adap; adap->demux.filternum = 0; adap->demux.filternum = adap->max_feed_count; adap->demux.feednum = adap->demux.filternum; adap->demux.start_feed = dvb_usb_start_feed; adap->demux.stop_feed = dvb_usb_stop_feed; adap->demux.write_to_decoder = NULL; ret = dvb_dmx_init(&adap->demux); if (ret < 0) { dev_err(&d->udev->dev, "%s: dvb_dmx_init() failed=%d\n", KBUILD_MODNAME, ret); goto err_dvb_dmx_init; } adap->dmxdev.filternum = adap->demux.filternum; adap->dmxdev.demux = &adap->demux.dmx; adap->dmxdev.capabilities = 0; ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap); if (ret < 0) { dev_err(&d->udev->dev, "%s: dvb_dmxdev_init() failed=%d\n", KBUILD_MODNAME, ret); goto err_dvb_dmxdev_init; } ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx); if (ret < 0) { dev_err(&d->udev->dev, "%s: dvb_net_init() failed=%d\n", KBUILD_MODNAME, ret); goto err_dvb_net_init; } return 0; err_dvb_net_init: dvb_dmxdev_release(&adap->dmxdev); err_dvb_dmxdev_init: dvb_dmx_release(&adap->demux); err_dvb_dmx_init: dvb_unregister_adapter(&adap->dvb_adap); err_dvb_register_adapter: adap->dvb_adap.priv = NULL; return ret; }
int __devinit saa716x_dvb_init(struct saa716x_dev *saa716x) { struct saa716x_adapter *saa716x_adap = saa716x->saa716x_adap; struct saa716x_config *config = saa716x->config; int result, i; mutex_init(&saa716x->adap_lock); for (i = 0; i < config->adapters; i++) { dprintk(SAA716x_DEBUG, 1, "dvb_register_adapter"); if (dvb_register_adapter(&saa716x_adap->dvb_adapter, "SAA716x dvb adapter", THIS_MODULE, &saa716x->pdev->dev, adapter_nr) < 0) { dprintk(SAA716x_ERROR, 1, "Error registering adapter"); return -ENODEV; } saa716x_adap->count = i; saa716x_adap->dvb_adapter.priv = saa716x_adap; saa716x_adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; saa716x_adap->demux.priv = saa716x_adap; saa716x_adap->demux.filternum = 256; saa716x_adap->demux.feednum = 256; saa716x_adap->demux.start_feed = saa716x_dvb_start_feed; saa716x_adap->demux.stop_feed = saa716x_dvb_stop_feed; saa716x_adap->demux.write_to_decoder = NULL; dprintk(SAA716x_DEBUG, 1, "dvb_dmx_init"); if ((result = dvb_dmx_init(&saa716x_adap->demux)) < 0) { dprintk(SAA716x_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err0; } saa716x_adap->dmxdev.filternum = 256; saa716x_adap->dmxdev.demux = &saa716x_adap->demux.dmx; saa716x_adap->dmxdev.capabilities = 0; dprintk(SAA716x_DEBUG, 1, "dvb_dmxdev_init"); if ((result = dvb_dmxdev_init(&saa716x_adap->dmxdev, &saa716x_adap->dvb_adapter)) < 0) { dprintk(SAA716x_ERROR, 1, "dvb_dmxdev_init failed, ERROR=%d", result); goto err1; } saa716x_adap->fe_hw.source = DMX_FRONTEND_0; if ((result = saa716x_adap->demux.dmx.add_frontend(&saa716x_adap->demux.dmx, &saa716x_adap->fe_hw)) < 0) { dprintk(SAA716x_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err2; } saa716x_adap->fe_mem.source = DMX_MEMORY_FE; if ((result = saa716x_adap->demux.dmx.add_frontend(&saa716x_adap->demux.dmx, &saa716x_adap->fe_mem)) < 0) { dprintk(SAA716x_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err3; } if ((result = saa716x_adap->demux.dmx.connect_frontend(&saa716x_adap->demux.dmx, &saa716x_adap->fe_hw)) < 0) { dprintk(SAA716x_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err4; } dvb_net_init(&saa716x_adap->dvb_adapter, &saa716x_adap->dvb_net, &saa716x_adap->demux.dmx); // tasklet_init(&saa716x_adap->tasklet, saa716x_dma_xfer, (unsigned long) saa716x); dprintk(SAA716x_DEBUG, 1, "Frontend Init"); saa716x_adap->saa716x = saa716x; if (config->frontend_attach) { result = config->frontend_attach(saa716x_adap, i); if (result < 0) dprintk(SAA716x_ERROR, 1, "SAA716x frontend attach failed"); if (saa716x_adap->fe == NULL) { dprintk(SAA716x_ERROR, 1, "A frontend driver was not found for [%04x:%04x] subsystem [%04x:%04x]\n", saa716x->pdev->vendor, saa716x->pdev->device, saa716x->pdev->subsystem_vendor, saa716x->pdev->subsystem_device); } else { result = dvb_register_frontend(&saa716x_adap->dvb_adapter, saa716x_adap->fe); if (result < 0) { dprintk(SAA716x_ERROR, 1, "SAA716x register frontend failed"); goto err6; } } } else { dprintk(SAA716x_ERROR, 1, "Frontend attach = NULL"); } saa716x_fgpi_init(saa716x, config->adap_config[i].ts_port); saa716x_adap++; } return 0; /* Error conditions */ err6: dvb_frontend_detach(saa716x_adap->fe); err4: saa716x_adap->demux.dmx.remove_frontend(&saa716x_adap->demux.dmx, &saa716x_adap->fe_mem); err3: saa716x_adap->demux.dmx.remove_frontend(&saa716x_adap->demux.dmx, &saa716x_adap->fe_hw); err2: dvb_dmxdev_release(&saa716x_adap->dmxdev); err1: dvb_dmx_release(&saa716x_adap->demux); err0: dvb_unregister_adapter(&saa716x_adap->dvb_adapter); return result; }
static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module, struct em28xx *dev, struct device *device) { int result; mutex_init(&dvb->lock); /* register adapter */ result = dvb_register_adapter(&dvb->adapter, dev->name, module, device, adapter_nr); if (result < 0) { printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n", dev->name, result); goto fail_adapter; } /* Ensure all frontends negotiate bus access */ dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl; if (dvb->fe[1]) dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl; dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus]; /* register frontend */ result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]); if (result < 0) { printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n", dev->name, result); goto fail_frontend0; } /* register 2nd frontend */ if (dvb->fe[1]) { result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]); if (result < 0) { printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n", dev->name, result); goto fail_frontend1; } } /* register demux stuff */ dvb->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; dvb->demux.priv = dvb; dvb->demux.filternum = 256; dvb->demux.feednum = 256; dvb->demux.start_feed = em28xx_start_feed; dvb->demux.stop_feed = em28xx_stop_feed; result = dvb_dmx_init(&dvb->demux); if (result < 0) { printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n", dev->name, result); goto fail_dmx; } dvb->dmxdev.filternum = 256; dvb->dmxdev.demux = &dvb->demux.dmx; dvb->dmxdev.capabilities = 0; result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); if (result < 0) { printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n", dev->name, result); goto fail_dmxdev; } dvb->fe_hw.source = DMX_FRONTEND_0; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n", dev->name, result); goto fail_fe_hw; } dvb->fe_mem.source = DMX_MEMORY_FE; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); if (result < 0) { printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n", dev->name, result); goto fail_fe_mem; } result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n", dev->name, result); goto fail_fe_conn; } /* register network adapter */ dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); return 0; fail_fe_conn: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); fail_fe_mem: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); fail_fe_hw: dvb_dmxdev_release(&dvb->dmxdev); fail_dmxdev: dvb_dmx_release(&dvb->demux); fail_dmx: if (dvb->fe[1]) dvb_unregister_frontend(dvb->fe[1]); dvb_unregister_frontend(dvb->fe[0]); fail_frontend1: if (dvb->fe[1]) dvb_frontend_detach(dvb->fe[1]); fail_frontend0: dvb_frontend_detach(dvb->fe[0]); dvb_unregister_adapter(&dvb->adapter); fail_adapter: return result; }
int cx18_dvb_register(struct cx18_stream *stream) { struct cx18 *cx = stream->cx; struct cx18_dvb *dvb = stream->dvb; struct dvb_adapter *dvb_adapter; struct dvb_demux *dvbdemux; struct dmx_demux *dmx; int ret; if (!dvb) return -EINVAL; dvb->enabled = 0; dvb->stream = stream; ret = dvb_register_adapter(&dvb->dvb_adapter, CX18_DRIVER_NAME, THIS_MODULE, &cx->pci_dev->dev, adapter_nr); if (ret < 0) goto err_out; dvb_adapter = &dvb->dvb_adapter; dvbdemux = &dvb->demux; dvbdemux->priv = (void *)stream; dvbdemux->filternum = 256; dvbdemux->feednum = 256; dvbdemux->start_feed = cx18_dvb_start_feed; dvbdemux->stop_feed = cx18_dvb_stop_feed; dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING); ret = dvb_dmx_init(dvbdemux); if (ret < 0) goto err_dvb_unregister_adapter; dmx = &dvbdemux->dmx; dvb->hw_frontend.source = DMX_FRONTEND_0; dvb->mem_frontend.source = DMX_MEMORY_FE; dvb->dmxdev.filternum = 256; dvb->dmxdev.demux = dmx; ret = dvb_dmxdev_init(&dvb->dmxdev, dvb_adapter); if (ret < 0) goto err_dvb_dmx_release; ret = dmx->add_frontend(dmx, &dvb->hw_frontend); if (ret < 0) goto err_dvb_dmxdev_release; ret = dmx->add_frontend(dmx, &dvb->mem_frontend); if (ret < 0) goto err_remove_hw_frontend; ret = dmx->connect_frontend(dmx, &dvb->hw_frontend); if (ret < 0) goto err_remove_mem_frontend; ret = dvb_register(stream); if (ret < 0) goto err_disconnect_frontend; dvb_net_init(dvb_adapter, &dvb->dvbnet, dmx); CX18_INFO("DVB Frontend registered\n"); CX18_INFO("Registered DVB adapter%d for %s (%d x %d.%02d kB)\n", stream->dvb->dvb_adapter.num, stream->name, stream->buffers, stream->buf_size/1024, (stream->buf_size * 100 / 1024) % 100); mutex_init(&dvb->feedlock); dvb->enabled = 1; return ret; err_disconnect_frontend: dmx->disconnect_frontend(dmx); err_remove_mem_frontend: dmx->remove_frontend(dmx, &dvb->mem_frontend); err_remove_hw_frontend: dmx->remove_frontend(dmx, &dvb->hw_frontend); err_dvb_dmxdev_release: dvb_dmxdev_release(&dvb->dmxdev); err_dvb_dmx_release: dvb_dmx_release(dvbdemux); err_dvb_unregister_adapter: dvb_unregister_adapter(dvb_adapter); err_out: return ret; }
static int flexcop_dvb_init(struct flexcop_device *fc) { int ret = dvb_register_adapter(&fc->dvb_adapter, "FlexCop Digital TV device", fc->owner, fc->dev, adapter_nr); if (ret < 0) { err("error registering DVB adapter"); return ret; } fc->dvb_adapter.priv = fc; fc->demux.dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING); fc->demux.priv = fc; fc->demux.filternum = fc->demux.feednum = FC_MAX_FEED; fc->demux.start_feed = flexcop_dvb_start_feed; fc->demux.stop_feed = flexcop_dvb_stop_feed; fc->demux.write_to_decoder = NULL; ret = dvb_dmx_init(&fc->demux); if (ret < 0) { err("dvb_dmx failed: error %d", ret); goto err_dmx; } fc->hw_frontend.source = DMX_FRONTEND_0; fc->dmxdev.filternum = fc->demux.feednum; fc->dmxdev.demux = &fc->demux.dmx; fc->dmxdev.capabilities = 0; ret = dvb_dmxdev_init(&fc->dmxdev, &fc->dvb_adapter); if (ret < 0) { err("dvb_dmxdev_init failed: error %d", ret); goto err_dmx_dev; } ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->hw_frontend); if (ret < 0) { err("adding hw_frontend to dmx failed: error %d", ret); goto err_dmx_add_hw_frontend; } fc->mem_frontend.source = DMX_MEMORY_FE; ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->mem_frontend); if (ret < 0) { err("adding mem_frontend to dmx failed: error %d", ret); goto err_dmx_add_mem_frontend; } ret = fc->demux.dmx.connect_frontend(&fc->demux.dmx, &fc->hw_frontend); if (ret < 0) { err("connect frontend failed: error %d", ret); goto err_connect_frontend; } ret = dvb_net_init(&fc->dvb_adapter, &fc->dvbnet, &fc->demux.dmx); if (ret < 0) { err("dvb_net_init failed: error %d", ret); goto err_net; } fc->init_state |= FC_STATE_DVB_INIT; return 0; err_net: fc->demux.dmx.disconnect_frontend(&fc->demux.dmx); err_connect_frontend: fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->mem_frontend); err_dmx_add_mem_frontend: fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->hw_frontend); err_dmx_add_hw_frontend: dvb_dmxdev_release(&fc->dmxdev); err_dmx_dev: dvb_dmx_release(&fc->demux); err_dmx: dvb_unregister_adapter(&fc->dvb_adapter); return ret; }
int fdtv_dvb_register(struct firedtv *fdtv, const char *name) { int err; err = dvb_register_adapter(&fdtv->adapter, name, THIS_MODULE, fdtv->device, adapter_nr); if (err < 0) goto fail_log; /*DMX_TS_FILTERING | DMX_SECTION_FILTERING*/ fdtv->demux.dmx.capabilities = 0; fdtv->demux.priv = fdtv; fdtv->demux.filternum = 16; fdtv->demux.feednum = 16; fdtv->demux.start_feed = fdtv_start_feed; fdtv->demux.stop_feed = fdtv_stop_feed; fdtv->demux.write_to_decoder = NULL; err = dvb_dmx_init(&fdtv->demux); if (err) goto fail_unreg_adapter; fdtv->dmxdev.filternum = 16; fdtv->dmxdev.demux = &fdtv->demux.dmx; fdtv->dmxdev.capabilities = 0; err = dvb_dmxdev_init(&fdtv->dmxdev, &fdtv->adapter); if (err) goto fail_dmx_release; fdtv->frontend.source = DMX_FRONTEND_0; err = fdtv->demux.dmx.add_frontend(&fdtv->demux.dmx, &fdtv->frontend); if (err) goto fail_dmxdev_release; err = fdtv->demux.dmx.connect_frontend(&fdtv->demux.dmx, &fdtv->frontend); if (err) goto fail_rem_frontend; err = dvb_net_init(&fdtv->adapter, &fdtv->dvbnet, &fdtv->demux.dmx); if (err) goto fail_disconnect_frontend; fdtv_frontend_init(fdtv, name); err = dvb_register_frontend(&fdtv->adapter, &fdtv->fe); if (err) goto fail_net_release; err = fdtv_ca_register(fdtv); if (err) dev_info(fdtv->device, "Conditional Access Module not enabled\n"); return 0; fail_net_release: dvb_net_release(&fdtv->dvbnet); fail_disconnect_frontend: fdtv->demux.dmx.close(&fdtv->demux.dmx); fail_rem_frontend: fdtv->demux.dmx.remove_frontend(&fdtv->demux.dmx, &fdtv->frontend); fail_dmxdev_release: dvb_dmxdev_release(&fdtv->dmxdev); fail_dmx_release: dvb_dmx_release(&fdtv->demux); fail_unreg_adapter: dvb_unregister_adapter(&fdtv->adapter); fail_log: dev_err(fdtv->device, "DVB initialization failed\n"); return err; }
static int dvb_register(struct au0828_dev *dev) { struct au0828_dvb *dvb = &dev->dvb; int result; dprintk(1, "%s()\n", __func__); INIT_WORK(&dev->restart_streaming, au0828_restart_dvb_streaming); /* register adapter */ result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE, &dev->usbdev->dev, adapter_nr); if (result < 0) { printk(KERN_ERR "%s: dvb_register_adapter failed " "(errno = %d)\n", DRIVER_NAME, result); goto fail_adapter; } dvb->adapter.priv = dev; /* register frontend */ result = dvb_register_frontend(&dvb->adapter, dvb->frontend); if (result < 0) { printk(KERN_ERR "%s: dvb_register_frontend failed " "(errno = %d)\n", DRIVER_NAME, result); goto fail_frontend; } /* register demux stuff */ dvb->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; dvb->demux.priv = dev; dvb->demux.filternum = 256; dvb->demux.feednum = 256; dvb->demux.start_feed = au0828_dvb_start_feed; dvb->demux.stop_feed = au0828_dvb_stop_feed; result = dvb_dmx_init(&dvb->demux); if (result < 0) { printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n", DRIVER_NAME, result); goto fail_dmx; } dvb->dmxdev.filternum = 256; dvb->dmxdev.demux = &dvb->demux.dmx; dvb->dmxdev.capabilities = 0; result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); if (result < 0) { printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n", DRIVER_NAME, result); goto fail_dmxdev; } dvb->fe_hw.source = DMX_FRONTEND_0; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_ERR "%s: add_frontend failed " "(DMX_FRONTEND_0, errno = %d)\n", DRIVER_NAME, result); goto fail_fe_hw; } dvb->fe_mem.source = DMX_MEMORY_FE; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); if (result < 0) { printk(KERN_ERR "%s: add_frontend failed " "(DMX_MEMORY_FE, errno = %d)\n", DRIVER_NAME, result); goto fail_fe_mem; } result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n", DRIVER_NAME, result); goto fail_fe_conn; } /* register network adapter */ dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); return 0; fail_fe_conn: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); fail_fe_mem: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); fail_fe_hw: dvb_dmxdev_release(&dvb->dmxdev); fail_dmxdev: dvb_dmx_release(&dvb->demux); fail_dmx: dvb_unregister_frontend(dvb->frontend); fail_frontend: dvb_frontend_detach(dvb->frontend); dvb_unregister_adapter(&dvb->adapter); fail_adapter: return result; }
static int register_dvb(struct tm6000_core *dev) { int ret = -1; struct tm6000_dvb *dvb = dev->dvb; mutex_init(&dvb->mutex); dvb->streams = 0; /* attach the frontend */ ret = tm6000_dvb_attach_frontend(dev); if (ret < 0) { printk(KERN_ERR "tm6000: couldn't attach the frontend!\n"); goto err; } ret = dvb_register_adapter(&dvb->adapter, "Trident TVMaster 6000 DVB-T", THIS_MODULE, &dev->udev->dev, adapter_nr); dvb->adapter.priv = dev; if (dvb->frontend) { switch (dev->tuner_type) { case TUNER_XC2028: { struct xc2028_config cfg = { .i2c_adap = &dev->i2c_adap, .i2c_addr = dev->tuner_addr, }; dvb->frontend->callback = tm6000_tuner_callback; ret = dvb_register_frontend(&dvb->adapter, dvb->frontend); if (ret < 0) { printk(KERN_ERR "tm6000: couldn't register frontend\n"); goto adapter_err; } if (!dvb_attach(xc2028_attach, dvb->frontend, &cfg)) { printk(KERN_ERR "tm6000: couldn't register " "frontend (xc3028)\n"); ret = -EINVAL; goto frontend_err; } printk(KERN_INFO "tm6000: XC2028/3028 asked to be " "attached to frontend!\n"); break; } case TUNER_XC5000: { struct xc5000_config cfg = { .i2c_address = dev->tuner_addr, }; dvb->frontend->callback = tm6000_xc5000_callback; ret = dvb_register_frontend(&dvb->adapter, dvb->frontend); if (ret < 0) { printk(KERN_ERR "tm6000: couldn't register frontend\n"); goto adapter_err; } if (!dvb_attach(xc5000_attach, dvb->frontend, &dev->i2c_adap, &cfg)) { printk(KERN_ERR "tm6000: couldn't register " "frontend (xc5000)\n"); ret = -EINVAL; goto frontend_err; } printk(KERN_INFO "tm6000: XC5000 asked to be " "attached to frontend!\n"); break; } } } else printk(KERN_ERR "tm6000: no frontend found\n"); dvb->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; dvb->demux.priv = dev; dvb->demux.filternum = 8; dvb->demux.feednum = 8; dvb->demux.start_feed = tm6000_start_feed; dvb->demux.stop_feed = tm6000_stop_feed; dvb->demux.write_to_decoder = NULL; ret = dvb_dmx_init(&dvb->demux); if (ret < 0) { printk(KERN_ERR "tm6000: dvb_dmx_init failed (errno = %d)\n", ret); goto frontend_err; } dvb->dmxdev.filternum = dev->dvb->demux.filternum; dvb->dmxdev.demux = &dev->dvb->demux.dmx; dvb->dmxdev.capabilities = 0; ret = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); if (ret < 0) { printk(KERN_ERR "tm6000: dvb_dmxdev_init failed (errno = %d)\n", ret); goto dvb_dmx_err; } return 0; dvb_dmx_err: dvb_dmx_release(&dvb->demux); frontend_err: if (dvb->frontend) { dvb_unregister_frontend(dvb->frontend); dvb_frontend_detach(dvb->frontend); } adapter_err: dvb_unregister_adapter(&dvb->adapter); err: return ret; } static void unregister_dvb(struct tm6000_core *dev) { struct tm6000_dvb *dvb = dev->dvb; if (dvb->bulk_urb != NULL) { struct urb *bulk_urb = dvb->bulk_urb; kfree(bulk_urb->transfer_buffer); bulk_urb->transfer_buffer = NULL; usb_unlink_urb(bulk_urb); usb_free_urb(bulk_urb); } /* mutex_lock(&tm6000_driver.open_close_mutex); */ if (dvb->frontend) { dvb_unregister_frontend(dvb->frontend); dvb_frontend_detach(dvb->frontend); } dvb_dmxdev_release(&dvb->dmxdev); dvb_dmx_release(&dvb->demux); dvb_unregister_adapter(&dvb->adapter); mutex_destroy(&dvb->mutex); /* mutex_unlock(&tm6000_driver.open_close_mutex); */ } static int dvb_init(struct tm6000_core *dev) { struct tm6000_dvb *dvb; int rc; if (!dev) return 0; if (!dev->caps.has_dvb) return 0; if (dev->udev->speed == USB_SPEED_FULL) { printk(KERN_INFO "This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)\n"); return 0; } dvb = kzalloc(sizeof(struct tm6000_dvb), GFP_KERNEL); if (!dvb) { printk(KERN_INFO "Cannot allocate memory\n"); return -ENOMEM; } dev->dvb = dvb; rc = register_dvb(dev); if (rc < 0) { kfree(dvb); dev->dvb = NULL; return 0; } return 0; } static int dvb_fini(struct tm6000_core *dev) { if (!dev) return 0; if (!dev->caps.has_dvb) return 0; if (dev->dvb) { unregister_dvb(dev); kfree(dev->dvb); dev->dvb = NULL; } return 0; } static struct tm6000_ops dvb_ops = { .type = TM6000_DVB, .name = "TM6000 dvb Extension", .init = dvb_init, .fini = dvb_fini, }; static int __init tm6000_dvb_register(void) { return tm6000_register_extension(&dvb_ops); } static void __exit tm6000_dvb_unregister(void) { tm6000_unregister_extension(&dvb_ops); } module_init(tm6000_dvb_register); module_exit(tm6000_dvb_unregister);
int __devinit mantis_dvb_init(struct mantis_pci *mantis) { struct mantis_hwconfig *config = mantis->hwconfig; int result = -1; dprintk(MANTIS_DEBUG, 1, "dvb_register_adapter"); result = dvb_register_adapter(&mantis->dvb_adapter, "Mantis DVB adapter", THIS_MODULE, &mantis->pdev->dev, adapter_nr); if (result < 0) { dprintk(MANTIS_ERROR, 1, "Error registering adapter"); return -ENODEV; } mantis->dvb_adapter.priv = mantis; mantis->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; mantis->demux.priv = mantis; mantis->demux.filternum = 256; mantis->demux.feednum = 256; mantis->demux.start_feed = mantis_dvb_start_feed; mantis->demux.stop_feed = mantis_dvb_stop_feed; mantis->demux.write_to_decoder = NULL; dprintk(MANTIS_DEBUG, 1, "dvb_dmx_init"); result = dvb_dmx_init(&mantis->demux); if (result < 0) { dprintk(MANTIS_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err0; } mantis->dmxdev.filternum = 256; mantis->dmxdev.demux = &mantis->demux.dmx; mantis->dmxdev.capabilities = 0; dprintk(MANTIS_DEBUG, 1, "dvb_dmxdev_init"); result = dvb_dmxdev_init(&mantis->dmxdev, &mantis->dvb_adapter); if (result < 0) { dprintk(MANTIS_ERROR, 1, "dvb_dmxdev_init failed, ERROR=%d", result); goto err1; } mantis->fe_hw.source = DMX_FRONTEND_0; result = mantis->demux.dmx.add_frontend(&mantis->demux.dmx, &mantis->fe_hw); if (result < 0) { dprintk(MANTIS_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err2; } mantis->fe_mem.source = DMX_MEMORY_FE; result = mantis->demux.dmx.add_frontend(&mantis->demux.dmx, &mantis->fe_mem); if (result < 0) { dprintk(MANTIS_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err3; } result = mantis->demux.dmx.connect_frontend(&mantis->demux.dmx, &mantis->fe_hw); if (result < 0) { dprintk(MANTIS_ERROR, 1, "dvb_dmx_init failed, ERROR=%d", result); goto err4; } dvb_net_init(&mantis->dvb_adapter, &mantis->dvbnet, &mantis->demux.dmx); tasklet_init(&mantis->tasklet, mantis_dma_xfer, (unsigned long) mantis); tasklet_disable(&mantis->tasklet); if (mantis->hwconfig) { result = config->frontend_init(mantis, mantis->fe); if (result < 0) { dprintk(MANTIS_ERROR, 1, "!!! NO Frontends found !!!"); goto err5; } else { if (mantis->fe == NULL) { dprintk(MANTIS_ERROR, 1, "FE <NULL>"); goto err5; } if (dvb_register_frontend(&mantis->dvb_adapter, mantis->fe)) { dprintk(MANTIS_ERROR, 1, "ERROR: Frontend registration failed"); if (mantis->fe->ops.release) mantis->fe->ops.release(mantis->fe); mantis->fe = NULL; goto err5; } } } return 0; /* */ err5: tasklet_kill(&mantis->tasklet); dvb_net_release(&mantis->dvbnet); dvb_unregister_frontend(mantis->fe); dvb_frontend_detach(mantis->fe); err4: mantis->demux.dmx.remove_frontend(&mantis->demux.dmx, &mantis->fe_mem); err3: mantis->demux.dmx.remove_frontend(&mantis->demux.dmx, &mantis->fe_hw); err2: dvb_dmxdev_release(&mantis->dmxdev); err1: dvb_dmx_release(&mantis->demux); err0: dvb_unregister_adapter(&mantis->dvb_adapter); return result; }
int videobuf_dvb_register(struct videobuf_dvb *dvb, struct module *module, void *adapter_priv) { int result; mutex_init(&dvb->lock); /* register adapter */ result = dvb_register_adapter(&dvb->adapter, dvb->name, module); if (result < 0) { printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n", dvb->name, result); goto fail_adapter; } dvb->adapter.priv = adapter_priv; /* register frontend */ result = dvb_register_frontend(&dvb->adapter, dvb->frontend); if (result < 0) { printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n", dvb->name, result); goto fail_frontend; } /* register demux stuff */ dvb->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; dvb->demux.priv = dvb; dvb->demux.filternum = 256; dvb->demux.feednum = 256; dvb->demux.start_feed = videobuf_dvb_start_feed; dvb->demux.stop_feed = videobuf_dvb_stop_feed; result = dvb_dmx_init(&dvb->demux); if (result < 0) { printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n", dvb->name, result); goto fail_dmx; } dvb->dmxdev.filternum = 256; dvb->dmxdev.demux = &dvb->demux.dmx; dvb->dmxdev.capabilities = 0; result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); if (result < 0) { printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n", dvb->name, result); goto fail_dmxdev; } dvb->fe_hw.source = DMX_FRONTEND_0; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n", dvb->name, result); goto fail_fe_hw; } dvb->fe_mem.source = DMX_MEMORY_FE; result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); if (result < 0) { printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n", dvb->name, result); goto fail_fe_mem; } result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); if (result < 0) { printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n", dvb->name, result); goto fail_fe_conn; } /* register network adapter */ dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); return 0; fail_fe_conn: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); fail_fe_mem: dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); fail_fe_hw: dvb_dmxdev_release(&dvb->dmxdev); fail_dmxdev: dvb_dmx_release(&dvb->demux); fail_dmx: dvb_unregister_frontend(dvb->frontend); fail_frontend: dvb_unregister_adapter(&dvb->adapter); fail_adapter: return result; }
/*static*/ int __init StmLoadModule(void) { int Result; int i; short int AdapterNumbers[] = { -1 }; DvbContext = kzalloc(sizeof(struct DvbContext_s), GFP_KERNEL); if (DvbContext == NULL) { DVB_ERROR("Unable to allocate device memory\n"); return -ENOMEM; } #ifdef __TDT__ memset(DvbContext, 0, sizeof * DvbContext); #endif #ifdef __TDT__ if (swts) printk("swts ->routing streams from dvr0 to tsm to pti to player\n"); else printk("no swts ->routing streams from dvr0 direct to the player\n"); #endif #if DVB_API_VERSION < 5 Result = dvb_register_adapter(&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE, NULL); #else Result = dvb_register_adapter(&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE, NULL, AdapterNumbers); #endif if (Result < 0) { DVB_ERROR("Failed to register adapter (%d)\n", Result); kfree(DvbContext); DvbContext = NULL; return -ENOMEM; } mutex_init(&(DvbContext->Lock)); mutex_lock(&(DvbContext->Lock)); /*{{{ Register devices*/ for (i = 0; i < DVB_MAX_DEVICES_PER_ADAPTER; i++) { struct DeviceContext_s* DeviceContext = &DvbContext->DeviceContext[i]; struct dvb_demux* DvbDemux = &DeviceContext->DvbDemux; struct dmxdev* DmxDevice = &DeviceContext->DmxDevice; struct dvb_device* DvrDevice; #ifdef __TDT__ //sylvester: wenn der stream vom user kommt soll WriteToDecoder nix //tun, da das ja hier schon passiert. keine ahnung wie man das ansonsten //verhindern soll;-) DeviceContext->dvr_write = 0; #endif DeviceContext->DvbContext = DvbContext; #if defined (USE_KERNEL_DEMUX) memset(DvbDemux, 0, sizeof(struct dvb_demux)); #ifdef __TDT__ DvbDemux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING | DMX_TS_DESCRAMBLING; /* currently only dummy to avoid EINVAL error. Later we need it for second frontend ?! */ DvbDemux->dmx.set_source = SetSource; #else DvbDemux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING; #endif DvbDemux->priv = DeviceContext; DvbDemux->filternum = 32; DvbDemux->feednum = 32; DvbDemux->start_feed = StartFeed; DvbDemux->stop_feed = StopFeed; #ifdef __TDT__ DvbDemux->write_to_decoder = WriteToDecoder; #else DvbDemux->write_to_decoder = NULL; #endif Result = dvb_dmx_init(DvbDemux); if (Result < 0) { DVB_ERROR("dvb_dmx_init failed (errno = %d)\n", Result); return Result; } memset(DmxDevice, 0, sizeof(struct dmxdev)); DmxDevice->filternum = DvbDemux->filternum; DmxDevice->demux = &DvbDemux->dmx; DmxDevice->capabilities = 0; Result = dvb_dmxdev_init(DmxDevice, &DvbContext->DvbAdapter); if (Result < 0) { DVB_ERROR("dvb_dmxdev_init failed (errno = %d)\n", Result); dvb_dmx_release(DvbDemux); return Result; } DvrDevice = DvrInit(DmxDevice->dvr_dvbdev->fops); #ifdef __TDT__ printk("%d: DeviceContext %p, DvbDemux %p, DmxDevice %p\n", i, DeviceContext, DvbDemux, DmxDevice); #endif /* Unregister the built-in dvr device and replace it with our own version */ dvb_unregister_device(DmxDevice->dvr_dvbdev); dvb_register_device(&DvbContext->DvbAdapter, &DmxDevice->dvr_dvbdev, DvrDevice, DmxDevice, DVB_DEVICE_DVR); DeviceContext->MemoryFrontend.source = DMX_MEMORY_FE; Result = DvbDemux->dmx.add_frontend(&DvbDemux->dmx, &DeviceContext->MemoryFrontend); if (Result < 0) { DVB_ERROR("add_frontend failed (errno = %d)\n", Result); dvb_dmxdev_release(DmxDevice); dvb_dmx_release(DvbDemux); return Result; } #else dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->DemuxDevice, DemuxInit(DeviceContext), DeviceContext, DVB_DEVICE_DEMUX); dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->DvrDevice, DvrInit(DeviceContext), DeviceContext, DVB_DEVICE_DVR); #endif dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->AudioDevice, AudioInit(DeviceContext), DeviceContext, DVB_DEVICE_AUDIO); #ifdef __TDT__ /* register the CA device (e.g. CIMAX) */ if (i < 3) #ifndef VIP2_V1 dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->CaDevice, CaInit(DeviceContext), DeviceContext, DVB_DEVICE_CA); #endif #else dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->CaDevice, CaInit(DeviceContext), DeviceContext, DVB_DEVICE_CA); #endif dvb_register_device(&DvbContext->DvbAdapter, &DeviceContext->VideoDevice, VideoInit(DeviceContext), DeviceContext, DVB_DEVICE_VIDEO); DeviceContext->Id = i; DeviceContext->numRunningFeeds = 0; DeviceContext->DemuxContext = DeviceContext; /* wire directly to own demux by default */ DeviceContext->SyncContext = DeviceContext; /* we are our own sync group by default */ DeviceContext->Playback = NULL; DeviceContext->StreamType = STREAM_TYPE_TRANSPORT; DeviceContext->DvbContext = DvbContext; DeviceContext->DemuxStream = NULL; DeviceContext->VideoStream = NULL; DeviceContext->AudioStream = NULL; DeviceContext->PlaySpeed = DVB_SPEED_NORMAL_PLAY; DeviceContext->dvr_in = kmalloc(65536, GFP_KERNEL); // 128Kbytes is quite a lot per device. DeviceContext->dvr_out = kmalloc(65536, GFP_KERNEL); // However allocating on each write is expensive. DeviceContext->EncryptionOn = 0; #ifdef __TDT__ DeviceContext->VideoPlaySpeed = DVB_SPEED_NORMAL_PLAY; DeviceContext->provideToDecoder = 0; DeviceContext->feedPesType = 0; mutex_init(&DeviceContext->injectMutex); if (i < 4) { ptiInit(DeviceContext); } if (i < 1) { init_e2_proc(DeviceContext); } #endif } mutex_unlock(&(DvbContext->Lock)); DvbBackendInit(); #ifndef __TDT__ #if defined (CONFIG_CPU_SUBTYPE_STX7105) // || defined (CONFIG_CPU_SUBTYPE_STX7200) cap_init(); #endif #endif linuxdvb_v4l2_init(); DVB_DEBUG("STM stream device loaded\n"); return 0; }
static int aml_dvb_dmx_init(struct aml_dvb *advb, struct aml_dmx *dmx, int id) { int i, ret; struct resource *res; char buf[32]; dmx->dmx_irq = id?demux1_irq:demux0_irq; if(dmx->dmx_irq==-1) { snprintf(buf, sizeof(buf), "demux%d_irq", id); res = platform_get_resource_byname(advb->pdev, IORESOURCE_IRQ, buf); if (!res) { pr_error("cannot get resource %s\n", buf); return -1; } dmx->dmx_irq = res->start; } dmx->source = AM_TS_SRC_TS0; dmx->dump_ts_select = 0; dmx->dvr_irq = -1; /* if(id==0) { dmx->dvr_irq = dvr0_irq; if(dmx->dvr_irq==-1) { snprintf(buf, sizeof(buf), "dvr%d_irq", id); res = platform_get_resource_byname(advb->pdev, IORESOURCE_IRQ, buf); if (!res) { pr_error("cannot get resource %s\n", buf); return -1; } dmx->dvr_irq = res->start; } } else { dmx->dvr_irq = -1; } */ dmx->demux.dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_PES_FILTERING | DMX_MEMORY_BASED_FILTERING | DMX_TS_DESCRAMBLING); dmx->demux.filternum = dmx->demux.feednum = FILTER_COUNT; dmx->demux.priv = advb; dmx->demux.start_feed = aml_dmx_hw_start_feed; dmx->demux.stop_feed = aml_dmx_hw_stop_feed; dmx->demux.write_to_decoder = NULL; spin_lock_init(&dmx->slock); if ((ret = dvb_dmx_init(&dmx->demux)) < 0) { pr_error("dvb_dmx failed: error %d",ret); goto error_dmx_init; } dmx->dmxdev.filternum = dmx->demux.feednum; dmx->dmxdev.demux = &dmx->demux.dmx; dmx->dmxdev.capabilities = 0; if ((ret = dvb_dmxdev_init(&dmx->dmxdev, &advb->dvb_adapter)) < 0) { pr_error("dvb_dmxdev_init failed: error %d",ret); goto error_dmxdev_init; } for (i=0; i<DMX_DEV_COUNT; i++) { int source = i+DMX_FRONTEND_0; dmx->hw_fe[i].source = source; if ((ret = dmx->demux.dmx.add_frontend(&dmx->demux.dmx, &dmx->hw_fe[i])) < 0) { pr_error("adding hw_frontend to dmx failed: error %d",ret); dmx->hw_fe[i].source = 0; goto error_add_hw_fe; } } dmx->mem_fe.source = DMX_MEMORY_FE; if ((ret = dmx->demux.dmx.add_frontend(&dmx->demux.dmx, &dmx->mem_fe)) < 0) { pr_error("adding mem_frontend to dmx failed: error %d",ret); goto error_add_mem_fe; } if ((ret = dmx->demux.dmx.connect_frontend(&dmx->demux.dmx, &dmx->hw_fe[1])) < 0) { pr_error("connect frontend failed: error %d",ret); goto error_connect_fe; } dmx->id = id; dmx->aud_chan = -1; dmx->vid_chan = -1; dmx->sub_chan = -1; if ((ret = aml_dmx_hw_init(dmx)) <0) { pr_error("demux hw init error %d", ret); dmx->id = -1; goto error_dmx_hw_init; } dvb_net_init(&advb->dvb_adapter, &dmx->dvb_net, &dmx->demux.dmx); return 0; error_dmx_hw_init: error_connect_fe: dmx->demux.dmx.remove_frontend(&dmx->demux.dmx, &dmx->mem_fe); error_add_mem_fe: error_add_hw_fe: for (i=0; i<DMX_DEV_COUNT; i++) { if (dmx->hw_fe[i].source) dmx->demux.dmx.remove_frontend(&dmx->demux.dmx, &dmx->hw_fe[i]); } dvb_dmxdev_release(&dmx->dmxdev); error_dmxdev_init: dvb_dmx_release(&dmx->demux); error_dmx_init: return ret; }