Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * The Virtual DTV test driver serves as a reference DVB driver and helps
0004  * validate the existing APIs in the media subsystem. It can also aid
0005  * developers working on userspace applications.
0006  *
0007  * When this module is loaded, it will attempt to modprobe 'dvb_vidtv_tuner'
0008  * and 'dvb_vidtv_demod'.
0009  *
0010  * Copyright (C) 2020 Daniel W. S. Almeida
0011  */
0012 
0013 #include <linux/dev_printk.h>
0014 #include <linux/moduleparam.h>
0015 #include <linux/mutex.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/time.h>
0018 #include <linux/types.h>
0019 #include <linux/workqueue.h>
0020 #include <media/dvbdev.h>
0021 #include <media/media-device.h>
0022 
0023 #include "vidtv_bridge.h"
0024 #include "vidtv_common.h"
0025 #include "vidtv_demod.h"
0026 #include "vidtv_mux.h"
0027 #include "vidtv_ts.h"
0028 #include "vidtv_tuner.h"
0029 
0030 #define MUX_BUF_MIN_SZ 90164
0031 #define MUX_BUF_MAX_SZ (MUX_BUF_MIN_SZ * 10)
0032 #define TUNER_DEFAULT_ADDR 0x68
0033 #define DEMOD_DEFAULT_ADDR 0x60
0034 #define VIDTV_DEFAULT_NETWORK_ID 0xff44
0035 #define VIDTV_DEFAULT_NETWORK_NAME "LinuxTV.org"
0036 #define VIDTV_DEFAULT_TS_ID 0x4081
0037 
0038 /*
0039  * The LNBf fake parameters here are the ranges used by an
0040  * Universal (extended) European LNBf, which is likely the most common LNBf
0041  * found on Satellite digital TV system nowadays.
0042  */
0043 #define LNB_CUT_FREQUENCY   11700000    /* high IF frequency */
0044 #define LNB_LOW_FREQ        9750000     /* low IF frequency */
0045 #define LNB_HIGH_FREQ       10600000    /* transition frequency */
0046 
0047 static unsigned int drop_tslock_prob_on_low_snr;
0048 module_param(drop_tslock_prob_on_low_snr, uint, 0);
0049 MODULE_PARM_DESC(drop_tslock_prob_on_low_snr,
0050          "Probability of losing the TS lock if the signal quality is bad");
0051 
0052 static unsigned int recover_tslock_prob_on_good_snr;
0053 module_param(recover_tslock_prob_on_good_snr, uint, 0);
0054 MODULE_PARM_DESC(recover_tslock_prob_on_good_snr,
0055          "Probability recovering the TS lock when the signal improves");
0056 
0057 static unsigned int mock_power_up_delay_msec;
0058 module_param(mock_power_up_delay_msec, uint, 0);
0059 MODULE_PARM_DESC(mock_power_up_delay_msec, "Simulate a power up delay");
0060 
0061 static unsigned int mock_tune_delay_msec;
0062 module_param(mock_tune_delay_msec, uint, 0);
0063 MODULE_PARM_DESC(mock_tune_delay_msec, "Simulate a tune delay");
0064 
0065 static unsigned int vidtv_valid_dvb_t_freqs[NUM_VALID_TUNER_FREQS] = {
0066     474000000
0067 };
0068 
0069 module_param_array(vidtv_valid_dvb_t_freqs, uint, NULL, 0);
0070 MODULE_PARM_DESC(vidtv_valid_dvb_t_freqs,
0071          "Valid DVB-T frequencies to simulate, in Hz");
0072 
0073 static unsigned int vidtv_valid_dvb_c_freqs[NUM_VALID_TUNER_FREQS] = {
0074     474000000
0075 };
0076 
0077 module_param_array(vidtv_valid_dvb_c_freqs, uint, NULL, 0);
0078 MODULE_PARM_DESC(vidtv_valid_dvb_c_freqs,
0079          "Valid DVB-C frequencies to simulate, in Hz");
0080 
0081 static unsigned int vidtv_valid_dvb_s_freqs[NUM_VALID_TUNER_FREQS] = {
0082     11362000
0083 };
0084 module_param_array(vidtv_valid_dvb_s_freqs, uint, NULL, 0);
0085 MODULE_PARM_DESC(vidtv_valid_dvb_s_freqs,
0086          "Valid DVB-S/S2 frequencies to simulate at Ku-Band, in kHz");
0087 
0088 static unsigned int max_frequency_shift_hz;
0089 module_param(max_frequency_shift_hz, uint, 0);
0090 MODULE_PARM_DESC(max_frequency_shift_hz,
0091          "Maximum shift in HZ allowed when tuning in a channel");
0092 
0093 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nums);
0094 
0095 /*
0096  * Influences the signal acquisition time. See ISO/IEC 13818-1 : 2000. p. 113.
0097  */
0098 static unsigned int si_period_msec = 40;
0099 module_param(si_period_msec, uint, 0);
0100 MODULE_PARM_DESC(si_period_msec, "How often to send SI packets. Default: 40ms");
0101 
0102 static unsigned int pcr_period_msec = 40;
0103 module_param(pcr_period_msec, uint, 0);
0104 MODULE_PARM_DESC(pcr_period_msec,
0105          "How often to send PCR packets. Default: 40ms");
0106 
0107 static unsigned int mux_rate_kbytes_sec = 4096;
0108 module_param(mux_rate_kbytes_sec, uint, 0);
0109 MODULE_PARM_DESC(mux_rate_kbytes_sec, "Mux rate: will pad stream if below");
0110 
0111 static unsigned int pcr_pid = 0x200;
0112 module_param(pcr_pid, uint, 0);
0113 MODULE_PARM_DESC(pcr_pid, "PCR PID for all channels: defaults to 0x200");
0114 
0115 static unsigned int mux_buf_sz_pkts;
0116 module_param(mux_buf_sz_pkts, uint, 0);
0117 MODULE_PARM_DESC(mux_buf_sz_pkts,
0118          "Size for the internal mux buffer in multiples of 188 bytes");
0119 
0120 static u32 vidtv_bridge_mux_buf_sz_for_mux_rate(void)
0121 {
0122     u32 max_elapsed_time_msecs =  VIDTV_MAX_SLEEP_USECS / USEC_PER_MSEC;
0123     u32 mux_buf_sz = mux_buf_sz_pkts * TS_PACKET_LEN;
0124     u32 nbytes_expected;
0125 
0126     nbytes_expected = mux_rate_kbytes_sec;
0127     nbytes_expected *= max_elapsed_time_msecs;
0128 
0129     mux_buf_sz = roundup(nbytes_expected, TS_PACKET_LEN);
0130     mux_buf_sz += mux_buf_sz / 10;
0131 
0132     if (mux_buf_sz < MUX_BUF_MIN_SZ)
0133         mux_buf_sz = MUX_BUF_MIN_SZ;
0134 
0135     if (mux_buf_sz > MUX_BUF_MAX_SZ)
0136         mux_buf_sz = MUX_BUF_MAX_SZ;
0137 
0138     return mux_buf_sz;
0139 }
0140 
0141 static bool vidtv_bridge_check_demod_lock(struct vidtv_dvb *dvb, u32 n)
0142 {
0143     enum fe_status status;
0144 
0145     dvb->fe[n]->ops.read_status(dvb->fe[n], &status);
0146 
0147     return status == (FE_HAS_SIGNAL  |
0148               FE_HAS_CARRIER |
0149               FE_HAS_VITERBI |
0150               FE_HAS_SYNC    |
0151               FE_HAS_LOCK);
0152 }
0153 
0154 /*
0155  * called on a separate thread by the mux when new packets become available
0156  */
0157 static void vidtv_bridge_on_new_pkts_avail(void *priv, u8 *buf, u32 npkts)
0158 {
0159     struct vidtv_dvb *dvb = priv;
0160 
0161     /* drop packets if we lose the lock */
0162     if (vidtv_bridge_check_demod_lock(dvb, 0))
0163         dvb_dmx_swfilter_packets(&dvb->demux, buf, npkts);
0164 }
0165 
0166 static int vidtv_start_streaming(struct vidtv_dvb *dvb)
0167 {
0168     struct vidtv_mux_init_args mux_args = {
0169         .mux_rate_kbytes_sec         = mux_rate_kbytes_sec,
0170         .on_new_packets_available_cb = vidtv_bridge_on_new_pkts_avail,
0171         .pcr_period_usecs            = pcr_period_msec * USEC_PER_MSEC,
0172         .si_period_usecs             = si_period_msec * USEC_PER_MSEC,
0173         .pcr_pid                     = pcr_pid,
0174         .transport_stream_id         = VIDTV_DEFAULT_TS_ID,
0175         .network_id                  = VIDTV_DEFAULT_NETWORK_ID,
0176         .network_name                = VIDTV_DEFAULT_NETWORK_NAME,
0177         .priv                        = dvb,
0178     };
0179     struct device *dev = &dvb->pdev->dev;
0180     u32 mux_buf_sz;
0181 
0182     if (dvb->streaming) {
0183         dev_warn_ratelimited(dev, "Already streaming. Skipping.\n");
0184         return 0;
0185     }
0186 
0187     if (mux_buf_sz_pkts)
0188         mux_buf_sz = mux_buf_sz_pkts;
0189     else
0190         mux_buf_sz = vidtv_bridge_mux_buf_sz_for_mux_rate();
0191 
0192     mux_args.mux_buf_sz  = mux_buf_sz;
0193 
0194     dvb->streaming = true;
0195     dvb->mux = vidtv_mux_init(dvb->fe[0], dev, &mux_args);
0196     if (!dvb->mux)
0197         return -ENOMEM;
0198     vidtv_mux_start_thread(dvb->mux);
0199 
0200     dev_dbg_ratelimited(dev, "Started streaming\n");
0201     return 0;
0202 }
0203 
0204 static int vidtv_stop_streaming(struct vidtv_dvb *dvb)
0205 {
0206     struct device *dev = &dvb->pdev->dev;
0207 
0208     dvb->streaming = false;
0209     vidtv_mux_stop_thread(dvb->mux);
0210     vidtv_mux_destroy(dvb->mux);
0211     dvb->mux = NULL;
0212 
0213     dev_dbg_ratelimited(dev, "Stopped streaming\n");
0214     return 0;
0215 }
0216 
0217 static int vidtv_start_feed(struct dvb_demux_feed *feed)
0218 {
0219     struct dvb_demux *demux = feed->demux;
0220     struct vidtv_dvb *dvb   = demux->priv;
0221     int ret;
0222     int rc;
0223 
0224     if (!demux->dmx.frontend)
0225         return -EINVAL;
0226 
0227     mutex_lock(&dvb->feed_lock);
0228 
0229     dvb->nfeeds++;
0230     rc = dvb->nfeeds;
0231 
0232     if (dvb->nfeeds == 1) {
0233         ret = vidtv_start_streaming(dvb);
0234         if (ret < 0)
0235             rc = ret;
0236     }
0237 
0238     mutex_unlock(&dvb->feed_lock);
0239     return rc;
0240 }
0241 
0242 static int vidtv_stop_feed(struct dvb_demux_feed *feed)
0243 {
0244     struct dvb_demux *demux = feed->demux;
0245     struct vidtv_dvb *dvb   = demux->priv;
0246     int err = 0;
0247 
0248     mutex_lock(&dvb->feed_lock);
0249     dvb->nfeeds--;
0250 
0251     if (!dvb->nfeeds)
0252         err = vidtv_stop_streaming(dvb);
0253 
0254     mutex_unlock(&dvb->feed_lock);
0255     return err;
0256 }
0257 
0258 static struct dvb_frontend *vidtv_get_frontend_ptr(struct i2c_client *c)
0259 {
0260     struct vidtv_demod_state *state = i2c_get_clientdata(c);
0261 
0262     /* the demod will set this when its probe function runs */
0263     return &state->frontend;
0264 }
0265 
0266 static int vidtv_master_xfer(struct i2c_adapter *i2c_adap,
0267                  struct i2c_msg msgs[],
0268                  int num)
0269 {
0270     /*
0271      * Right now, this virtual driver doesn't really send or receive
0272      * messages from I2C. A real driver will require an implementation
0273      * here.
0274      */
0275     return 0;
0276 }
0277 
0278 static u32 vidtv_i2c_func(struct i2c_adapter *adapter)
0279 {
0280     return I2C_FUNC_I2C;
0281 }
0282 
0283 static const struct i2c_algorithm vidtv_i2c_algorithm = {
0284     .master_xfer   = vidtv_master_xfer,
0285     .functionality = vidtv_i2c_func,
0286 };
0287 
0288 static int vidtv_bridge_i2c_register_adap(struct vidtv_dvb *dvb)
0289 {
0290     struct i2c_adapter *i2c_adapter = &dvb->i2c_adapter;
0291 
0292     strscpy(i2c_adapter->name, "vidtv_i2c", sizeof(i2c_adapter->name));
0293     i2c_adapter->owner      = THIS_MODULE;
0294     i2c_adapter->algo       = &vidtv_i2c_algorithm;
0295     i2c_adapter->algo_data  = NULL;
0296     i2c_adapter->timeout    = 500;
0297     i2c_adapter->retries    = 3;
0298     i2c_adapter->dev.parent = &dvb->pdev->dev;
0299 
0300     i2c_set_adapdata(i2c_adapter, dvb);
0301     return i2c_add_adapter(&dvb->i2c_adapter);
0302 }
0303 
0304 static int vidtv_bridge_register_adap(struct vidtv_dvb *dvb)
0305 {
0306     int ret = 0;
0307 
0308     ret = dvb_register_adapter(&dvb->adapter,
0309                    KBUILD_MODNAME,
0310                    THIS_MODULE,
0311                    &dvb->i2c_adapter.dev,
0312                    adapter_nums);
0313 
0314     return ret;
0315 }
0316 
0317 static int vidtv_bridge_dmx_init(struct vidtv_dvb *dvb)
0318 {
0319     dvb->demux.dmx.capabilities = DMX_TS_FILTERING |
0320                       DMX_SECTION_FILTERING;
0321 
0322     dvb->demux.priv       = dvb;
0323     dvb->demux.filternum  = 256;
0324     dvb->demux.feednum    = 256;
0325     dvb->demux.start_feed = vidtv_start_feed;
0326     dvb->demux.stop_feed  = vidtv_stop_feed;
0327 
0328     return dvb_dmx_init(&dvb->demux);
0329 }
0330 
0331 static int vidtv_bridge_dmxdev_init(struct vidtv_dvb *dvb)
0332 {
0333     dvb->dmx_dev.filternum    = 256;
0334     dvb->dmx_dev.demux        = &dvb->demux.dmx;
0335     dvb->dmx_dev.capabilities = 0;
0336 
0337     return dvb_dmxdev_init(&dvb->dmx_dev, &dvb->adapter);
0338 }
0339 
0340 static int vidtv_bridge_probe_demod(struct vidtv_dvb *dvb, u32 n)
0341 {
0342     struct vidtv_demod_config cfg = {
0343         .drop_tslock_prob_on_low_snr     = drop_tslock_prob_on_low_snr,
0344         .recover_tslock_prob_on_good_snr = recover_tslock_prob_on_good_snr,
0345     };
0346     dvb->i2c_client_demod[n] = dvb_module_probe("dvb_vidtv_demod",
0347                             NULL,
0348                             &dvb->i2c_adapter,
0349                             DEMOD_DEFAULT_ADDR,
0350                             &cfg);
0351 
0352     /* driver will not work anyways so bail out */
0353     if (!dvb->i2c_client_demod[n])
0354         return -ENODEV;
0355 
0356     /* retrieve a ptr to the frontend state */
0357     dvb->fe[n] = vidtv_get_frontend_ptr(dvb->i2c_client_demod[n]);
0358 
0359     return 0;
0360 }
0361 
0362 static int vidtv_bridge_probe_tuner(struct vidtv_dvb *dvb, u32 n)
0363 {
0364     struct vidtv_tuner_config cfg = {
0365         .fe                       = dvb->fe[n],
0366         .mock_power_up_delay_msec = mock_power_up_delay_msec,
0367         .mock_tune_delay_msec     = mock_tune_delay_msec,
0368     };
0369     u32 freq;
0370     int i;
0371 
0372     /* TODO: check if the frequencies are at a valid range */
0373 
0374     memcpy(cfg.vidtv_valid_dvb_t_freqs,
0375            vidtv_valid_dvb_t_freqs,
0376            sizeof(vidtv_valid_dvb_t_freqs));
0377 
0378     memcpy(cfg.vidtv_valid_dvb_c_freqs,
0379            vidtv_valid_dvb_c_freqs,
0380            sizeof(vidtv_valid_dvb_c_freqs));
0381 
0382     /*
0383      * Convert Satellite frequencies from Ku-band in kHZ into S-band
0384      * frequencies in Hz.
0385      */
0386     for (i = 0; i < ARRAY_SIZE(vidtv_valid_dvb_s_freqs); i++) {
0387         freq = vidtv_valid_dvb_s_freqs[i];
0388         if (freq) {
0389             if (freq < LNB_CUT_FREQUENCY)
0390                 freq = abs(freq - LNB_LOW_FREQ);
0391             else
0392                 freq = abs(freq - LNB_HIGH_FREQ);
0393         }
0394         cfg.vidtv_valid_dvb_s_freqs[i] = freq;
0395     }
0396 
0397     cfg.max_frequency_shift_hz = max_frequency_shift_hz;
0398 
0399     dvb->i2c_client_tuner[n] = dvb_module_probe("dvb_vidtv_tuner",
0400                             NULL,
0401                             &dvb->i2c_adapter,
0402                             TUNER_DEFAULT_ADDR,
0403                             &cfg);
0404 
0405     return (dvb->i2c_client_tuner[n]) ? 0 : -ENODEV;
0406 }
0407 
0408 static int vidtv_bridge_dvb_init(struct vidtv_dvb *dvb)
0409 {
0410     int ret, i, j;
0411 
0412     ret = vidtv_bridge_i2c_register_adap(dvb);
0413     if (ret < 0)
0414         goto fail_i2c;
0415 
0416     ret = vidtv_bridge_register_adap(dvb);
0417     if (ret < 0)
0418         goto fail_adapter;
0419     dvb_register_media_controller(&dvb->adapter, &dvb->mdev);
0420 
0421     for (i = 0; i < NUM_FE; ++i) {
0422         ret = vidtv_bridge_probe_demod(dvb, i);
0423         if (ret < 0)
0424             goto fail_demod_probe;
0425 
0426         ret = vidtv_bridge_probe_tuner(dvb, i);
0427         if (ret < 0)
0428             goto fail_tuner_probe;
0429 
0430         ret = dvb_register_frontend(&dvb->adapter, dvb->fe[i]);
0431         if (ret < 0)
0432             goto fail_fe;
0433     }
0434 
0435     ret = vidtv_bridge_dmx_init(dvb);
0436     if (ret < 0)
0437         goto fail_dmx;
0438 
0439     ret = vidtv_bridge_dmxdev_init(dvb);
0440     if (ret < 0)
0441         goto fail_dmx_dev;
0442 
0443     for (j = 0; j < NUM_FE; ++j) {
0444         ret = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx,
0445                               &dvb->dmx_fe[j]);
0446         if (ret < 0)
0447             goto fail_dmx_conn;
0448 
0449         /*
0450          * The source of the demux is a frontend connected
0451          * to the demux.
0452          */
0453         dvb->dmx_fe[j].source = DMX_FRONTEND_0;
0454     }
0455 
0456     return ret;
0457 
0458 fail_dmx_conn:
0459     for (j = j - 1; j >= 0; --j)
0460         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx,
0461                            &dvb->dmx_fe[j]);
0462 fail_dmx_dev:
0463     dvb_dmxdev_release(&dvb->dmx_dev);
0464 fail_dmx:
0465     dvb_dmx_release(&dvb->demux);
0466 fail_fe:
0467     for (j = i; j >= 0; --j)
0468         dvb_unregister_frontend(dvb->fe[j]);
0469 fail_tuner_probe:
0470     for (j = i; j >= 0; --j)
0471         if (dvb->i2c_client_tuner[j])
0472             dvb_module_release(dvb->i2c_client_tuner[j]);
0473 
0474 fail_demod_probe:
0475     for (j = i; j >= 0; --j)
0476         if (dvb->i2c_client_demod[j])
0477             dvb_module_release(dvb->i2c_client_demod[j]);
0478 
0479 fail_adapter:
0480     dvb_unregister_adapter(&dvb->adapter);
0481 
0482 fail_i2c:
0483     i2c_del_adapter(&dvb->i2c_adapter);
0484 
0485     return ret;
0486 }
0487 
0488 static int vidtv_bridge_probe(struct platform_device *pdev)
0489 {
0490     struct vidtv_dvb *dvb;
0491     int ret;
0492 
0493     dvb = kzalloc(sizeof(*dvb), GFP_KERNEL);
0494     if (!dvb)
0495         return -ENOMEM;
0496 
0497     dvb->pdev = pdev;
0498 
0499 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0500     dvb->mdev.dev = &pdev->dev;
0501 
0502     strscpy(dvb->mdev.model, "vidtv", sizeof(dvb->mdev.model));
0503     strscpy(dvb->mdev.bus_info, "platform:vidtv", sizeof(dvb->mdev.bus_info));
0504 
0505     media_device_init(&dvb->mdev);
0506 #endif
0507 
0508     ret = vidtv_bridge_dvb_init(dvb);
0509     if (ret < 0)
0510         goto err_dvb;
0511 
0512     mutex_init(&dvb->feed_lock);
0513 
0514     platform_set_drvdata(pdev, dvb);
0515 
0516 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0517     ret = media_device_register(&dvb->mdev);
0518     if (ret) {
0519         dev_err(dvb->mdev.dev,
0520             "media device register failed (err=%d)\n", ret);
0521         goto err_media_device_register;
0522     }
0523 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
0524 
0525     dev_info(&pdev->dev, "Successfully initialized vidtv!\n");
0526     return ret;
0527 
0528 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0529 err_media_device_register:
0530     media_device_cleanup(&dvb->mdev);
0531 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
0532 err_dvb:
0533     kfree(dvb);
0534     return ret;
0535 }
0536 
0537 static int vidtv_bridge_remove(struct platform_device *pdev)
0538 {
0539     struct vidtv_dvb *dvb;
0540     u32 i;
0541 
0542     dvb = platform_get_drvdata(pdev);
0543 
0544 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0545     media_device_unregister(&dvb->mdev);
0546     media_device_cleanup(&dvb->mdev);
0547 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
0548 
0549     mutex_destroy(&dvb->feed_lock);
0550 
0551     for (i = 0; i < NUM_FE; ++i) {
0552         dvb_unregister_frontend(dvb->fe[i]);
0553         dvb_module_release(dvb->i2c_client_tuner[i]);
0554         dvb_module_release(dvb->i2c_client_demod[i]);
0555     }
0556 
0557     dvb_dmxdev_release(&dvb->dmx_dev);
0558     dvb_dmx_release(&dvb->demux);
0559     dvb_unregister_adapter(&dvb->adapter);
0560     dev_info(&pdev->dev, "Successfully removed vidtv\n");
0561 
0562     return 0;
0563 }
0564 
0565 static void vidtv_bridge_dev_release(struct device *dev)
0566 {
0567     struct vidtv_dvb *dvb;
0568 
0569     dvb = dev_get_drvdata(dev);
0570     kfree(dvb);
0571 }
0572 
0573 static struct platform_device vidtv_bridge_dev = {
0574     .name       = VIDTV_PDEV_NAME,
0575     .dev.release    = vidtv_bridge_dev_release,
0576 };
0577 
0578 static struct platform_driver vidtv_bridge_driver = {
0579     .driver = {
0580         .name = VIDTV_PDEV_NAME,
0581     },
0582     .probe    = vidtv_bridge_probe,
0583     .remove   = vidtv_bridge_remove,
0584 };
0585 
0586 static void __exit vidtv_bridge_exit(void)
0587 {
0588     platform_driver_unregister(&vidtv_bridge_driver);
0589     platform_device_unregister(&vidtv_bridge_dev);
0590 }
0591 
0592 static int __init vidtv_bridge_init(void)
0593 {
0594     int ret;
0595 
0596     ret = platform_device_register(&vidtv_bridge_dev);
0597     if (ret)
0598         return ret;
0599 
0600     ret = platform_driver_register(&vidtv_bridge_driver);
0601     if (ret)
0602         platform_device_unregister(&vidtv_bridge_dev);
0603 
0604     return ret;
0605 }
0606 
0607 module_init(vidtv_bridge_init);
0608 module_exit(vidtv_bridge_exit);
0609 
0610 MODULE_DESCRIPTION("Virtual Digital TV Test Driver");
0611 MODULE_AUTHOR("Daniel W. S. Almeida");
0612 MODULE_LICENSE("GPL");
0613 MODULE_ALIAS("vidtv");
0614 MODULE_ALIAS("dvb_vidtv");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!