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