drivers/media/test-drivers/vivid/vivid-radio-common.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vivid-radio-common.c - common radio rx/tx support functions.
   4  *
   5  * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/kernel.h>
  10 #include <linux/delay.h>
  11 #include <linux/videodev2.h>
  12
  13 #include "vivid-core.h"
  14 #include "vivid-ctrls.h"
  15 #include "vivid-radio-common.h"
  16 #include "vivid-rds-gen.h"
  17
  18 /*
  19  * These functions are shared between the vivid receiver and transmitter
  20  * since both use the same frequency bands.
  21  */
  22
  23 const struct v4l2_frequency_band vivid_radio_bands[TOT_BANDS] = {
  24         /* Band FM */
  25         {
  26                 .type = V4L2_TUNER_RADIO,
  27                 .index = 0,
  28                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
  29                               V4L2_TUNER_CAP_FREQ_BANDS,
  30                 .rangelow   = FM_FREQ_RANGE_LOW,
  31                 .rangehigh  = FM_FREQ_RANGE_HIGH,
  32                 .modulation = V4L2_BAND_MODULATION_FM,
  33         },
  34         /* Band AM */
  35         {
  36                 .type = V4L2_TUNER_RADIO,
  37                 .index = 1,
  38                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_FREQ_BANDS,
  39                 .rangelow   = AM_FREQ_RANGE_LOW,
  40                 .rangehigh  = AM_FREQ_RANGE_HIGH,
  41                 .modulation = V4L2_BAND_MODULATION_AM,
  42         },
  43         /* Band SW */
  44         {
  45                 .type = V4L2_TUNER_RADIO,
  46                 .index = 2,
  47                 .capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_FREQ_BANDS,
  48                 .rangelow   = SW_FREQ_RANGE_LOW,
  49                 .rangehigh  = SW_FREQ_RANGE_HIGH,
  50                 .modulation = V4L2_BAND_MODULATION_AM,
  51         },
  52 };
  53
  54 /*
  55  * Initialize the RDS generator. If we can loop, then the RDS generator
  56  * is set up with the values from the RDS TX controls, otherwise it
  57  * will fill in standard values using one of two alternates.
  58  */
  59 void vivid_radio_rds_init(struct vivid_dev *dev)
  60 {
  61         struct vivid_rds_gen *rds = &dev->rds_gen;
  62         bool alt = dev->radio_rx_rds_use_alternates;
  63
  64         /* Do nothing, blocks will be filled by the transmitter */
  65         if (dev->radio_rds_loop && !dev->radio_tx_rds_controls)
  66                 return;
  67
  68         if (dev->radio_rds_loop) {
  69                 v4l2_ctrl_lock(dev->radio_tx_rds_pi);
  70                 rds->picode = dev->radio_tx_rds_pi->cur.val;
  71                 rds->pty = dev->radio_tx_rds_pty->cur.val;
  72                 rds->mono_stereo = dev->radio_tx_rds_mono_stereo->cur.val;
  73                 rds->art_head = dev->radio_tx_rds_art_head->cur.val;
  74                 rds->compressed = dev->radio_tx_rds_compressed->cur.val;
  75                 rds->dyn_pty = dev->radio_tx_rds_dyn_pty->cur.val;
  76                 rds->ta = dev->radio_tx_rds_ta->cur.val;
  77                 rds->tp = dev->radio_tx_rds_tp->cur.val;
  78                 rds->ms = dev->radio_tx_rds_ms->cur.val;
  79                 strscpy(rds->psname,
  80                         dev->radio_tx_rds_psname->p_cur.p_char,
  81                         sizeof(rds->psname));
  82                 strscpy(rds->radiotext,
  83                         dev->radio_tx_rds_radiotext->p_cur.p_char + alt * 64,
  84                         sizeof(rds->radiotext));
  85                 v4l2_ctrl_unlock(dev->radio_tx_rds_pi);
  86         } else {
  87                 vivid_rds_gen_fill(rds, dev->radio_rx_freq, alt);
  88         }
  89         if (dev->radio_rx_rds_controls) {
  90                 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, rds->pty);
  91                 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, rds->ta);
  92                 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, rds->tp);
  93                 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, rds->ms);
  94                 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, rds->psname);
  95                 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, rds->radiotext);
  96                 if (!dev->radio_rds_loop)
  97                         dev->radio_rx_rds_use_alternates = !dev->radio_rx_rds_use_alternates;
  98         }
  99         vivid_rds_generate(rds);
 100 }
 101
 102 /*
 103  * Calculate the emulated signal quality taking into account the frequency
 104  * the transmitter is using.
 105  */
 106 static void vivid_radio_calc_sig_qual(struct vivid_dev *dev)
 107 {
 108         int mod = 16000;
 109         int delta = 800;
 110         int sig_qual, sig_qual_tx = mod;
 111
 112         /*
 113          * For SW and FM there is a channel every 1000 kHz, for AM there is one
 114          * every 100 kHz.
 115          */
 116         if (dev->radio_rx_freq <= AM_FREQ_RANGE_HIGH) {
 117                 mod /= 10;
 118                 delta /= 10;
 119         }
 120         sig_qual = (dev->radio_rx_freq + delta) % mod - delta;
 121         if (dev->has_radio_tx)
 122                 sig_qual_tx = dev->radio_rx_freq - dev->radio_tx_freq;
 123         if (abs(sig_qual_tx) <= abs(sig_qual)) {
 124                 sig_qual = sig_qual_tx;
 125                 /*
 126                  * Zero the internal rds buffer if we are going to loop
 127                  * rds blocks.
 128                  */
 129                 if (!dev->radio_rds_loop && !dev->radio_tx_rds_controls)
 130                         memset(dev->rds_gen.data, 0,
 131                                sizeof(dev->rds_gen.data));
 132                 dev->radio_rds_loop = dev->radio_rx_freq >= FM_FREQ_RANGE_LOW;
 133         } else {
 134                 dev->radio_rds_loop = false;
 135         }
 136         if (dev->radio_rx_freq <= AM_FREQ_RANGE_HIGH)
 137                 sig_qual *= 10;
 138         dev->radio_rx_sig_qual = sig_qual;
 139 }
 140
 141 int vivid_radio_g_frequency(struct file *file, const unsigned *pfreq, struct v4l2_frequency *vf)
 142 {
 143         if (vf->tuner != 0)
 144                 return -EINVAL;
 145         vf->frequency = *pfreq;
 146         return 0;
 147 }
 148
 149 int vivid_radio_s_frequency(struct file *file, unsigned *pfreq, const struct v4l2_frequency *vf)
 150 {
 151         struct vivid_dev *dev = video_drvdata(file);
 152         unsigned freq;
 153         unsigned band;
 154
 155         if (vf->tuner != 0)
 156                 return -EINVAL;
 157
 158         if (vf->frequency >= (FM_FREQ_RANGE_LOW + SW_FREQ_RANGE_HIGH) / 2)
 159                 band = BAND_FM;
 160         else if (vf->frequency <= (AM_FREQ_RANGE_HIGH + SW_FREQ_RANGE_LOW) / 2)
 161                 band = BAND_AM;
 162         else
 163                 band = BAND_SW;
 164
 165         freq = clamp_t(u32, vf->frequency, vivid_radio_bands[band].rangelow,
 166                                            vivid_radio_bands[band].rangehigh);
 167         *pfreq = freq;
 168
 169         /*
 170          * For both receiver and transmitter recalculate the signal quality
 171          * (since that depends on both frequencies) and re-init the rds
 172          * generator.
 173          */
 174         vivid_radio_calc_sig_qual(dev);
 175         vivid_radio_rds_init(dev);
 176         return 0;
 177 }