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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 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, 0444); 117 MODULE_PARM_DESC(mux_buf_sz_pkts, 118 "Size for the internal mux buffer in multiples of 188 bytes"); 119 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 = vidtv_bridge_remove, 582 }; 583 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 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