vidtv_bridge.c

  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
 47static unsigned int drop_tslock_prob_on_low_snr;
 48module_param(drop_tslock_prob_on_low_snr, uint, 0444);
 49MODULE_PARM_DESC(drop_tslock_prob_on_low_snr,
 50		 "Probability of losing the TS lock if the signal quality is bad");
 51
 52static unsigned int recover_tslock_prob_on_good_snr;
 53module_param(recover_tslock_prob_on_good_snr, uint, 0444);
 54MODULE_PARM_DESC(recover_tslock_prob_on_good_snr,
 55		 "Probability recovering the TS lock when the signal improves");
 56
 57static unsigned int mock_power_up_delay_msec;
 58module_param(mock_power_up_delay_msec, uint, 0444);
 59MODULE_PARM_DESC(mock_power_up_delay_msec, "Simulate a power up delay");
 60
 61static unsigned int mock_tune_delay_msec;
 62module_param(mock_tune_delay_msec, uint, 0444);
 63MODULE_PARM_DESC(mock_tune_delay_msec, "Simulate a tune delay");
 64
 65static unsigned int vidtv_valid_dvb_t_freqs[NUM_VALID_TUNER_FREQS] = {
 66	474000000
 67};
 68
 69module_param_array(vidtv_valid_dvb_t_freqs, uint, NULL, 0444);
 70MODULE_PARM_DESC(vidtv_valid_dvb_t_freqs,
 71		 "Valid DVB-T frequencies to simulate, in Hz");
 72
 73static unsigned int vidtv_valid_dvb_c_freqs[NUM_VALID_TUNER_FREQS] = {
 74	474000000
 75};
 76
 77module_param_array(vidtv_valid_dvb_c_freqs, uint, NULL, 0444);
 78MODULE_PARM_DESC(vidtv_valid_dvb_c_freqs,
 79		 "Valid DVB-C frequencies to simulate, in Hz");
 80
 81static unsigned int vidtv_valid_dvb_s_freqs[NUM_VALID_TUNER_FREQS] = {
 82	11362000
 83};
 84module_param_array(vidtv_valid_dvb_s_freqs, uint, NULL, 0444);
 85MODULE_PARM_DESC(vidtv_valid_dvb_s_freqs,
 86		 "Valid DVB-S/S2 frequencies to simulate at Ku-Band, in kHz");
 87
 88static unsigned int max_frequency_shift_hz;
 89module_param(max_frequency_shift_hz, uint, 0444);
 90MODULE_PARM_DESC(max_frequency_shift_hz,
 91		 "Maximum shift in HZ allowed when tuning in a channel");
 92
 93DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nums);
 94
 95/*
 96 * Influences the signal acquisition time. See ISO/IEC 13818-1 : 2000. p. 113.
 97 */
 98static unsigned int si_period_msec = 40;
 99module_param(si_period_msec, uint, 0444);
100MODULE_PARM_DESC(si_period_msec, "How often to send SI packets. Default: 40ms");
101
102static unsigned int pcr_period_msec = 40;
103module_param(pcr_period_msec, uint, 0444);
104MODULE_PARM_DESC(pcr_period_msec,
105		 "How often to send PCR packets. Default: 40ms");
106
107static unsigned int mux_rate_kbytes_sec = 4096;
108module_param(mux_rate_kbytes_sec, uint, 0444);
109MODULE_PARM_DESC(mux_rate_kbytes_sec, "Mux rate: will pad stream if below");
110
111static unsigned int pcr_pid = 0x200;
112module_param(pcr_pid, uint, 0444);
113MODULE_PARM_DESC(pcr_pid, "PCR PID for all channels: defaults to 0x200");
114
115static unsigned int mux_buf_sz_pkts;
116module_param(mux_buf_sz_pkts, uint, 0444);
117MODULE_PARM_DESC(mux_buf_sz_pkts,
118		 "Size for the internal mux buffer in multiples of 188 bytes");
119
120static 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
141static 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 */
157static 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
166static 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
205static 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
223static 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			dvb->nfeeds--;
242			rc = ret;
243		}
244	}
245
246	mutex_unlock(&dvb->feed_lock);
247	return rc;
248}
249
250static int vidtv_stop_feed(struct dvb_demux_feed *feed)
251{
252	struct dvb_demux *demux = feed->demux;
253	struct vidtv_dvb *dvb   = demux->priv;
254	int err = 0;
255
256	mutex_lock(&dvb->feed_lock);
257	dvb->nfeeds--;
258
259	if (!dvb->nfeeds)
260		err = vidtv_stop_streaming(dvb);
261
262	mutex_unlock(&dvb->feed_lock);
263	return err;
264}
265
266static struct dvb_frontend *vidtv_get_frontend_ptr(struct i2c_client *c)
267{
268	struct vidtv_demod_state *state = i2c_get_clientdata(c);
269
270	/* the demod will set this when its probe function runs */
271	return &state->frontend;
272}
273
274static int vidtv_master_xfer(struct i2c_adapter *i2c_adap,
275			     struct i2c_msg msgs[],
276			     int num)
277{
278	/*
279	 * Right now, this virtual driver doesn't really send or receive
280	 * messages from I2C. A real driver will require an implementation
281	 * here.
282	 */
283	return 0;
284}
285
286static u32 vidtv_i2c_func(struct i2c_adapter *adapter)
287{
288	return I2C_FUNC_I2C;
289}
290
291static const struct i2c_algorithm vidtv_i2c_algorithm = {
292	.master_xfer   = vidtv_master_xfer,
293	.functionality = vidtv_i2c_func,
294};
295
296static int vidtv_bridge_i2c_register_adap(struct vidtv_dvb *dvb)
297{
298	struct i2c_adapter *i2c_adapter = &dvb->i2c_adapter;
299
300	strscpy(i2c_adapter->name, "vidtv_i2c", sizeof(i2c_adapter->name));
301	i2c_adapter->owner      = THIS_MODULE;
302	i2c_adapter->algo       = &vidtv_i2c_algorithm;
303	i2c_adapter->algo_data  = NULL;
304	i2c_adapter->timeout    = 500;
305	i2c_adapter->retries    = 3;
306	i2c_adapter->dev.parent = &dvb->pdev->dev;
307
308	i2c_set_adapdata(i2c_adapter, dvb);
309	return i2c_add_adapter(&dvb->i2c_adapter);
310}
311
312static int vidtv_bridge_register_adap(struct vidtv_dvb *dvb)
313{
314	int ret = 0;
315
316	ret = dvb_register_adapter(&dvb->adapter,
317				   KBUILD_MODNAME,
318				   THIS_MODULE,
319				   &dvb->i2c_adapter.dev,
320				   adapter_nums);
321
322	return ret;
323}
324
325static int vidtv_bridge_dmx_init(struct vidtv_dvb *dvb)
326{
327	dvb->demux.dmx.capabilities = DMX_TS_FILTERING |
328				      DMX_SECTION_FILTERING;
329
330	dvb->demux.priv       = dvb;
331	dvb->demux.filternum  = 256;
332	dvb->demux.feednum    = 256;
333	dvb->demux.start_feed = vidtv_start_feed;
334	dvb->demux.stop_feed  = vidtv_stop_feed;
335
336	return dvb_dmx_init(&dvb->demux);
337}
338
339static int vidtv_bridge_dmxdev_init(struct vidtv_dvb *dvb)
340{
341	dvb->dmx_dev.filternum    = 256;
342	dvb->dmx_dev.demux        = &dvb->demux.dmx;
343	dvb->dmx_dev.capabilities = 0;
344
345	return dvb_dmxdev_init(&dvb->dmx_dev, &dvb->adapter);
346}
347
348static int vidtv_bridge_probe_demod(struct vidtv_dvb *dvb, u32 n)
349{
350	struct vidtv_demod_config cfg = {
351		.drop_tslock_prob_on_low_snr     = drop_tslock_prob_on_low_snr,
352		.recover_tslock_prob_on_good_snr = recover_tslock_prob_on_good_snr,
353	};
354	dvb->i2c_client_demod[n] = dvb_module_probe("dvb_vidtv_demod",
355						    NULL,
356						    &dvb->i2c_adapter,
357						    DEMOD_DEFAULT_ADDR,
358						    &cfg);
359
360	/* driver will not work anyways so bail out */
361	if (!dvb->i2c_client_demod[n])
362		return -ENODEV;
363
364	/* retrieve a ptr to the frontend state */
365	dvb->fe[n] = vidtv_get_frontend_ptr(dvb->i2c_client_demod[n]);
366
367	return 0;
368}
369
370static int vidtv_bridge_probe_tuner(struct vidtv_dvb *dvb, u32 n)
371{
372	struct vidtv_tuner_config cfg = {
373		.fe                       = dvb->fe[n],
374		.mock_power_up_delay_msec = mock_power_up_delay_msec,
375		.mock_tune_delay_msec     = mock_tune_delay_msec,
376	};
377	u32 freq;
378	int i;
379
380	/* TODO: check if the frequencies are at a valid range */
381
382	memcpy(cfg.vidtv_valid_dvb_t_freqs,
383	       vidtv_valid_dvb_t_freqs,
384	       sizeof(vidtv_valid_dvb_t_freqs));
385
386	memcpy(cfg.vidtv_valid_dvb_c_freqs,
387	       vidtv_valid_dvb_c_freqs,
388	       sizeof(vidtv_valid_dvb_c_freqs));
389
390	/*
391	 * Convert Satellite frequencies from Ku-band in kHZ into S-band
392	 * frequencies in Hz.
393	 */
394	for (i = 0; i < ARRAY_SIZE(vidtv_valid_dvb_s_freqs); i++) {
395		freq = vidtv_valid_dvb_s_freqs[i];
396		if (freq) {
397			if (freq < LNB_CUT_FREQUENCY)
398				freq = abs(freq - LNB_LOW_FREQ);
399			else
400				freq = abs(freq - LNB_HIGH_FREQ);
401		}
402		cfg.vidtv_valid_dvb_s_freqs[i] = freq;
403	}
404
405	cfg.max_frequency_shift_hz = max_frequency_shift_hz;
406
407	dvb->i2c_client_tuner[n] = dvb_module_probe("dvb_vidtv_tuner",
408						    NULL,
409						    &dvb->i2c_adapter,
410						    TUNER_DEFAULT_ADDR,
411						    &cfg);
412
413	return (dvb->i2c_client_tuner[n]) ? 0 : -ENODEV;
414}
415
416static int vidtv_bridge_dvb_init(struct vidtv_dvb *dvb)
417{
418	int ret, i, j;
419
420	ret = vidtv_bridge_i2c_register_adap(dvb);
421	if (ret < 0)
422		goto fail_i2c;
423
424	ret = vidtv_bridge_register_adap(dvb);
425	if (ret < 0)
426		goto fail_adapter;
427	dvb_register_media_controller(&dvb->adapter, &dvb->mdev);
428
429	for (i = 0; i < NUM_FE; ++i) {
430		ret = vidtv_bridge_probe_demod(dvb, i);
431		if (ret < 0)
432			goto fail_demod_probe;
433
434		ret = vidtv_bridge_probe_tuner(dvb, i);
435		if (ret < 0)
436			goto fail_tuner_probe;
437
438		ret = dvb_register_frontend(&dvb->adapter, dvb->fe[i]);
439		if (ret < 0)
440			goto fail_fe;
441	}
442
443	ret = vidtv_bridge_dmx_init(dvb);
444	if (ret < 0)
445		goto fail_dmx;
446
447	ret = vidtv_bridge_dmxdev_init(dvb);
448	if (ret < 0)
449		goto fail_dmx_dev;
450
451	for (j = 0; j < NUM_FE; ++j) {
452		ret = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx,
453						      &dvb->dmx_fe[j]);
454		if (ret < 0)
455			goto fail_dmx_conn;
456
457		/*
458		 * The source of the demux is a frontend connected
459		 * to the demux.
460		 */
461		dvb->dmx_fe[j].source = DMX_FRONTEND_0;
462	}
463
464	return ret;
465
466fail_dmx_conn:
467	for (j = j - 1; j >= 0; --j)
468		dvb->demux.dmx.remove_frontend(&dvb->demux.dmx,
469					       &dvb->dmx_fe[j]);
470	dvb_dmxdev_release(&dvb->dmx_dev);
471fail_dmx_dev:
472	dvb_dmx_release(&dvb->demux);
473fail_dmx:
474fail_demod_probe:
475	for (i = i - 1; i >= 0; --i) {
476		dvb_unregister_frontend(dvb->fe[i]);
477fail_fe:
478		dvb_module_release(dvb->i2c_client_tuner[i]);
479fail_tuner_probe:
480		dvb_module_release(dvb->i2c_client_demod[i]);
481	}
482fail_adapter:
483	dvb_unregister_adapter(&dvb->adapter);
484fail_i2c:
485	i2c_del_adapter(&dvb->i2c_adapter);
486
487	return ret;
488}
489
490static int vidtv_bridge_probe(struct platform_device *pdev)
491{
492	struct vidtv_dvb *dvb;
493	int ret;
494
495	dvb = kzalloc(sizeof(*dvb), GFP_KERNEL);
496	if (!dvb)
497		return -ENOMEM;
498
499	dvb->pdev = pdev;
500
501#ifdef CONFIG_MEDIA_CONTROLLER_DVB
502	dvb->mdev.dev = &pdev->dev;
503
504	strscpy(dvb->mdev.model, "vidtv", sizeof(dvb->mdev.model));
505	strscpy(dvb->mdev.bus_info, "platform:vidtv", sizeof(dvb->mdev.bus_info));
506
507	media_device_init(&dvb->mdev);
508#endif
509
510	ret = vidtv_bridge_dvb_init(dvb);
511	if (ret < 0)
512		goto err_dvb;
513
514	mutex_init(&dvb->feed_lock);
515
516	platform_set_drvdata(pdev, dvb);
517
518#ifdef CONFIG_MEDIA_CONTROLLER_DVB
519	ret = media_device_register(&dvb->mdev);
520	if (ret) {
521		dev_err(dvb->mdev.dev,
522			"media device register failed (err=%d)\n", ret);
523		goto err_media_device_register;
524	}
525#endif /* CONFIG_MEDIA_CONTROLLER_DVB */
526
527	dev_info(&pdev->dev, "Successfully initialized vidtv!\n");
528	return ret;
529
530#ifdef CONFIG_MEDIA_CONTROLLER_DVB
531err_media_device_register:
532	media_device_cleanup(&dvb->mdev);
533#endif /* CONFIG_MEDIA_CONTROLLER_DVB */
534err_dvb:
535	kfree(dvb);
536	return ret;
537}
538
539static void vidtv_bridge_remove(struct platform_device *pdev)
540{
541	struct vidtv_dvb *dvb;
542	u32 i;
543
544	dvb = platform_get_drvdata(pdev);
545
546#ifdef CONFIG_MEDIA_CONTROLLER_DVB
547	media_device_unregister(&dvb->mdev);
548	media_device_cleanup(&dvb->mdev);
549#endif /* CONFIG_MEDIA_CONTROLLER_DVB */
550
551	mutex_destroy(&dvb->feed_lock);
552
553	for (i = 0; i < NUM_FE; ++i) {
554		dvb_unregister_frontend(dvb->fe[i]);
555		dvb_module_release(dvb->i2c_client_tuner[i]);
556		dvb_module_release(dvb->i2c_client_demod[i]);
557	}
558
559	dvb_dmxdev_release(&dvb->dmx_dev);
560	dvb_dmx_release(&dvb->demux);
561	dvb_unregister_adapter(&dvb->adapter);
562	dev_info(&pdev->dev, "Successfully removed vidtv\n");
563}
564
565static void vidtv_bridge_dev_release(struct device *dev)
566{
567	struct vidtv_dvb *dvb;
568
569	dvb = dev_get_drvdata(dev);
570	kfree(dvb);
571}
572
573static struct platform_device vidtv_bridge_dev = {
574	.name		= VIDTV_PDEV_NAME,
575	.dev.release	= vidtv_bridge_dev_release,
576};
577
578static struct platform_driver vidtv_bridge_driver = {
579	.driver = {
580		.name = VIDTV_PDEV_NAME,
581	},
582	.probe    = vidtv_bridge_probe,
583	.remove = vidtv_bridge_remove,
584};
585
586static void __exit vidtv_bridge_exit(void)
587{
588	platform_driver_unregister(&vidtv_bridge_driver);
589	platform_device_unregister(&vidtv_bridge_dev);
590}
591
592static int __init vidtv_bridge_init(void)
593{
594	int ret;
595
596	ret = platform_device_register(&vidtv_bridge_dev);
597	if (ret)
598		return ret;
599
600	ret = platform_driver_register(&vidtv_bridge_driver);
601	if (ret)
602		platform_device_unregister(&vidtv_bridge_dev);
603
604	return ret;
605}
606
607module_init(vidtv_bridge_init);
608module_exit(vidtv_bridge_exit);
609
610MODULE_DESCRIPTION("Virtual Digital TV Test Driver");
611MODULE_AUTHOR("Daniel W. S. Almeida");
612MODULE_LICENSE("GPL");
613MODULE_ALIAS("vidtv");
614MODULE_ALIAS("dvb_vidtv");