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;
}
static int mpq_tspp_dmx_init(
struct dvb_adapter *mpq_adapter,
struct mpq_demux *mpq_demux)
{
int result;
MPQ_DVB_DBG_PRINT("%s executed\n", __func__);
mpq_dmx_tspp_info.ion_client = mpq_demux->ion_client;
mpq_demux->demux.dmx.capabilities =
DMX_TS_FILTERING |
DMX_PES_FILTERING |
DMX_SECTION_FILTERING |
DMX_MEMORY_BASED_FILTERING |
DMX_CRC_CHECKING |
DMX_TS_DESCRAMBLING;
mpq_demux->demux.priv = (void *)mpq_demux;
mpq_demux->demux.filternum = TSPP_MAX_SECTION_FILTER_NUM;
mpq_demux->demux.feednum = MPQ_MAX_DMX_FILES;
mpq_demux->demux.start_feed = mpq_tspp_dmx_start_filtering;
mpq_demux->demux.stop_feed = mpq_tspp_dmx_stop_filtering;
mpq_demux->demux.write_to_decoder = mpq_tspp_dmx_write_to_decoder;
mpq_demux->demux.decoder_fullness_init = mpq_dmx_decoder_fullness_init;
mpq_demux->demux.decoder_fullness_wait = mpq_dmx_decoder_fullness_wait;
mpq_demux->demux.decoder_fullness_abort =
mpq_dmx_decoder_fullness_abort;
mpq_demux->demux.decoder_buffer_status = mpq_dmx_decoder_buffer_status;
mpq_demux->demux.reuse_decoder_buffer = mpq_dmx_reuse_decoder_buffer;
mpq_demux->demux.set_cipher_op = mpq_dmx_set_cipher_ops;
mpq_demux->demux.oob_command = mpq_dmx_oob_command;
mpq_demux->demux.convert_ts = mpq_dmx_convert_tts;
result = dvb_dmx_init(&mpq_demux->demux);
if (result < 0) {
MPQ_DVB_ERR_PRINT("%s: dvb_dmx_init failed\n", __func__);
goto init_failed;
}
mpq_demux->dmxdev.filternum = MPQ_MAX_DMX_FILES;
mpq_demux->dmxdev.demux = &mpq_demux->demux.dmx;
mpq_demux->dmxdev.capabilities = DMXDEV_CAP_DUPLEX;
mpq_demux->dmxdev.demux->set_source = mpq_dmx_set_source;
mpq_demux->dmxdev.demux->get_stc = mpq_tspp_dmx_get_stc;
mpq_demux->dmxdev.demux->get_caps = mpq_tspp_dmx_get_caps;
mpq_demux->dmxdev.demux->map_buffer = mpq_dmx_map_buffer;
mpq_demux->dmxdev.demux->unmap_buffer = mpq_dmx_unmap_buffer;
mpq_demux->dmxdev.demux->write = mpq_dmx_write;
result = dvb_dmxdev_init(&mpq_demux->dmxdev, mpq_adapter);
if (result < 0) {
MPQ_DVB_ERR_PRINT("%s: dvb_dmxdev_init failed (errno=%d)\n",
__func__,
result);
goto init_failed_dmx_release;
}
mpq_dmx_init_debugfs_entries(mpq_demux);
return 0;
init_failed_dmx_release:
dvb_dmx_release(&mpq_demux->demux);
init_failed:
return result;
}
int videobuf_dvb_register(struct videobuf_dvb *dvb,
struct module *module,
void *adapter_priv,
struct device *device,
short *adapter_nr)
{
int result;
mutex_init(&dvb->lock);
/* register adapter */
result = dvb_register_adapter(&dvb->adapter, dvb->name, module, device,
adapter_nr);
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_frontend_detach(dvb->frontend);
dvb_unregister_adapter(&dvb->adapter);
fail_adapter:
return result;
}
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;
}
int as102_dvb_register(struct as102_dev_t *as102_dev)
{
int ret = 0;
ENTER();
dprintk(debug,"1 dvb_register_adapter\n");
ret = dvb_register_adapter(&as102_dev->dvb_adap,
as102_dev->name,
THIS_MODULE,
&as102_dev->bus_adap.usb_dev->dev,
adapter_nr
);
if (ret < 0) {
err("%s: dvb_register_adapter() failed (errno = %d)",
__func__, ret);
goto failed;
}
/*j00zek comment: We don't initiate demux here as we use one from player2*/
#if 0
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.write_to_decoder = NULL;
as102_dev->dvb_dmx.dmx.set_source = NULL; //as102_dvb_dmx_SetSource;
as102_dev->dvb_dmx.dmx.capabilities = DMX_TS_FILTERING |
DMX_SECTION_FILTERING | DMX_MEMORY_BASED_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;
dprintk(debug,"3 dvb_dmx_init\n");
ret = dvb_dmx_init(&as102_dev->dvb_dmx);
if (ret < 0) {
err("%s: dvb_dmx_init() failed (errno = %d)", __func__, ret);
goto failed;
}
dprintk(debug,"4 dvb_dmxdev_init\n");
ret = dvb_dmxdev_init(&as102_dev->dvb_dmxdev, &as102_dev->dvb_adap);
if (ret < 0) {
err("%s: dvb_dmxdev_init() failed (errno = %d)", __func__,
ret);
goto failed;
}
#endif
dprintk(debug,"2 dvb_register_frontend\n");
ret = as102_dvb_register_fe(as102_dev, &as102_dev->dvb_fe);
if (ret < 0) {
err("%s: as102_dvb_register_frontend() failed (errno = %d)",
__func__, ret);
goto failed;
}
/* init bus mutex for token locking */
mutex_init(&as102_dev->bus_adap.lock);
/* init start / stop stream mutex */
mutex_init(&as102_dev->sem);
#if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
/*
* 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");
#endif
/* start/stop pid from dvb_demux.c */
as102_dev_ = as102_dev;//store dvb_adapter to use later when feeding from demux_player2
extern_startfeed_init(as102_dvb_dmx_start_feed,as102_dvb_dmx_stop_feed);
failed:
LEAVE();
/* FIXME: free dvb_XXX */
return ret;
}
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 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 __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;
}
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;
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");
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;
}
int as102_dvb_register(struct as102_dev_t *as102_dev)
{
int ret = 0;
ENTER();
#if defined(CONFIG_DVB_CORE) || defined(CONFIG_DVB_CORE_MODULE)
ret = dvb_register_adapter(&as102_dev->dvb_adap,
as102_dev->name,
THIS_MODULE,
#if defined(CONFIG_AS102_USB)
&as102_dev->bus_adap.usb_dev->dev
#elif defined(CONFIG_AS102_SPI)
&as102_dev->bus_adap.spi_dev->dev
#else
#error >>> dvb_register_adapter <<<
#endif
#ifdef DVB_DEFINE_MOD_OPT_ADAPTER_NR
, adapter_nr
#endif
);
if (ret < 0) {
err("%s: dvb_register_adapter() failed (errno = %d)",
__func__, ret);
goto failed;
}
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) {
err("%s: dvb_dmx_init() failed (errno = %d)", __func__, ret);
goto failed;
}
ret = dvb_dmxdev_init(&as102_dev->dvb_dmxdev, &as102_dev->dvb_adap);
if (ret < 0) {
err("%s: dvb_dmxdev_init() failed (errno = %d)", __func__,
ret);
goto failed;
}
ret = as102_dvb_register_fe(as102_dev, &as102_dev->dvb_fe);
if (ret < 0) {
err("%s: as102_dvb_register_frontend() failed (errno = %d)",
__func__, ret);
goto failed;
}
#endif
/* init bus mutex for token locking */
mutex_init(&as102_dev->bus_adap.lock);
/* init start / stop stream mutex */
mutex_init(&as102_dev->sem);
#if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
/*
* 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");
#endif
failed:
LEAVE();
/* FIXME: free dvb_XXX */
return ret;
}
struct stfe *stfe_create(void *private_data, void *start_feed, void *stop_feed)
{
struct stfe *stfe;
int channel;
int result;
if (!(stfe = kmalloc(sizeof(struct stfe), GFP_KERNEL)))
return NULL;
printk("%s: Allocated stfe @ 0x%p\n", __FUNCTION__, stfe);
memset(stfe, 0, sizeof(struct stfe));
sema_init(&stfe->sem, 0);
up(&stfe->sem);
for (channel = 0; channel < STFE_MAXCHANNEL; ++channel)
{
stfe->channel[channel].id = channel;
stfe->channel[channel].stfe = stfe;
stfe->channel[channel].havana_id = private_data;
}
dvb_register_adapter(&stfe->adapter, "ST Generic Front End Driver", THIS_MODULE, NULL, adapter_nr);
stfe->adapter.priv = stfe;
memset(&stfe->dvb_demux, 0, sizeof(stfe->dvb_demux));
stfe->dvb_demux.dmx.capabilities =
DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
stfe->dvb_demux.priv = private_data;
stfe->dvb_demux.filternum = 48;
stfe->dvb_demux.feednum = STFE_MAXCHANNEL;
stfe->dvb_demux.start_feed = start_feed;
stfe->dvb_demux.stop_feed = stop_feed;
stfe->dvb_demux.write_to_decoder = NULL; /* write_to_decoder;*/
if ((result = dvb_dmx_init(&stfe->dvb_demux)) < 0)
{
printk("stfe_init: dvb_dmx_init failed (errno = %d)\n",
result);
goto err;
}
stfe->dmxdev.filternum = stfe->dvb_demux.filternum;
stfe->dmxdev.demux = &stfe->dvb_demux.dmx;
stfe->dmxdev.capabilities = 0;
if ((result = dvb_dmxdev_init(&stfe->dmxdev, &stfe->adapter)) < 0)
{
printk("stfe_init: dvb_dmxdev_init failed (errno = %d)\n",
result);
dvb_dmx_release(&stfe->dvb_demux);
goto err;
}
stfe->hw_frontend.source = DMX_FRONTEND_0;
result = stfe->dvb_demux.dmx.add_frontend(&stfe->dvb_demux.dmx, &stfe->hw_frontend);
if (result < 0)
return NULL;
stfe->mem_frontend.source = DMX_MEMORY_FE;
result = stfe->dvb_demux.dmx.add_frontend(&stfe->dvb_demux.dmx, &stfe->mem_frontend);
if (result < 0)
return NULL;
result = stfe->dvb_demux.dmx.connect_frontend(&stfe->dvb_demux.dmx, &stfe->hw_frontend);
if (result < 0)
return NULL;
stfe->driver_data = private_data;
//i2c_add_driver(&st_tuner_i2c_driver);
return stfe;
err:
return NULL;
}
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->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;
}
static int aml_dvb_dmx_init(struct aml_dvb *advb, struct aml_dmx *dmx, int id)
{
int i, ret;
#ifndef CONFIG_OF
struct resource *res;
char buf[32];
#endif
switch(id){
case 0:
dmx->dmx_irq = INT_DEMUX;
break;
case 1:
dmx->dmx_irq = INT_DEMUX_1;
break;
case 2:
dmx->dmx_irq = INT_DEMUX_2;
break;
}
#ifndef CONFIG_OF
snprintf(buf, sizeof(buf), "demux%d_irq", id);
res = platform_get_resource_byname(advb->pdev, IORESOURCE_IRQ, buf);
if (res) {
dmx->dmx_irq = res->start;
}
#endif
dmx->source = -1;
dmx->dump_ts_select = 0;
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;
if ((ret = dvb_dmx_init(&dmx->demux)) < 0) {
pr_error("dvb_dmx failed: error %d\n",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\n",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;
dmx->pcr_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;
}
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;
}
mutex_init(&adap->sync_mutex);
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 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;
}
/**
* Initialize a single demux device.
*
* @mpq_adapter: MPQ DVB adapter
* @mpq_demux: The demux device to initialize
*
* Return error code
*/
static int mpq_tspp_dmx_init(
struct dvb_adapter *mpq_adapter,
struct mpq_demux *mpq_demux)
{
int result;
MPQ_DVB_DBG_PRINT("%s executed\n", __func__);
/* Set the kernel-demux object capabilities */
mpq_demux->demux.dmx.capabilities =
DMX_TS_FILTERING |
DMX_PES_FILTERING |
DMX_SECTION_FILTERING |
DMX_MEMORY_BASED_FILTERING |
DMX_CRC_CHECKING |
DMX_TS_DESCRAMBLING;
/* Set dvb-demux "virtual" function pointers */
mpq_demux->demux.priv = (void *)mpq_demux;
mpq_demux->demux.filternum = TSPP_MAX_SECTION_FILTER_NUM;
mpq_demux->demux.feednum = MPQ_MAX_DMX_FILES;
mpq_demux->demux.start_feed = mpq_tspp_dmx_start_filtering;
mpq_demux->demux.stop_feed = mpq_tspp_dmx_stop_filtering;
mpq_demux->demux.write_to_decoder = NULL;
mpq_demux->demux.decoder_fullness_init = NULL;
mpq_demux->demux.decoder_fullness_wait = NULL;
mpq_demux->demux.decoder_fullness_abort = NULL;
mpq_demux->demux.decoder_buffer_status = NULL;
/* Initialize dvb_demux object */
result = dvb_dmx_init(&mpq_demux->demux);
if (result < 0) {
MPQ_ERR_PRINT("%s: dvb_dmx_init failed\n", __func__);
goto init_failed;
}
/* Now initailize the dmx-dev object */
mpq_demux->dmxdev.filternum = MPQ_MAX_DMX_FILES;
mpq_demux->dmxdev.demux = &mpq_demux->demux.dmx;
mpq_demux->dmxdev.capabilities =
DMXDEV_CAP_DUPLEX |
DMXDEV_CAP_PULL_MODE |
DMXDEV_CAP_INDEXING;
mpq_demux->dmxdev.demux->set_source = mpq_dmx_set_source;
mpq_demux->dmxdev.demux->get_caps = mpq_tspp_dmx_get_caps;
result = dvb_dmxdev_init(&mpq_demux->dmxdev, mpq_adapter);
if (result < 0) {
MPQ_DVB_ERR_PRINT("%s: dvb_dmxdev_init failed (errno=%d)\n",
__func__,
result);
goto init_failed_dmx_release;
}
return 0;
init_failed_dmx_release:
dvb_dmx_release(&mpq_demux->demux);
init_failed:
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;
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 __init StmLoadModule (void)
{
int Result;
int i;
DvbContext = kmalloc (sizeof (struct DvbContext_s), GFP_KERNEL);
#ifdef __TDT__
memset(DvbContext, 0, sizeof*DvbContext);
#endif
if (DvbContext == NULL)
{
DVB_ERROR("Unable to allocate device memory\n");
return -ENOMEM;
}
#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 LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)
#if (DVB_API_VERSION > 3)
Result = dvb_register_adapter (&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE,NULL, adapter_num);
#else
Result = dvb_register_adapter (&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE,NULL);
#endif
#else /* STLinux 2.2 kernel */
#ifdef __TDT__
Result = dvb_register_adapter (&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE,NULL);
#else
Result = dvb_register_adapter (&DvbContext->DvbAdapter, MODULE_NAME, THIS_MODULE);
#endif
#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;
//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;
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;
DvbDemux->write_to_decoder = WriteToDecoder;
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);
/* Unregister the built-in dvr device and replace it with our own version */
#ifdef __TDT__
printk("%d: DeviceContext %p, DvbDemux %p, DmxDevice %p\n", i, DeviceContext, DvbDemux, DmxDevice);
#endif
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);
/* register the CA device (e.g. CIMAX) */
#ifdef __TDT__
if(i < 2)
#endif
#ifndef VIP2_V1
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->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->PlayInterval.start = DVB_TIME_NOT_BOUNDED;
DeviceContext->PlayInterval.end = DVB_TIME_NOT_BOUNDED;
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 < 3)
{
ptiInit(DeviceContext);
}
if(i < 1)
{
init_e2_proc(DeviceContext);
}
#endif
}
/*}}} */
mutex_unlock (&(DvbContext->Lock));
BackendInit ();
#ifndef __TDT__
dvp_init();
#endif
linuxdvb_v4l2_init();
DVB_DEBUG("STM stream device loaded\n");
return 0;
}
static int dvb_register(struct au0828_dev *dev)
{
struct au0828_dvb *dvb = &dev->dvb;
int result;
dprintk(1, "%s()\n", __func__);
/* 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 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;
if ((ret = dvb_dmx_init(&fc->demux)) < 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;
if ((ret = dvb_dmxdev_init(&fc->dmxdev, &fc->dvb_adapter)) < 0) {
err("dvb_dmxdev_init failed: error %d",ret);
goto err_dmx_dev;
}
if ((ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->hw_frontend)) < 0) {
err("adding hw_frontend to dmx failed: error %d",ret);
goto err_dmx_add_hw_frontend;
}
fc->mem_frontend.source = DMX_MEMORY_FE;
if ((ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->mem_frontend)) < 0) {
err("adding mem_frontend to dmx failed: error %d",ret);
goto err_dmx_add_mem_frontend;
}
if ((ret = fc->demux.dmx.connect_frontend(&fc->demux.dmx, &fc->hw_frontend)) < 0) {
err("connect frontend failed: error %d",ret);
goto err_connect_frontend;
}
dvb_net_init(&fc->dvb_adapter, &fc->dvbnet, &fc->demux.dmx);
fc->init_state |= FC_STATE_DVB_INIT;
return 0;
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 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;
}