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