1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * The Virtual DTV test driver serves as a reference DVB driver and helps
4 * validate the existing APIs in the media subsystem. It can also aid
5 * developers working on userspace applications.
6 *
7 * When this module is loaded, it will attempt to modprobe 'dvb_vidtv_tuner'
8 * and 'dvb_vidtv_demod'.
9 *
10 * Copyright (C) 2020 Daniel W. S. Almeida
11 */
12
13 #include <linux/dev_printk.h>
14 #include <linux/moduleparam.h>
15 #include <linux/mutex.h>
16 #include <linux/platform_device.h>
17 #include <linux/time.h>
18 #include <linux/types.h>
19 #include <linux/workqueue.h>
20 #include <media/dvbdev.h>
21 #include <media/media-device.h>
22
23 #include "vidtv_bridge.h"
24 #include "vidtv_common.h"
25 #include "vidtv_demod.h"
26 #include "vidtv_mux.h"
27 #include "vidtv_ts.h"
28 #include "vidtv_tuner.h"
29
30 #define MUX_BUF_MIN_SZ 90164
31 #define MUX_BUF_MAX_SZ (MUX_BUF_MIN_SZ * 10)
32 #define TUNER_DEFAULT_ADDR 0x68
33 #define DEMOD_DEFAULT_ADDR 0x60
34 #define VIDTV_DEFAULT_NETWORK_ID 0xff44
35 #define VIDTV_DEFAULT_NETWORK_NAME "LinuxTV.org"
36 #define VIDTV_DEFAULT_TS_ID 0x4081
37
38 /*
39 * The LNBf fake parameters here are the ranges used by an
40 * Universal (extended) European LNBf, which is likely the most common LNBf
41 * found on Satellite digital TV system nowadays.
42 */
43 #define LNB_CUT_FREQUENCY 11700000 /* high IF frequency */
44 #define LNB_LOW_FREQ 9750000 /* low IF frequency */
45 #define LNB_HIGH_FREQ 10600000 /* transition frequency */
46
47 static unsigned int drop_tslock_prob_on_low_snr;
48 module_param(drop_tslock_prob_on_low_snr, uint, 0);
49 MODULE_PARM_DESC(drop_tslock_prob_on_low_snr,
50 "Probability of losing the TS lock if the signal quality is bad");
51
52 static unsigned int recover_tslock_prob_on_good_snr;
53 module_param(recover_tslock_prob_on_good_snr, uint, 0);
54 MODULE_PARM_DESC(recover_tslock_prob_on_good_snr,
55 "Probability recovering the TS lock when the signal improves");
56
57 static unsigned int mock_power_up_delay_msec;
58 module_param(mock_power_up_delay_msec, uint, 0);
59 MODULE_PARM_DESC(mock_power_up_delay_msec, "Simulate a power up delay");
60
61 static unsigned int mock_tune_delay_msec;
62 module_param(mock_tune_delay_msec, uint, 0);
63 MODULE_PARM_DESC(mock_tune_delay_msec, "Simulate a tune delay");
64
65 static unsigned int vidtv_valid_dvb_t_freqs[NUM_VALID_TUNER_FREQS] = {
66 474000000
67 };
68
69 module_param_array(vidtv_valid_dvb_t_freqs, uint, NULL, 0);
70 MODULE_PARM_DESC(vidtv_valid_dvb_t_freqs,
71 "Valid DVB-T frequencies to simulate, in Hz");
72
73 static unsigned int vidtv_valid_dvb_c_freqs[NUM_VALID_TUNER_FREQS] = {
74 474000000
75 };
76
77 module_param_array(vidtv_valid_dvb_c_freqs, uint, NULL, 0);
78 MODULE_PARM_DESC(vidtv_valid_dvb_c_freqs,
79 "Valid DVB-C frequencies to simulate, in Hz");
80
81 static unsigned int vidtv_valid_dvb_s_freqs[NUM_VALID_TUNER_FREQS] = {
82 11362000
83 };
84 module_param_array(vidtv_valid_dvb_s_freqs, uint, NULL, 0);
85 MODULE_PARM_DESC(vidtv_valid_dvb_s_freqs,
86 "Valid DVB-S/S2 frequencies to simulate at Ku-Band, in kHz");
87
88 static unsigned int max_frequency_shift_hz;
89 module_param(max_frequency_shift_hz, uint, 0);
90 MODULE_PARM_DESC(max_frequency_shift_hz,
91 "Maximum shift in HZ allowed when tuning in a channel");
92
93 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nums);
94
95 /*
96 * Influences the signal acquisition time. See ISO/IEC 13818-1 : 2000. p. 113.
97 */
98 static unsigned int si_period_msec = 40;
99 module_param(si_period_msec, uint, 0);
100 MODULE_PARM_DESC(si_period_msec, "How often to send SI packets. Default: 40ms");
101
102 static unsigned int pcr_period_msec = 40;
103 module_param(pcr_period_msec, uint, 0);
104 MODULE_PARM_DESC(pcr_period_msec,
105 "How often to send PCR packets. Default: 40ms");
106
107 static unsigned int mux_rate_kbytes_sec = 4096;
108 module_param(mux_rate_kbytes_sec, uint, 0);
109 MODULE_PARM_DESC(mux_rate_kbytes_sec, "Mux rate: will pad stream if below");
110
111 static unsigned int pcr_pid = 0x200;
112 module_param(pcr_pid, uint, 0);
113 MODULE_PARM_DESC(pcr_pid, "PCR PID for all channels: defaults to 0x200");
114
115 static unsigned int mux_buf_sz_pkts;
116 module_param(mux_buf_sz_pkts, uint, 0);
117 MODULE_PARM_DESC(mux_buf_sz_pkts,
118 "Size for the internal mux buffer in multiples of 188 bytes");
119
vidtv_bridge_mux_buf_sz_for_mux_rate(void)120 static u32 vidtv_bridge_mux_buf_sz_for_mux_rate(void)
121 {
122 u32 max_elapsed_time_msecs = VIDTV_MAX_SLEEP_USECS / USEC_PER_MSEC;
123 u32 mux_buf_sz = mux_buf_sz_pkts * TS_PACKET_LEN;
124 u32 nbytes_expected;
125
126 nbytes_expected = mux_rate_kbytes_sec;
127 nbytes_expected *= max_elapsed_time_msecs;
128
129 mux_buf_sz = roundup(nbytes_expected, TS_PACKET_LEN);
130 mux_buf_sz += mux_buf_sz / 10;
131
132 if (mux_buf_sz < MUX_BUF_MIN_SZ)
133 mux_buf_sz = MUX_BUF_MIN_SZ;
134
135 if (mux_buf_sz > MUX_BUF_MAX_SZ)
136 mux_buf_sz = MUX_BUF_MAX_SZ;
137
138 return mux_buf_sz;
139 }
140
vidtv_bridge_check_demod_lock(struct vidtv_dvb * dvb,u32 n)141 static bool vidtv_bridge_check_demod_lock(struct vidtv_dvb *dvb, u32 n)
142 {
143 enum fe_status status;
144
145 dvb->fe[n]->ops.read_status(dvb->fe[n], &status);
146
147 return status == (FE_HAS_SIGNAL |
148 FE_HAS_CARRIER |
149 FE_HAS_VITERBI |
150 FE_HAS_SYNC |
151 FE_HAS_LOCK);
152 }
153
154 /*
155 * called on a separate thread by the mux when new packets become available
156 */
vidtv_bridge_on_new_pkts_avail(void * priv,u8 * buf,u32 npkts)157 static void vidtv_bridge_on_new_pkts_avail(void *priv, u8 *buf, u32 npkts)
158 {
159 struct vidtv_dvb *dvb = priv;
160
161 /* drop packets if we lose the lock */
162 if (vidtv_bridge_check_demod_lock(dvb, 0))
163 dvb_dmx_swfilter_packets(&dvb->demux, buf, npkts);
164 }
165
vidtv_start_streaming(struct vidtv_dvb * dvb)166 static int vidtv_start_streaming(struct vidtv_dvb *dvb)
167 {
168 struct vidtv_mux_init_args mux_args = {
169 .mux_rate_kbytes_sec = mux_rate_kbytes_sec,
170 .on_new_packets_available_cb = vidtv_bridge_on_new_pkts_avail,
171 .pcr_period_usecs = pcr_period_msec * USEC_PER_MSEC,
172 .si_period_usecs = si_period_msec * USEC_PER_MSEC,
173 .pcr_pid = pcr_pid,
174 .transport_stream_id = VIDTV_DEFAULT_TS_ID,
175 .network_id = VIDTV_DEFAULT_NETWORK_ID,
176 .network_name = VIDTV_DEFAULT_NETWORK_NAME,
177 .priv = dvb,
178 };
179 struct device *dev = &dvb->pdev->dev;
180 u32 mux_buf_sz;
181
182 if (dvb->streaming) {
183 dev_warn_ratelimited(dev, "Already streaming. Skipping.\n");
184 return 0;
185 }
186
187 if (mux_buf_sz_pkts)
188 mux_buf_sz = mux_buf_sz_pkts;
189 else
190 mux_buf_sz = vidtv_bridge_mux_buf_sz_for_mux_rate();
191
192 mux_args.mux_buf_sz = mux_buf_sz;
193
194 dvb->mux = vidtv_mux_init(dvb->fe[0], dev, &mux_args);
195 if (!dvb->mux)
196 return -ENOMEM;
197
198 dvb->streaming = true;
199 vidtv_mux_start_thread(dvb->mux);
200
201 dev_dbg_ratelimited(dev, "Started streaming\n");
202 return 0;
203 }
204
vidtv_stop_streaming(struct vidtv_dvb * dvb)205 static int vidtv_stop_streaming(struct vidtv_dvb *dvb)
206 {
207 struct device *dev = &dvb->pdev->dev;
208
209 if (!dvb->streaming) {
210 dev_warn_ratelimited(dev, "No streaming. Skipping.\n");
211 return 0;
212 }
213
214 dvb->streaming = false;
215 vidtv_mux_stop_thread(dvb->mux);
216 vidtv_mux_destroy(dvb->mux);
217 dvb->mux = NULL;
218
219 dev_dbg_ratelimited(dev, "Stopped streaming\n");
220 return 0;
221 }
222
vidtv_start_feed(struct dvb_demux_feed * feed)223 static int vidtv_start_feed(struct dvb_demux_feed *feed)
224 {
225 struct dvb_demux *demux = feed->demux;
226 struct vidtv_dvb *dvb = demux->priv;
227 int ret;
228 int rc;
229
230 if (!demux->dmx.frontend)
231 return -EINVAL;
232
233 mutex_lock(&dvb->feed_lock);
234
235 dvb->nfeeds++;
236 rc = dvb->nfeeds;
237
238 if (dvb->nfeeds == 1) {
239 ret = vidtv_start_streaming(dvb);
240 if (ret < 0)
241 rc = ret;
242 }
243
244 mutex_unlock(&dvb->feed_lock);
245 return rc;
246 }
247
vidtv_stop_feed(struct dvb_demux_feed * feed)248 static int vidtv_stop_feed(struct dvb_demux_feed *feed)
249 {
250 struct dvb_demux *demux = feed->demux;
251 struct vidtv_dvb *dvb = demux->priv;
252 int err = 0;
253
254 mutex_lock(&dvb->feed_lock);
255 dvb->nfeeds--;
256
257 if (!dvb->nfeeds)
258 err = vidtv_stop_streaming(dvb);
259
260 mutex_unlock(&dvb->feed_lock);
261 return err;
262 }
263
vidtv_get_frontend_ptr(struct i2c_client * c)264 static struct dvb_frontend *vidtv_get_frontend_ptr(struct i2c_client *c)
265 {
266 struct vidtv_demod_state *state = i2c_get_clientdata(c);
267
268 /* the demod will set this when its probe function runs */
269 return &state->frontend;
270 }
271
vidtv_master_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg msgs[],int num)272 static int vidtv_master_xfer(struct i2c_adapter *i2c_adap,
273 struct i2c_msg msgs[],
274 int num)
275 {
276 /*
277 * Right now, this virtual driver doesn't really send or receive
278 * messages from I2C. A real driver will require an implementation
279 * here.
280 */
281 return 0;
282 }
283
vidtv_i2c_func(struct i2c_adapter * adapter)284 static u32 vidtv_i2c_func(struct i2c_adapter *adapter)
285 {
286 return I2C_FUNC_I2C;
287 }
288
289 static const struct i2c_algorithm vidtv_i2c_algorithm = {
290 .master_xfer = vidtv_master_xfer,
291 .functionality = vidtv_i2c_func,
292 };
293
vidtv_bridge_i2c_register_adap(struct vidtv_dvb * dvb)294 static int vidtv_bridge_i2c_register_adap(struct vidtv_dvb *dvb)
295 {
296 struct i2c_adapter *i2c_adapter = &dvb->i2c_adapter;
297
298 strscpy(i2c_adapter->name, "vidtv_i2c", sizeof(i2c_adapter->name));
299 i2c_adapter->owner = THIS_MODULE;
300 i2c_adapter->algo = &vidtv_i2c_algorithm;
301 i2c_adapter->algo_data = NULL;
302 i2c_adapter->timeout = 500;
303 i2c_adapter->retries = 3;
304 i2c_adapter->dev.parent = &dvb->pdev->dev;
305
306 i2c_set_adapdata(i2c_adapter, dvb);
307 return i2c_add_adapter(&dvb->i2c_adapter);
308 }
309
vidtv_bridge_register_adap(struct vidtv_dvb * dvb)310 static int vidtv_bridge_register_adap(struct vidtv_dvb *dvb)
311 {
312 int ret = 0;
313
314 ret = dvb_register_adapter(&dvb->adapter,
315 KBUILD_MODNAME,
316 THIS_MODULE,
317 &dvb->i2c_adapter.dev,
318 adapter_nums);
319
320 return ret;
321 }
322
vidtv_bridge_dmx_init(struct vidtv_dvb * dvb)323 static int vidtv_bridge_dmx_init(struct vidtv_dvb *dvb)
324 {
325 dvb->demux.dmx.capabilities = DMX_TS_FILTERING |
326 DMX_SECTION_FILTERING;
327
328 dvb->demux.priv = dvb;
329 dvb->demux.filternum = 256;
330 dvb->demux.feednum = 256;
331 dvb->demux.start_feed = vidtv_start_feed;
332 dvb->demux.stop_feed = vidtv_stop_feed;
333
334 return dvb_dmx_init(&dvb->demux);
335 }
336
vidtv_bridge_dmxdev_init(struct vidtv_dvb * dvb)337 static int vidtv_bridge_dmxdev_init(struct vidtv_dvb *dvb)
338 {
339 dvb->dmx_dev.filternum = 256;
340 dvb->dmx_dev.demux = &dvb->demux.dmx;
341 dvb->dmx_dev.capabilities = 0;
342
343 return dvb_dmxdev_init(&dvb->dmx_dev, &dvb->adapter);
344 }
345
vidtv_bridge_probe_demod(struct vidtv_dvb * dvb,u32 n)346 static int vidtv_bridge_probe_demod(struct vidtv_dvb *dvb, u32 n)
347 {
348 struct vidtv_demod_config cfg = {
349 .drop_tslock_prob_on_low_snr = drop_tslock_prob_on_low_snr,
350 .recover_tslock_prob_on_good_snr = recover_tslock_prob_on_good_snr,
351 };
352 dvb->i2c_client_demod[n] = dvb_module_probe("dvb_vidtv_demod",
353 NULL,
354 &dvb->i2c_adapter,
355 DEMOD_DEFAULT_ADDR,
356 &cfg);
357
358 /* driver will not work anyways so bail out */
359 if (!dvb->i2c_client_demod[n])
360 return -ENODEV;
361
362 /* retrieve a ptr to the frontend state */
363 dvb->fe[n] = vidtv_get_frontend_ptr(dvb->i2c_client_demod[n]);
364
365 return 0;
366 }
367
vidtv_bridge_probe_tuner(struct vidtv_dvb * dvb,u32 n)368 static int vidtv_bridge_probe_tuner(struct vidtv_dvb *dvb, u32 n)
369 {
370 struct vidtv_tuner_config cfg = {
371 .fe = dvb->fe[n],
372 .mock_power_up_delay_msec = mock_power_up_delay_msec,
373 .mock_tune_delay_msec = mock_tune_delay_msec,
374 };
375 u32 freq;
376 int i;
377
378 /* TODO: check if the frequencies are at a valid range */
379
380 memcpy(cfg.vidtv_valid_dvb_t_freqs,
381 vidtv_valid_dvb_t_freqs,
382 sizeof(vidtv_valid_dvb_t_freqs));
383
384 memcpy(cfg.vidtv_valid_dvb_c_freqs,
385 vidtv_valid_dvb_c_freqs,
386 sizeof(vidtv_valid_dvb_c_freqs));
387
388 /*
389 * Convert Satellite frequencies from Ku-band in kHZ into S-band
390 * frequencies in Hz.
391 */
392 for (i = 0; i < ARRAY_SIZE(vidtv_valid_dvb_s_freqs); i++) {
393 freq = vidtv_valid_dvb_s_freqs[i];
394 if (freq) {
395 if (freq < LNB_CUT_FREQUENCY)
396 freq = abs(freq - LNB_LOW_FREQ);
397 else
398 freq = abs(freq - LNB_HIGH_FREQ);
399 }
400 cfg.vidtv_valid_dvb_s_freqs[i] = freq;
401 }
402
403 cfg.max_frequency_shift_hz = max_frequency_shift_hz;
404
405 dvb->i2c_client_tuner[n] = dvb_module_probe("dvb_vidtv_tuner",
406 NULL,
407 &dvb->i2c_adapter,
408 TUNER_DEFAULT_ADDR,
409 &cfg);
410
411 return (dvb->i2c_client_tuner[n]) ? 0 : -ENODEV;
412 }
413
vidtv_bridge_dvb_init(struct vidtv_dvb * dvb)414 static int vidtv_bridge_dvb_init(struct vidtv_dvb *dvb)
415 {
416 int ret, i, j;
417
418 ret = vidtv_bridge_i2c_register_adap(dvb);
419 if (ret < 0)
420 goto fail_i2c;
421
422 ret = vidtv_bridge_register_adap(dvb);
423 if (ret < 0)
424 goto fail_adapter;
425 dvb_register_media_controller(&dvb->adapter, &dvb->mdev);
426
427 for (i = 0; i < NUM_FE; ++i) {
428 ret = vidtv_bridge_probe_demod(dvb, i);
429 if (ret < 0)
430 goto fail_demod_probe;
431
432 ret = vidtv_bridge_probe_tuner(dvb, i);
433 if (ret < 0)
434 goto fail_tuner_probe;
435
436 ret = dvb_register_frontend(&dvb->adapter, dvb->fe[i]);
437 if (ret < 0)
438 goto fail_fe;
439 }
440
441 ret = vidtv_bridge_dmx_init(dvb);
442 if (ret < 0)
443 goto fail_dmx;
444
445 ret = vidtv_bridge_dmxdev_init(dvb);
446 if (ret < 0)
447 goto fail_dmx_dev;
448
449 for (j = 0; j < NUM_FE; ++j) {
450 ret = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx,
451 &dvb->dmx_fe[j]);
452 if (ret < 0)
453 goto fail_dmx_conn;
454
455 /*
456 * The source of the demux is a frontend connected
457 * to the demux.
458 */
459 dvb->dmx_fe[j].source = DMX_FRONTEND_0;
460 }
461
462 return ret;
463
464 fail_dmx_conn:
465 for (j = j - 1; j >= 0; --j)
466 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx,
467 &dvb->dmx_fe[j]);
468 dvb_dmxdev_release(&dvb->dmx_dev);
469 fail_dmx_dev:
470 dvb_dmx_release(&dvb->demux);
471 fail_dmx:
472 fail_demod_probe:
473 for (i = i - 1; i >= 0; --i) {
474 dvb_unregister_frontend(dvb->fe[i]);
475 fail_fe:
476 dvb_module_release(dvb->i2c_client_tuner[i]);
477 fail_tuner_probe:
478 dvb_module_release(dvb->i2c_client_demod[i]);
479 }
480 fail_adapter:
481 dvb_unregister_adapter(&dvb->adapter);
482 fail_i2c:
483 i2c_del_adapter(&dvb->i2c_adapter);
484
485 return ret;
486 }
487
vidtv_bridge_probe(struct platform_device * pdev)488 static int vidtv_bridge_probe(struct platform_device *pdev)
489 {
490 struct vidtv_dvb *dvb;
491 int ret;
492
493 dvb = kzalloc(sizeof(*dvb), GFP_KERNEL);
494 if (!dvb)
495 return -ENOMEM;
496
497 dvb->pdev = pdev;
498
499 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
500 dvb->mdev.dev = &pdev->dev;
501
502 strscpy(dvb->mdev.model, "vidtv", sizeof(dvb->mdev.model));
503 strscpy(dvb->mdev.bus_info, "platform:vidtv", sizeof(dvb->mdev.bus_info));
504
505 media_device_init(&dvb->mdev);
506 #endif
507
508 ret = vidtv_bridge_dvb_init(dvb);
509 if (ret < 0)
510 goto err_dvb;
511
512 mutex_init(&dvb->feed_lock);
513
514 platform_set_drvdata(pdev, dvb);
515
516 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
517 ret = media_device_register(&dvb->mdev);
518 if (ret) {
519 dev_err(dvb->mdev.dev,
520 "media device register failed (err=%d)\n", ret);
521 goto err_media_device_register;
522 }
523 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
524
525 dev_info(&pdev->dev, "Successfully initialized vidtv!\n");
526 return ret;
527
528 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
529 err_media_device_register:
530 media_device_cleanup(&dvb->mdev);
531 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
532 err_dvb:
533 kfree(dvb);
534 return ret;
535 }
536
vidtv_bridge_remove(struct platform_device * pdev)537 static void vidtv_bridge_remove(struct platform_device *pdev)
538 {
539 struct vidtv_dvb *dvb;
540 u32 i;
541
542 dvb = platform_get_drvdata(pdev);
543
544 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
545 media_device_unregister(&dvb->mdev);
546 media_device_cleanup(&dvb->mdev);
547 #endif /* CONFIG_MEDIA_CONTROLLER_DVB */
548
549 mutex_destroy(&dvb->feed_lock);
550
551 for (i = 0; i < NUM_FE; ++i) {
552 dvb_unregister_frontend(dvb->fe[i]);
553 dvb_module_release(dvb->i2c_client_tuner[i]);
554 dvb_module_release(dvb->i2c_client_demod[i]);
555 }
556
557 dvb_dmxdev_release(&dvb->dmx_dev);
558 dvb_dmx_release(&dvb->demux);
559 dvb_unregister_adapter(&dvb->adapter);
560 dev_info(&pdev->dev, "Successfully removed vidtv\n");
561 }
562
vidtv_bridge_dev_release(struct device * dev)563 static void vidtv_bridge_dev_release(struct device *dev)
564 {
565 struct vidtv_dvb *dvb;
566
567 dvb = dev_get_drvdata(dev);
568 kfree(dvb);
569 }
570
571 static struct platform_device vidtv_bridge_dev = {
572 .name = VIDTV_PDEV_NAME,
573 .dev.release = vidtv_bridge_dev_release,
574 };
575
576 static struct platform_driver vidtv_bridge_driver = {
577 .driver = {
578 .name = VIDTV_PDEV_NAME,
579 },
580 .probe = vidtv_bridge_probe,
581 .remove_new = vidtv_bridge_remove,
582 };
583
vidtv_bridge_exit(void)584 static void __exit vidtv_bridge_exit(void)
585 {
586 platform_driver_unregister(&vidtv_bridge_driver);
587 platform_device_unregister(&vidtv_bridge_dev);
588 }
589
vidtv_bridge_init(void)590 static int __init vidtv_bridge_init(void)
591 {
592 int ret;
593
594 ret = platform_device_register(&vidtv_bridge_dev);
595 if (ret)
596 return ret;
597
598 ret = platform_driver_register(&vidtv_bridge_driver);
599 if (ret)
600 platform_device_unregister(&vidtv_bridge_dev);
601
602 return ret;
603 }
604
605 module_init(vidtv_bridge_init);
606 module_exit(vidtv_bridge_exit);
607
608 MODULE_DESCRIPTION("Virtual Digital TV Test Driver");
609 MODULE_AUTHOR("Daniel W. S. Almeida");
610 MODULE_LICENSE("GPL");
611 MODULE_ALIAS("vidtv");
612 MODULE_ALIAS("dvb_vidtv");
613