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; }
static int dvb_register(struct au0828_dev *dev) { struct au0828_dvb *dvb = &dev->dvb; int result; dprintk(1, "%s()\n", __func__); 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; 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; } 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; } 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 smsdvb_hotplug(struct smscore_device_t *coredev, struct device *device, int arrival) { struct smsclient_params_t params; struct smsdvb_client_t *client; int rc; /* device removal handled by onremove callback */ if (!arrival) return 0; if (smscore_get_device_mode(coredev) != 4) { sms_err("SMS Device mode is not set for " "DVB operation."); return 0; } client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { sms_err("kmalloc() failed"); return -ENOMEM; } /* register dvb adapter */ rc = dvb_register_adapter(&client->adapter, sms_get_board( smscore_get_board_id(coredev))->name, THIS_MODULE, device, adapter_nr); if (rc < 0) { sms_err("dvb_register_adapter() failed %d", rc); goto adapter_error; } /* init dvb demux */ client->demux.dmx.capabilities = DMX_TS_FILTERING; client->demux.filternum = 32; /* todo: nova ??? */ client->demux.feednum = 32; client->demux.start_feed = smsdvb_start_feed; client->demux.stop_feed = smsdvb_stop_feed; rc = dvb_dmx_init(&client->demux); if (rc < 0) { sms_err("dvb_dmx_init failed %d", rc); goto dvbdmx_error; } /* init dmxdev */ client->dmxdev.filternum = 32; client->dmxdev.demux = &client->demux.dmx; client->dmxdev.capabilities = 0; rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { sms_err("dvb_dmxdev_init failed %d", rc); goto dmxdev_error; } /* init and register frontend */ memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { sms_err("frontend registration failed %d", rc); goto frontend_error; } params.initial_id = 1; params.data_type = MSG_SMS_DVBT_BDA_DATA; params.onresponse_handler = smsdvb_onresponse; params.onremove_handler = smsdvb_onremove; params.context = client; rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { sms_err("smscore_register_client() failed %d", rc); goto client_error; } client->coredev = coredev; init_completion(&client->tune_done); init_completion(&client->stat_done); kmutex_lock(&g_smsdvb_clientslock); list_add(&client->entry, &g_smsdvb_clients); kmutex_unlock(&g_smsdvb_clientslock); sms_info("success"); sms_board_setup(coredev); return 0; client_error: dvb_unregister_frontend(&client->frontend); frontend_error: dvb_dmxdev_release(&client->dmxdev); dmxdev_error: dvb_dmx_release(&client->demux); dvbdmx_error: dvb_unregister_adapter(&client->adapter); adapter_error: kfree(client); return rc; }
static int register_dvb(struct em28xx_dvb *dvb, struct module *module, struct em28xx *dev, struct device *device) { int result; mutex_init(&dvb->lock); 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; } dvb->frontend->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl; dvb->adapter.priv = dev; result = dvb_register_frontend(&dvb->adapter, dvb->frontend); if (result < 0) { printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n", dev->name, result); goto fail_frontend; } 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 = start_feed; dvb->demux.stop_feed = 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; } 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; }
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("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("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_frontend_detach(dvb->frontend); dvb_unregister_frontend(dvb->frontend); } adapter_err: dvb_unregister_adapter(&dvb->adapter); err: return ret; } 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_frontend_detach(dvb->frontend); dvb_unregister_frontend(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; 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 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; }
int ttpci_budget_init (struct budget *budget, struct saa7146_dev* dev, struct saa7146_pci_extension_data *info) { int length = TS_WIDTH*TS_HEIGHT; int ret = 0; struct budget_info *bi = info->ext_priv; memset(budget, 0, sizeof(struct budget)); DEB_EE(("dev: %p, budget: %p\n", dev, budget)); budget->card = bi; budget->dev = (struct saa7146_dev *) dev; dvb_register_adapter(&budget->dvb_adapter, budget->card->name, THIS_MODULE); /* set dd1 stream a & b */ saa7146_write(dev, DD1_STREAM_B, 0x00000000); saa7146_write(dev, MC2, (MASK_09 | MASK_25)); saa7146_write(dev, MC2, (MASK_10 | MASK_26)); saa7146_write(dev, DD1_INIT, 0x02000000); saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26)); if (bi->type != BUDGET_FS_ACTIVY) budget->video_port = BUDGET_VIDEO_PORTB; else budget->video_port = BUDGET_VIDEO_PORTA; spin_lock_init(&budget->feedlock); /* the Siemens DVB needs this if you want to have the i2c chips get recognized before the main driver is loaded */ if (bi->type != BUDGET_FS_ACTIVY) saa7146_write(dev, GPIO_CTRL, 0x500000); /* GPIO 3 = 1 */ saa7146_i2c_adapter_prepare(dev, NULL, 0, SAA7146_I2C_BUS_BIT_RATE_120); budget->i2c_bus = dvb_register_i2c_bus (master_xfer, dev, budget->dvb_adapter, 0); if (!budget->i2c_bus) { dvb_unregister_adapter (budget->dvb_adapter); return -ENOMEM; } ttpci_eeprom_parse_mac(budget->i2c_bus); if( NULL == (budget->grabbing = saa7146_vmalloc_build_pgtable(dev->pci,length,&budget->pt))) { ret = -ENOMEM; goto err; } saa7146_write(dev, PCI_BT_V1, 0x001c0000); /* upload all */ saa7146_write(dev, GPIO_CTRL, 0x000000); tasklet_init (&budget->vpe_tasklet, vpeirq, (unsigned long) budget); /* frontend power on */ if (bi->type == BUDGET_FS_ACTIVY) saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); else saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI); if (budget_register(budget) == 0) { return 0; } err: if (budget->grabbing) vfree(budget->grabbing); dvb_unregister_i2c_bus (master_xfer,budget->i2c_bus->adapter, budget->i2c_bus->id); dvb_unregister_adapter (budget->dvb_adapter); return ret; }
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; } /* Attach the frontend */ as102_dev->dvb_fe = dvb_attach(as102_attach, as102_dev->name, &as102_fe_ops, &as102_dev->bus_adap, as102_dev->elna_cfg); if (!as102_dev->dvb_fe) { dev_err(dev, "%s: as102_attach() failed: %d", __func__, ret); goto efereg; } ret = dvb_register_frontend(&as102_dev->dvb_adap, 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; }
static void __exit avia_napi_exit(void) { dvb_i2c_bridge_unregister(adap); dvb_unregister_adapter(adap); }
int 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) { result = -ENOMEM; dprintk(MANTIS_ERROR, 1, "FE <NULL>"); goto err5; } result = dvb_register_frontend(&mantis->dvb_adapter, mantis->fe); if (result) { 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; /* Error conditions .. */ err5: tasklet_kill(&mantis->tasklet); dvb_net_release(&mantis->dvbnet); if (mantis->fe) { 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 SysDVBRegisterAdapter(dvb_t dev, const char *name, int max_filters, void *device) #endif { int ret = 0; DVBDev *p = (DVBDev *)dev; DBG_fCDVB("\n"); if( !p ) return -ENODEV; #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17) if( !device ) return -EINVAL; #endif #if 0 strncpy(p->name, name, sizeof(p->name)); #else SysStrNCpy(p->name, name, sizeof(p->name)); #endif #if DVB_REG_NEWSTYLE #if 0 p->adapter = kmalloc(sizeof(struct dvb_adapter), GFP_KERNEL); #else p->adapter = SysKMalloc(sizeof(struct dvb_adapter)+512, eKMALLOC_KERNEL); #endif DBG_fCDVB("p->adapter=%p\n", p->adapter); if(NULL == p->adapter) { DBG_fCDVB("cannot kmalloc DVB adapter\n"); ret = -ENOMEM; goto fail0; } #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25) p->adapter->device = device; ret = dvb_register_adapter(p->adapter, p->name, THIS_MODULE, (struct device *)device, dvb_adapter_nr); #elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17) p->adapter->device = device; ret = dvb_register_adapter(p->adapter, p->name, THIS_MODULE, (struct device *)device); #else ret = dvb_register_adapter(p->adapter, p->name, THIS_MODULE); #endif #else ret = dvb_register_adapter(&p->adapter, p->name, THIS_MODULE); #endif if(ret<0) { #if 0 printk(KERN_WARNING "%s: failed to register adapter(%d)", p->name, ret); #else SysPrintk(KERN_WARNING "%s: failed to register adapter(%d)", p->name, ret); #endif goto fail1; } #if 0 printk(KERN_INFO "%s registered DVB adapter %d\n", name, p->adapter->num); #else SysPrintk(KERN_INFO "%s registered DVB adapter %d\n", name, p->adapter->num); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) p->i2c_bus = dvb_register_i2c_bus(master_xfer, dev, p->adapter, 111); if(!p->i2c_bus) { dvb_unregister_adapter(p->adapter); #if 0 printk(KERN_WARNING "%s: failed to register dvb-i2c\n", p->name); #else SysPrintk(KERN_WARNING "%s: failed to register dvb-i2c\n", p->name); #endif return -ENOMEM; } DBG_fCDVB("registered dvb-i2c %p\n", p->i2c_bus); #endif DBG_fCDVB("init software demux, demux_sw=%p\n", &p->demux_sw); #if 0 memset(&p->demux_sw, 0, sizeof(struct dvb_demux)); #else SysMemSet(&p->demux_sw, 0, sizeof(struct dvb_demux)); #endif p->demux_sw.priv = (void *)p; p->demux_sw.filternum = max_filters; p->demux_sw.feednum = max_filters; p->demux_sw.start_feed = demux_sw_start_feed; p->demux_sw.stop_feed = demux_sw_stop_feed; p->demux_sw.write_to_decoder = NULL; p->demux_sw.dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING ); ret = dvb_dmx_init(&p->demux_sw); if(ret) { printk(KERN_WARNING "%s: failed to init demux(%d)\n", p->name, ret); goto fail2; } DBG_fCDVB("init demux devices, dmxdev_sw=%p\n", &p->dmxdev_sw); p->dmxdev_sw.filternum = max_filters; p->dmxdev_sw.demux = &p->demux_sw.dmx; p->dmxdev_sw.capabilities = 0; ret = dvb_dmxdev_init(&p->dmxdev_sw, p->adapter); if(ret) { #if 0 printk(KERN_WARNING "%s: failed to init dmxdev\n", p->name); #else SysPrintk(KERN_WARNING "%s: failed to init dmxdev\n", p->name); #endif goto fail3; } DBG_fCDVB("add h/w frontend\n"); p->hw_frontend.source = DMX_FRONTEND_0; ret = p->demux_sw.dmx.add_frontend(&p->demux_sw.dmx, &p->hw_frontend); if(ret < 0) { #if 0 printk(KERN_WARNING "%s: cannot add hw frontend\n", p->name); #else SysPrintk(KERN_WARNING "%s: cannot add hw frontend, ret=%d\n", p->name, ret); #endif goto fail4; } DBG_fCDVB("add memory frontend\n"); p->mem_frontend.source = DMX_MEMORY_FE; ret = p->demux_sw.dmx.add_frontend(&p->demux_sw.dmx, &p->mem_frontend); if(ret < 0) { #if 0 printk(KERN_WARNING "%s: cannot add mem frontend\n", p->name); #else SysPrintk(KERN_WARNING "%s: cannot add mem frontend\n", p->name); #endif goto fail5; } ret = p->demux_sw.dmx.connect_frontend( &p->demux_sw.dmx, &p->mem_frontend); if(ret < 0) { #if 0 printk(KERN_WARNING "%s: cannot connect frontend\n", p->name); #else SysPrintk(KERN_WARNING "%s: cannot connect frontend, ret=%d\n", p->name, ret); #endif goto fail6; } DBG_fCDVB("done\n"); goto done; fail6: p->demux_sw.dmx.remove_frontend(&p->demux_sw.dmx, &p->mem_frontend); fail5: p->demux_sw.dmx.remove_frontend(&p->demux_sw.dmx, &p->hw_frontend); fail4: dvb_dmxdev_release(&p->dmxdev_sw); fail3: dvb_dmx_release(&p->demux_sw); fail2: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) dvb_unregister_i2c_bus(master_xfer, p->i2c_bus->adapter, p->i2c_bus->id); #endif dvb_unregister_adapter(p->adapter); fail1: #if DVB_REG_NEWSTYLE #if 0 kfree(p->adapter); #else SysKFree(p->adapter); #endif fail0: #endif done: return ret; }
static int __init vtunerc_init(void) { struct vtunerc_ctx *ctx = NULL; struct dvb_demux *dvbdemux; struct dmx_demux *dmx; int ret = -EINVAL, i, idx; printk(KERN_INFO "virtual DVB adapter driver, version " VTUNERC_MODULE_VERSION ", (c) 2010-11 Honza Petrous, SmartImp.cz\n"); request_module("dvb-core"); /* FIXME: dunno which way it should work :-/ */ for (idx = 0; idx < config.devices; idx++) { ctx = kzalloc(sizeof(struct vtunerc_ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; vtunerc_tbl[idx] = ctx; ctx->idx = idx; ctx->config = &config; ctx->ctrldev_request.type = -1; ctx->ctrldev_response.type = -1; init_waitqueue_head(&ctx->ctrldev_wait_request_wq); init_waitqueue_head(&ctx->ctrldev_wait_response_wq); /* dvb */ /* create new adapter */ ret = dvb_register_adapter(&ctx->dvb_adapter, DRIVER_NAME, THIS_MODULE, NULL, adapter_nr); if (ret < 0) goto err_kfree; ctx->dvb_adapter.priv = ctx; memset(&ctx->demux, 0, sizeof(ctx->demux)); dvbdemux = &ctx->demux; dvbdemux->priv = ctx; dvbdemux->filternum = MAX_PIDTAB_LEN; dvbdemux->feednum = MAX_PIDTAB_LEN; dvbdemux->start_feed = vtunerc_start_feed; dvbdemux->stop_feed = vtunerc_stop_feed; dvbdemux->dmx.capabilities = 0; ret = dvb_dmx_init(dvbdemux); if (ret < 0) goto err_dvb_unregister_adapter; dmx = &dvbdemux->dmx; ctx->hw_frontend.source = DMX_FRONTEND_0; ctx->mem_frontend.source = DMX_MEMORY_FE; ctx->dmxdev.filternum = MAX_PIDTAB_LEN; ctx->dmxdev.demux = dmx; ret = dvb_dmxdev_init(&ctx->dmxdev, &ctx->dvb_adapter); if (ret < 0) goto err_dvb_dmx_release; ret = dmx->add_frontend(dmx, &ctx->hw_frontend); if (ret < 0) goto err_dvb_dmxdev_release; ret = dmx->add_frontend(dmx, &ctx->mem_frontend); if (ret < 0) goto err_remove_hw_frontend; ret = dmx->connect_frontend(dmx, &ctx->hw_frontend); if (ret < 0) goto err_remove_mem_frontend; sema_init(&ctx->xchange_sem, 1); sema_init(&ctx->ioctl_sem, 1); sema_init(&ctx->tswrite_sem, 1); /* init pid table */ for (i = 0; i < MAX_PIDTAB_LEN; i++) ctx->pidtab[i] = PID_UNKNOWN; #ifdef CONFIG_PROC_FS { char procfilename[64]; sprintf(procfilename, VTUNERC_PROC_FILENAME, ctx->idx); ctx->procname = my_strdup(procfilename); if (create_proc_read_entry(ctx->procname, 0, NULL, vtunerc_read_proc, ctx) == 0) printk(KERN_WARNING "vtunerc%d: Unable to register '%s' proc file\n", ctx->idx, ctx->procname); } #endif } vtunerc_register_ctrldev(ctx); out: return ret; dmx->disconnect_frontend(dmx); err_remove_mem_frontend: dmx->remove_frontend(dmx, &ctx->mem_frontend); err_remove_hw_frontend: dmx->remove_frontend(dmx, &ctx->hw_frontend); err_dvb_dmxdev_release: dvb_dmxdev_release(&ctx->dmxdev); err_dvb_dmx_release: dvb_dmx_release(dvbdemux); err_dvb_unregister_adapter: dvb_unregister_adapter(&ctx->dvb_adapter); err_kfree: kfree(ctx); goto out; }
int fdtv_dvb_register(struct firedtv *fdtv) { int err; err = dvb_register_adapter(&fdtv->adapter, fdtv_model_names[fdtv->type], THIS_MODULE, fdtv->device, adapter_nr); if (err < 0) goto fail_log; 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; dvb_net_init(&fdtv->adapter, &fdtv->dvbnet, &fdtv->demux.dmx); fdtv_frontend_init(fdtv); 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); 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 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; }
static int smsdvb_hotplug(struct smscore_device_t *coredev, struct device *device, int arrival) { struct smsclient_params_t params; struct smsdvb_client_t *client; int rc; /* device removal handled by onremove callback */ if (!arrival) return 0; client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) return -ENOMEM; /* register dvb adapter */ rc = dvb_register_adapter(&client->adapter, sms_get_board( smscore_get_board_id(coredev))->name, THIS_MODULE, device, adapter_nr); if (rc < 0) { pr_err("dvb_register_adapter() failed %d\n", rc); goto adapter_error; } dvb_register_media_controller(&client->adapter, coredev->media_dev); /* init dvb demux */ client->demux.dmx.capabilities = DMX_TS_FILTERING; client->demux.filternum = 32; /* todo: nova ??? */ client->demux.feednum = 32; client->demux.start_feed = smsdvb_start_feed; client->demux.stop_feed = smsdvb_stop_feed; rc = dvb_dmx_init(&client->demux); if (rc < 0) { pr_err("dvb_dmx_init failed %d\n", rc); goto dvbdmx_error; } /* init dmxdev */ client->dmxdev.filternum = 32; client->dmxdev.demux = &client->demux.dmx; client->dmxdev.capabilities = 0; rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { pr_err("dvb_dmxdev_init failed %d\n", rc); goto dmxdev_error; } /* init and register frontend */ memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); switch (smscore_get_device_mode(coredev)) { case DEVICE_MODE_DVBT: case DEVICE_MODE_DVBT_BDA: client->frontend.ops.delsys[0] = SYS_DVBT; break; case DEVICE_MODE_ISDBT: case DEVICE_MODE_ISDBT_BDA: client->frontend.ops.delsys[0] = SYS_ISDBT; break; } rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { pr_err("frontend registration failed %d\n", rc); goto frontend_error; } params.initial_id = 1; params.data_type = MSG_SMS_DVBT_BDA_DATA; params.onresponse_handler = smsdvb_onresponse; params.onremove_handler = smsdvb_onremove; params.context = client; rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { pr_err("smscore_register_client() failed %d\n", rc); goto client_error; } client->coredev = coredev; init_completion(&client->tune_done); init_completion(&client->stats_done); kmutex_lock(&g_smsdvb_clientslock); list_add(&client->entry, &g_smsdvb_clients); kmutex_unlock(&g_smsdvb_clientslock); client->event_fe_state = -1; client->event_unc_state = -1; sms_board_dvb3_event(client, DVB3_EVENT_HOTPLUG); sms_board_setup(coredev); if (smsdvb_debugfs_create(client) < 0) pr_info("failed to create debugfs node\n"); rc = dvb_create_media_graph(&client->adapter, true); if (rc < 0) { pr_err("dvb_create_media_graph failed %d\n", rc); goto client_error; } pr_info("DVB interface registered.\n"); return 0; client_error: dvb_unregister_frontend(&client->frontend); frontend_error: dvb_dmxdev_release(&client->dmxdev); dmxdev_error: dvb_dmx_release(&client->demux); dvbdmx_error: smsdvb_media_device_unregister(client); dvb_unregister_adapter(&client->adapter); adapter_error: kfree(client); return rc; }
int ttpci_budget_init(struct budget *budget, struct saa7146_dev *dev, struct saa7146_pci_extension_data *info, struct module *owner, short *adapter_nums) { int ret = 0; struct budget_info *bi = info->ext_priv; int max_bufsize; int height_mask; memset(budget, 0, sizeof(struct budget)); dprintk(2, "dev: %p, budget: %p\n", dev, budget); budget->card = bi; budget->dev = (struct saa7146_dev *) dev; switch(budget->card->type) { case BUDGET_FS_ACTIVY: budget->buffer_width = TS_WIDTH_ACTIVY; max_bufsize = TS_MAX_BUFSIZE_K_ACTIVY; height_mask = TS_HEIGHT_MASK_ACTIVY; break; case BUDGET_KNC1C: case BUDGET_KNC1CP: case BUDGET_CIN1200C: case BUDGET_KNC1C_MK3: case BUDGET_KNC1C_TDA10024: case BUDGET_KNC1CP_MK3: case BUDGET_CIN1200C_MK3: budget->buffer_width = TS_WIDTH_DVBC; max_bufsize = TS_MAX_BUFSIZE_K_DVBC; height_mask = TS_HEIGHT_MASK_DVBC; break; default: budget->buffer_width = TS_WIDTH; max_bufsize = TS_MAX_BUFSIZE_K; height_mask = TS_HEIGHT_MASK; } if (dma_buffer_size < TS_MIN_BUFSIZE_K) dma_buffer_size = TS_MIN_BUFSIZE_K; else if (dma_buffer_size > max_bufsize) dma_buffer_size = max_bufsize; budget->buffer_height = dma_buffer_size * 1024 / budget->buffer_width; if (budget->buffer_height > 0xfff) { budget->buffer_height /= 2; budget->buffer_height &= height_mask; budget->buffer_size = 2 * budget->buffer_height * budget->buffer_width; } else { budget->buffer_height &= height_mask; budget->buffer_size = budget->buffer_height * budget->buffer_width; } budget->buffer_warning_threshold = budget->buffer_size * 80/100; budget->buffer_warnings = 0; budget->buffer_warning_time = jiffies; dprintk(2, "%s: buffer type = %s, width = %d, height = %d\n", budget->dev->name, budget->buffer_size > budget->buffer_width * budget->buffer_height ? "odd/even" : "single", budget->buffer_width, budget->buffer_height); printk("%s: dma buffer size %u\n", budget->dev->name, budget->buffer_size); ret = dvb_register_adapter(&budget->dvb_adapter, budget->card->name, owner, &budget->dev->pci->dev, adapter_nums); if (ret < 0) return ret; /* set dd1 stream a & b */ saa7146_write(dev, DD1_STREAM_B, 0x00000000); saa7146_write(dev, MC2, (MASK_09 | MASK_25)); saa7146_write(dev, MC2, (MASK_10 | MASK_26)); saa7146_write(dev, DD1_INIT, 0x02000000); saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26)); if (bi->type != BUDGET_FS_ACTIVY) budget->video_port = BUDGET_VIDEO_PORTB; else budget->video_port = BUDGET_VIDEO_PORTA; spin_lock_init(&budget->feedlock); spin_lock_init(&budget->debilock); /* the Siemens DVB needs this if you want to have the i2c chips get recognized before the main driver is loaded */ if (bi->type != BUDGET_FS_ACTIVY) saa7146_write(dev, GPIO_CTRL, 0x500000); /* GPIO 3 = 1 */ strlcpy(budget->i2c_adap.name, budget->card->name, sizeof(budget->i2c_adap.name)); saa7146_i2c_adapter_prepare(dev, &budget->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); strcpy(budget->i2c_adap.name, budget->card->name); if (i2c_add_adapter(&budget->i2c_adap) < 0) { ret = -ENOMEM; goto err_dvb_unregister; } ttpci_eeprom_parse_mac(&budget->i2c_adap, budget->dvb_adapter.proposed_mac); budget->grabbing = saa7146_vmalloc_build_pgtable(dev->pci, budget->buffer_size, &budget->pt); if (NULL == budget->grabbing) { ret = -ENOMEM; goto err_del_i2c; } saa7146_write(dev, PCI_BT_V1, 0x001c0000); /* upload all */ saa7146_write(dev, GPIO_CTRL, 0x000000); tasklet_init(&budget->vpe_tasklet, vpeirq, (unsigned long) budget); /* frontend power on */ if (bi->type != BUDGET_FS_ACTIVY) saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI); if ((ret = budget_register(budget)) == 0) return 0; /* Everything OK */ /* An error occurred, cleanup resources */ saa7146_vfree_destroy_pgtable(dev->pci, budget->grabbing, &budget->pt); err_del_i2c: i2c_del_adapter(&budget->i2c_adap); err_dvb_unregister: dvb_unregister_adapter(&budget->dvb_adapter); return ret; }
int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums) { int i; int ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name, adap->dev->owner, &adap->dev->udev->dev, adapter_nums); if (ret < 0) { deb_info("dvb_register_adapter failed: error %d", ret); goto err; } adap->dvb_adap.priv = adap; adap->dvb_adap.fe_ioctl_override = adap->props.fe_ioctl_override; if (adap->dev->props.read_mac_address) { if (adap->dev->props.read_mac_address(adap->dev,adap->dvb_adap.proposed_mac) == 0) info("MAC address: %pM",adap->dvb_adap.proposed_mac); else err("MAC address reading failed."); } adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; adap->demux.priv = adap; adap->demux.filternum = 0; for (i = 0; i < adap->props.num_frontends; i++) { if (adap->demux.filternum < adap->fe_adap[i].max_feed_count) adap->demux.filternum = adap->fe_adap[i].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; if ((ret = dvb_dmx_init(&adap->demux)) < 0) { err("dvb_dmx_init failed: error %d",ret); goto err_dmx; } adap->dmxdev.filternum = adap->demux.filternum; adap->dmxdev.demux = &adap->demux.dmx; adap->dmxdev.capabilities = 0; if ((ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap)) < 0) { err("dvb_dmxdev_init failed: error %d",ret); goto err_dmx_dev; } if ((ret = dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx)) < 0) { err("dvb_net_init failed: error %d",ret); goto err_net_init; } adap->state |= DVB_USB_ADAP_STATE_DVB; return 0; err_net_init: dvb_dmxdev_release(&adap->dmxdev); err_dmx_dev: dvb_dmx_release(&adap->demux); err_dmx: dvb_unregister_adapter(&adap->dvb_adap); err: return ret; }
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 smsdvb_hotplug(struct smscore_device_t *coredev, struct device *device, int arrival) { struct smsclient_params_t params; struct smsdvb_client_t *client; int rc; int mode = smscore_get_device_mode(coredev); //mode = 6; /* device removal handled by onremove callback */ if (!arrival) return 0; if ( (mode != DEVICE_MODE_DVBT_BDA) && (mode != DEVICE_MODE_ISDBT_BDA) ) { sms_err("SMS Device mode is not set for " "DVB operation."); return 0; } client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { sms_err("kmalloc() failed"); return -ENOMEM; } /* register dvb adapter */ #ifdef SMS_DVB_OLD_DVB_REGISTER_ADAPTER rc = dvb_register_adapter(&client->adapter, sms_get_board(smscore_get_board_id(coredev))-> name, THIS_MODULE, device); #else rc = dvb_register_adapter(&client->adapter, sms_get_board(smscore_get_board_id(coredev))-> name, THIS_MODULE, device, adapter_nr); #endif if (rc < 0) { sms_err("dvb_register_adapter() failed %d", rc); goto adapter_error; } /* init dvb demux */ client->demux.dmx.capabilities = DMX_TS_FILTERING; client->demux.filternum = 32; /* todo: nova ??? */ client->demux.feednum = 32; client->demux.start_feed = smsdvb_start_feed; client->demux.stop_feed = smsdvb_stop_feed; rc = dvb_dmx_init(&client->demux); if (rc < 0) { sms_err("dvb_dmx_init failed %d", rc); goto dvbdmx_error; } /* init dmxdev */ client->dmxdev.filternum = 32; client->dmxdev.demux = &client->demux.dmx; client->dmxdev.capabilities = 0; rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { sms_err("dvb_dmxdev_init failed %d", rc); goto dmxdev_error; } //add by luis printk("debug: %s, %d, %s>>>>>>>>>>>>>>>>>>>>\n", __FILE__, __LINE__, __FUNCTION__); //add by luis /* init and register frontend */ memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); //add by luis printk("debug: %s, %d, %s>>>>>>>>>>>>>>>>>>>>\n", __FILE__, __LINE__, __FUNCTION__); //add by luis rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { sms_err("frontend registration failed %d", rc); goto frontend_error; } params.initial_id = 1; params.data_type = MSG_SMS_DVBT_BDA_DATA; params.onresponse_handler = smsdvb_onresponse; params.onremove_handler = smsdvb_onremove; params.context = client; //add by luis printk("debug: %s, %d, %s>>>>>>>>>>>>>>>>>>>>\n", __FILE__, __LINE__, __FUNCTION__); //add by luis rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { sms_err("smscore_register_client() failed %d", rc); goto client_error; } client->coredev = coredev; init_completion(&client->tune_done); init_completion(&client->get_stats_done); kmutex_lock(&g_smsdvb_clientslock); list_add(&client->entry, &g_smsdvb_clients); kmutex_unlock(&g_smsdvb_clientslock); client->event_fe_state = -1; client->event_unc_state = -1; sms_board_dvb3_event(client, DVB3_EVENT_HOTPLUG); //add by luis printk("debug: %s, %d, %s>>>>>>>>>>>>>>>>>>>>\n", __FILE__, __LINE__, __FUNCTION__); //add by luis sms_info("success"); return 0; client_error: dvb_unregister_frontend(&client->frontend); frontend_error: dvb_dmxdev_release(&client->dmxdev); dmxdev_error: dvb_dmx_release(&client->demux); dvbdmx_error: dvb_unregister_adapter(&client->adapter); adapter_error: kfree(client); return rc; }