SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/frontends/dvb_dummy_fe.c

   1 /*
   2  *  Driver for Dummy Frontend
   3  *
   4  *  Written by Emard <emard@softhome.net>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.=
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/moduleparam.h>
  24 #include <linux/init.h>
  25 #include <linux/string.h>
  26 #include <linux/slab.h>
  27
  28 #include "dvb_frontend.h"
  29 #include "dvb_dummy_fe.h"
  30
  31
  32 struct dvb_dummy_fe_state {
  33         struct dvb_frontend_ops ops;
  34         struct dvb_frontend frontend;
  35 };
  36
  37
  38 static int dvb_dummy_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
  39 {
  40         *status = FE_HAS_SIGNAL
  41                 | FE_HAS_CARRIER
  42                 | FE_HAS_VITERBI
  43                 | FE_HAS_SYNC
  44                 | FE_HAS_LOCK;
  45
  46         return 0;
  47 }
  48
  49 static int dvb_dummy_fe_read_ber(struct dvb_frontend* fe, u32* ber)
  50 {
  51         *ber = 0;
  52         return 0;
  53 }
  54
  55 static int dvb_dummy_fe_read_signal_strength(struct dvb_frontend* fe, u16* strength)
  56 {
  57         *strength = 0;
  58         return 0;
  59 }
  60
  61 static int dvb_dummy_fe_read_snr(struct dvb_frontend* fe, u16* snr)
  62 {
  63         *snr = 0;
  64         return 0;
  65 }
  66
  67 static int dvb_dummy_fe_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
  68 {
  69         *ucblocks = 0;
  70         return 0;
  71 }
  72
  73 static int dvb_dummy_fe_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
  74 {
  75         return 0;
  76 }
  77
  78 static int dvb_dummy_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
  79 {
  80         if (fe->ops->tuner_ops->set_params) {
  81                 fe->ops->tuner_ops->set_params(fe, p);
  82                 if (fe->ops->i2c_gate_ctrl) fe->ops->i2c_gate_ctrl(fe, 0);
  83         }
  84
  85         return 0;
  86 }
  87
  88 static int dvb_dummy_fe_sleep(struct dvb_frontend* fe)
  89 {
  90         return 0;
  91 }
  92
  93 static int dvb_dummy_fe_init(struct dvb_frontend* fe)
  94 {
  95         return 0;
  96 }
  97
  98 static int dvb_dummy_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
  99 {
 100         return 0;
 101 }
 102
 103 static int dvb_dummy_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 104 {
 105         return 0;
 106 }
 107
 108 static void dvb_dummy_fe_release(struct dvb_frontend* fe)
 109 {
 110         struct dvb_dummy_fe_state* state = fe->demodulator_priv;
 111         kfree(state);
 112 }
 113
 114 static struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops;
 115
 116 struct dvb_frontend* dvb_dummy_fe_ofdm_attach(void)
 117 {
 118         struct dvb_dummy_fe_state* state = NULL;
 119
 120         /* allocate memory for the internal state */
 121         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
 122         if (state == NULL) goto error;
 123
 124         /* setup the state */
 125         memcpy(&state->ops, &dvb_dummy_fe_ofdm_ops, sizeof(struct dvb_frontend_ops));
 126
 127         /* create dvb_frontend */
 128         state->frontend.ops = &state->ops;
 129         state->frontend.demodulator_priv = state;
 130         return &state->frontend;
 131
 132 error:
 133         kfree(state);
 134         return NULL;
 135 }
 136
 137 static struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops;
 138
 139 struct dvb_frontend* dvb_dummy_fe_qpsk_attach()
 140 {
 141         struct dvb_dummy_fe_state* state = NULL;
 142
 143         /* allocate memory for the internal state */
 144         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
 145         if (state == NULL) goto error;
 146
 147         /* setup the state */
 148         memcpy(&state->ops, &dvb_dummy_fe_qpsk_ops, sizeof(struct dvb_frontend_ops));
 149
 150         /* create dvb_frontend */
 151         state->frontend.ops = &state->ops;
 152         state->frontend.demodulator_priv = state;
 153         return &state->frontend;
 154
 155 error:
 156         kfree(state);
 157         return NULL;
 158 }
 159
 160 static struct dvb_frontend_ops dvb_dummy_fe_qam_ops;
 161
 162 struct dvb_frontend* dvb_dummy_fe_qam_attach()
 163 {
 164         struct dvb_dummy_fe_state* state = NULL;
 165
 166         /* allocate memory for the internal state */
 167         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
 168         if (state == NULL) goto error;
 169
 170         /* setup the state */
 171         memcpy(&state->ops, &dvb_dummy_fe_qam_ops, sizeof(struct dvb_frontend_ops));
 172
 173         /* create dvb_frontend */
 174         state->frontend.ops = &state->ops;
 175         state->frontend.demodulator_priv = state;
 176         return &state->frontend;
 177
 178 error:
 179         kfree(state);
 180         return NULL;
 181 }
 182
 183 static struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops = {
 184
 185         .info = {
 186                 .name                   = "Dummy DVB-T",
 187                 .type                   = FE_OFDM,
 188                 .frequency_min          = 0,
 189                 .frequency_max          = 863250000,
 190                 .frequency_stepsize     = 62500,
 191                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 192                                 FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
 193                                 FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
 194                                 FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 195                                 FE_CAN_TRANSMISSION_MODE_AUTO |
 196                                 FE_CAN_GUARD_INTERVAL_AUTO |
 197                                 FE_CAN_HIERARCHY_AUTO,
 198         },
 199
 200         .release = dvb_dummy_fe_release,
 201
 202         .init = dvb_dummy_fe_init,
 203         .sleep = dvb_dummy_fe_sleep,
 204
 205         .set_frontend = dvb_dummy_fe_set_frontend,
 206         .get_frontend = dvb_dummy_fe_get_frontend,
 207
 208         .read_status = dvb_dummy_fe_read_status,
 209         .read_ber = dvb_dummy_fe_read_ber,
 210         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
 211         .read_snr = dvb_dummy_fe_read_snr,
 212         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
 213 };
 214
 215 static struct dvb_frontend_ops dvb_dummy_fe_qam_ops = {
 216
 217         .info = {
 218                 .name                   = "Dummy DVB-C",
 219                 .type                   = FE_QAM,
 220                 .frequency_stepsize     = 62500,
 221                 .frequency_min          = 51000000,
 222                 .frequency_max          = 858000000,
 223                 .symbol_rate_min        = (57840000/2)/64,     /* SACLK/64 == (XIN/2)/64 */
 224                 .symbol_rate_max        = (57840000/2)/4,      /* SACLK/4 */
 225                 .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
 226                         FE_CAN_QAM_128 | FE_CAN_QAM_256 |
 227                         FE_CAN_FEC_AUTO | FE_CAN_INVERSION_AUTO
 228         },
 229
 230         .release = dvb_dummy_fe_release,
 231
 232         .init = dvb_dummy_fe_init,
 233         .sleep = dvb_dummy_fe_sleep,
 234
 235         .set_frontend = dvb_dummy_fe_set_frontend,
 236         .get_frontend = dvb_dummy_fe_get_frontend,
 237
 238         .read_status = dvb_dummy_fe_read_status,
 239         .read_ber = dvb_dummy_fe_read_ber,
 240         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
 241         .read_snr = dvb_dummy_fe_read_snr,
 242         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
 243 };
 244
 245 static struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops = {
 246
 247         .info = {
 248                 .name                   = "Dummy DVB-S",
 249                 .type                   = FE_QPSK,
 250                 .frequency_min          = 950000,
 251                 .frequency_max          = 2150000,
 252                 .frequency_stepsize     = 250,           /* kHz for QPSK frontends */
 253                 .frequency_tolerance    = 29500,
 254                 .symbol_rate_min        = 1000000,
 255                 .symbol_rate_max        = 45000000,
 256                 .caps = FE_CAN_INVERSION_AUTO |
 257                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 258                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 259                         FE_CAN_QPSK
 260         },
 261
 262         .release = dvb_dummy_fe_release,
 263
 264         .init = dvb_dummy_fe_init,
 265         .sleep = dvb_dummy_fe_sleep,
 266
 267         .set_frontend = dvb_dummy_fe_set_frontend,
 268         .get_frontend = dvb_dummy_fe_get_frontend,
 269
 270         .read_status = dvb_dummy_fe_read_status,
 271         .read_ber = dvb_dummy_fe_read_ber,
 272         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
 273         .read_snr = dvb_dummy_fe_read_snr,
 274         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
 275
 276         .set_voltage = dvb_dummy_fe_set_voltage,
 277         .set_tone = dvb_dummy_fe_set_tone,
 278 };
 279
 280 MODULE_DESCRIPTION("DVB DUMMY Frontend");
 281 MODULE_AUTHOR("Emard");
 282 MODULE_LICENSE("GPL");
 283
 284 EXPORT_SYMBOL(dvb_dummy_fe_ofdm_attach);
 285 EXPORT_SYMBOL(dvb_dummy_fe_qam_attach);
 286 EXPORT_SYMBOL(dvb_dummy_fe_qpsk_attach);