drivers/media/usb/dvb-usb-v2/mxl111sf-tuner.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  mxl111sf-tuner.c - driver for the MaxLinear MXL111SF CMOS tuner
   4  *
   5  *  Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
   6  */
   7
   8 #include "mxl111sf-tuner.h"
   9 #include "mxl111sf-phy.h"
  10 #include "mxl111sf-reg.h"
  11
  12 /* debug */
  13 static int mxl111sf_tuner_debug;
  14 module_param_named(debug, mxl111sf_tuner_debug, int, 0644);
  15 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
  16
  17 #define mxl_dbg(fmt, arg...) \
  18         if (mxl111sf_tuner_debug) \
  19                 mxl_printk(KERN_DEBUG, fmt, ##arg)
  20
  21 /* ------------------------------------------------------------------------ */
  22
  23 struct mxl111sf_tuner_state {
  24         struct mxl111sf_state *mxl_state;
  25
  26         const struct mxl111sf_tuner_config *cfg;
  27
  28         enum mxl_if_freq if_freq;
  29
  30         u32 frequency;
  31         u32 bandwidth;
  32 };
  33
  34 static int mxl111sf_tuner_read_reg(struct mxl111sf_tuner_state *state,
  35                                    u8 addr, u8 *data)
  36 {
  37         return (state->cfg->read_reg) ?
  38                 state->cfg->read_reg(state->mxl_state, addr, data) :
  39                 -EINVAL;
  40 }
  41
  42 static int mxl111sf_tuner_write_reg(struct mxl111sf_tuner_state *state,
  43                                     u8 addr, u8 data)
  44 {
  45         return (state->cfg->write_reg) ?
  46                 state->cfg->write_reg(state->mxl_state, addr, data) :
  47                 -EINVAL;
  48 }
  49
  50 static int mxl111sf_tuner_program_regs(struct mxl111sf_tuner_state *state,
  51                                struct mxl111sf_reg_ctrl_info *ctrl_reg_info)
  52 {
  53         return (state->cfg->program_regs) ?
  54                 state->cfg->program_regs(state->mxl_state, ctrl_reg_info) :
  55                 -EINVAL;
  56 }
  57
  58 static int mxl1x1sf_tuner_top_master_ctrl(struct mxl111sf_tuner_state *state,
  59                                           int onoff)
  60 {
  61         return (state->cfg->top_master_ctrl) ?
  62                 state->cfg->top_master_ctrl(state->mxl_state, onoff) :
  63                 -EINVAL;
  64 }
  65
  66 /* ------------------------------------------------------------------------ */
  67
  68 static struct mxl111sf_reg_ctrl_info mxl_phy_tune_rf[] = {
  69         {0x1d, 0x7f, 0x00}, /* channel bandwidth section 1/2/3,
  70                                DIG_MODEINDEX, _A, _CSF, */
  71         {0x1e, 0xff, 0x00}, /* channel frequency (lo and fractional) */
  72         {0x1f, 0xff, 0x00}, /* channel frequency (hi for integer portion) */
  73         {0,    0,    0}
  74 };
  75
  76 /* ------------------------------------------------------------------------ */
  77
  78 static struct mxl111sf_reg_ctrl_info *mxl111sf_calc_phy_tune_regs(u32 freq,
  79                                                                   u8 bw)
  80 {
  81         u8 filt_bw;
  82
  83         /* set channel bandwidth */
  84         switch (bw) {
  85         case 0: /* ATSC */
  86                 filt_bw = 25;
  87                 break;
  88         case 1: /* QAM */
  89                 filt_bw = 69;
  90                 break;
  91         case 6:
  92                 filt_bw = 21;
  93                 break;
  94         case 7:
  95                 filt_bw = 42;
  96                 break;
  97         case 8:
  98                 filt_bw = 63;
  99                 break;
 100         default:
 101                 pr_err("%s: invalid bandwidth setting!", __func__);
 102                 return NULL;
 103         }
 104
 105         /* calculate RF channel */
 106         freq /= 1000000;
 107
 108         freq *= 64;
 109 #if 0
 110         /* do round */
 111         freq += 0.5;
 112 #endif
 113         /* set bandwidth */
 114         mxl_phy_tune_rf[0].data = filt_bw;
 115
 116         /* set RF */
 117         mxl_phy_tune_rf[1].data = (freq & 0xff);
 118         mxl_phy_tune_rf[2].data = (freq >> 8) & 0xff;
 119
 120         /* start tune */
 121         return mxl_phy_tune_rf;
 122 }
 123
 124 static int mxl1x1sf_tuner_set_if_output_freq(struct mxl111sf_tuner_state *state)
 125 {
 126         int ret;
 127         u8 ctrl;
 128 #if 0
 129         u16 iffcw;
 130         u32 if_freq;
 131 #endif
 132         mxl_dbg("(IF polarity = %d, IF freq = 0x%02x)",
 133                 state->cfg->invert_spectrum, state->cfg->if_freq);
 134
 135         /* set IF polarity */
 136         ctrl = state->cfg->invert_spectrum;
 137
 138         ctrl |= state->cfg->if_freq;
 139
 140         ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_SEL_REG, ctrl);
 141         if (mxl_fail(ret))
 142                 goto fail;
 143
 144 #if 0
 145         if_freq /= 1000000;
 146
 147         /* do round */
 148         if_freq += 0.5;
 149
 150         if (MXL_IF_LO == state->cfg->if_freq) {
 151                 ctrl = 0x08;
 152                 iffcw = (u16)(if_freq / (108 * 4096));
 153         } else if (MXL_IF_HI == state->cfg->if_freq) {
 154                 ctrl = 0x08;
 155                 iffcw = (u16)(if_freq / (216 * 4096));
 156         } else {
 157                 ctrl = 0;
 158                 iffcw = 0;
 159         }
 160
 161         ctrl |= (iffcw >> 8);
 162 #endif
 163         ret = mxl111sf_tuner_read_reg(state, V6_TUNER_IF_FCW_BYP_REG, &ctrl);
 164         if (mxl_fail(ret))
 165                 goto fail;
 166
 167         ctrl &= 0xf0;
 168         ctrl |= 0x90;
 169
 170         ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_FCW_BYP_REG, ctrl);
 171         if (mxl_fail(ret))
 172                 goto fail;
 173
 174 #if 0
 175         ctrl = iffcw & 0x00ff;
 176 #endif
 177         ret = mxl111sf_tuner_write_reg(state, V6_TUNER_IF_FCW_REG, ctrl);
 178         if (mxl_fail(ret))
 179                 goto fail;
 180
 181         state->if_freq = state->cfg->if_freq;
 182 fail:
 183         return ret;
 184 }
 185
 186 static int mxl1x1sf_tune_rf(struct dvb_frontend *fe, u32 freq, u8 bw)
 187 {
 188         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 189         static struct mxl111sf_reg_ctrl_info *reg_ctrl_array;
 190         int ret;
 191         u8 mxl_mode;
 192
 193         mxl_dbg("(freq = %d, bw = 0x%x)", freq, bw);
 194
 195         /* stop tune */
 196         ret = mxl111sf_tuner_write_reg(state, START_TUNE_REG, 0);
 197         if (mxl_fail(ret))
 198                 goto fail;
 199
 200         /* check device mode */
 201         ret = mxl111sf_tuner_read_reg(state, MXL_MODE_REG, &mxl_mode);
 202         if (mxl_fail(ret))
 203                 goto fail;
 204
 205         /* Fill out registers for channel tune */
 206         reg_ctrl_array = mxl111sf_calc_phy_tune_regs(freq, bw);
 207         if (!reg_ctrl_array)
 208                 return -EINVAL;
 209
 210         ret = mxl111sf_tuner_program_regs(state, reg_ctrl_array);
 211         if (mxl_fail(ret))
 212                 goto fail;
 213
 214         if ((mxl_mode & MXL_DEV_MODE_MASK) == MXL_TUNER_MODE) {
 215                 /* IF tuner mode only */
 216                 mxl1x1sf_tuner_top_master_ctrl(state, 0);
 217                 mxl1x1sf_tuner_top_master_ctrl(state, 1);
 218                 mxl1x1sf_tuner_set_if_output_freq(state);
 219         }
 220
 221         ret = mxl111sf_tuner_write_reg(state, START_TUNE_REG, 1);
 222         if (mxl_fail(ret))
 223                 goto fail;
 224
 225         if (state->cfg->ant_hunt)
 226                 state->cfg->ant_hunt(fe);
 227 fail:
 228         return ret;
 229 }
 230
 231 static int mxl1x1sf_tuner_get_lock_status(struct mxl111sf_tuner_state *state,
 232                                           int *rf_synth_lock,
 233                                           int *ref_synth_lock)
 234 {
 235         int ret;
 236         u8 data;
 237
 238         *rf_synth_lock = 0;
 239         *ref_synth_lock = 0;
 240
 241         ret = mxl111sf_tuner_read_reg(state, V6_RF_LOCK_STATUS_REG, &data);
 242         if (mxl_fail(ret))
 243                 goto fail;
 244
 245         *ref_synth_lock = ((data & 0x03) == 0x03) ? 1 : 0;
 246         *rf_synth_lock  = ((data & 0x0c) == 0x0c) ? 1 : 0;
 247 fail:
 248         return ret;
 249 }
 250
 251 #if 0
 252 static int mxl1x1sf_tuner_loop_thru_ctrl(struct mxl111sf_tuner_state *state,
 253                                          int onoff)
 254 {
 255         return mxl111sf_tuner_write_reg(state, V6_TUNER_LOOP_THRU_CTRL_REG,
 256                                         onoff ? 1 : 0);
 257 }
 258 #endif
 259
 260 /* ------------------------------------------------------------------------ */
 261
 262 static int mxl111sf_tuner_set_params(struct dvb_frontend *fe)
 263 {
 264         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 265         u32 delsys  = c->delivery_system;
 266         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 267         int ret;
 268         u8 bw;
 269
 270         mxl_dbg("()");
 271
 272         switch (delsys) {
 273         case SYS_ATSC:
 274         case SYS_ATSCMH:
 275                 bw = 0; /* ATSC */
 276                 break;
 277         case SYS_DVBC_ANNEX_B:
 278                 bw = 1; /* US CABLE */
 279                 break;
 280         case SYS_DVBT:
 281                 switch (c->bandwidth_hz) {
 282                 case 6000000:
 283                         bw = 6;
 284                         break;
 285                 case 7000000:
 286                         bw = 7;
 287                         break;
 288                 case 8000000:
 289                         bw = 8;
 290                         break;
 291                 default:
 292                         pr_err("%s: bandwidth not set!", __func__);
 293                         return -EINVAL;
 294                 }
 295                 break;
 296         default:
 297                 pr_err("%s: modulation type not supported!", __func__);
 298                 return -EINVAL;
 299         }
 300         ret = mxl1x1sf_tune_rf(fe, c->frequency, bw);
 301         if (mxl_fail(ret))
 302                 goto fail;
 303
 304         state->frequency = c->frequency;
 305         state->bandwidth = c->bandwidth_hz;
 306 fail:
 307         return ret;
 308 }
 309
 310 /* ------------------------------------------------------------------------ */
 311
 312 #if 0
 313 static int mxl111sf_tuner_init(struct dvb_frontend *fe)
 314 {
 315         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 316         int ret;
 317
 318         /* wake from standby handled by usb driver */
 319
 320         return ret;
 321 }
 322
 323 static int mxl111sf_tuner_sleep(struct dvb_frontend *fe)
 324 {
 325         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 326         int ret;
 327
 328         /* enter standby mode handled by usb driver */
 329
 330         return ret;
 331 }
 332 #endif
 333
 334 /* ------------------------------------------------------------------------ */
 335
 336 static int mxl111sf_tuner_get_status(struct dvb_frontend *fe, u32 *status)
 337 {
 338         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 339         int rf_locked, ref_locked, ret;
 340
 341         *status = 0;
 342
 343         ret = mxl1x1sf_tuner_get_lock_status(state, &rf_locked, &ref_locked);
 344         if (mxl_fail(ret))
 345                 goto fail;
 346         mxl_info("%s%s", rf_locked ? "rf locked " : "",
 347                  ref_locked ? "ref locked" : "");
 348
 349         if ((rf_locked) || (ref_locked))
 350                 *status |= TUNER_STATUS_LOCKED;
 351 fail:
 352         return ret;
 353 }
 354
 355 static int mxl111sf_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
 356 {
 357         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 358         u8 val1, val2;
 359         int ret;
 360
 361         *strength = 0;
 362
 363         ret = mxl111sf_tuner_write_reg(state, 0x00, 0x02);
 364         if (mxl_fail(ret))
 365                 goto fail;
 366         ret = mxl111sf_tuner_read_reg(state, V6_DIG_RF_PWR_LSB_REG, &val1);
 367         if (mxl_fail(ret))
 368                 goto fail;
 369         ret = mxl111sf_tuner_read_reg(state, V6_DIG_RF_PWR_MSB_REG, &val2);
 370         if (mxl_fail(ret))
 371                 goto fail;
 372
 373         *strength = val1 | ((val2 & 0x07) << 8);
 374 fail:
 375         ret = mxl111sf_tuner_write_reg(state, 0x00, 0x00);
 376         mxl_fail(ret);
 377
 378         return ret;
 379 }
 380
 381 /* ------------------------------------------------------------------------ */
 382
 383 static int mxl111sf_tuner_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 384 {
 385         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 386         *frequency = state->frequency;
 387         return 0;
 388 }
 389
 390 static int mxl111sf_tuner_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 391 {
 392         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 393         *bandwidth = state->bandwidth;
 394         return 0;
 395 }
 396
 397 static int mxl111sf_tuner_get_if_frequency(struct dvb_frontend *fe,
 398                                            u32 *frequency)
 399 {
 400         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 401
 402         *frequency = 0;
 403
 404         switch (state->if_freq) {
 405         case MXL_IF_4_0:   /* 4.0   MHz */
 406                 *frequency = 4000000;
 407                 break;
 408         case MXL_IF_4_5:   /* 4.5   MHz */
 409                 *frequency = 4500000;
 410                 break;
 411         case MXL_IF_4_57:  /* 4.57  MHz */
 412                 *frequency = 4570000;
 413                 break;
 414         case MXL_IF_5_0:   /* 5.0   MHz */
 415                 *frequency = 5000000;
 416                 break;
 417         case MXL_IF_5_38:  /* 5.38  MHz */
 418                 *frequency = 5380000;
 419                 break;
 420         case MXL_IF_6_0:   /* 6.0   MHz */
 421                 *frequency = 6000000;
 422                 break;
 423         case MXL_IF_6_28:  /* 6.28  MHz */
 424                 *frequency = 6280000;
 425                 break;
 426         case MXL_IF_7_2:   /* 7.2   MHz */
 427                 *frequency = 7200000;
 428                 break;
 429         case MXL_IF_35_25: /* 35.25 MHz */
 430                 *frequency = 35250000;
 431                 break;
 432         case MXL_IF_36:    /* 36    MHz */
 433                 *frequency = 36000000;
 434                 break;
 435         case MXL_IF_36_15: /* 36.15 MHz */
 436                 *frequency = 36150000;
 437                 break;
 438         case MXL_IF_44:    /* 44    MHz */
 439                 *frequency = 44000000;
 440                 break;
 441         }
 442         return 0;
 443 }
 444
 445 static void mxl111sf_tuner_release(struct dvb_frontend *fe)
 446 {
 447         struct mxl111sf_tuner_state *state = fe->tuner_priv;
 448         mxl_dbg("()");
 449         kfree(state);
 450         fe->tuner_priv = NULL;
 451 }
 452
 453 /* ------------------------------------------------------------------------- */
 454
 455 static const struct dvb_tuner_ops mxl111sf_tuner_tuner_ops = {
 456         .info = {
 457                 .name = "MaxLinear MxL111SF",
 458 #if 0
 459                 .frequency_min_hz  = ,
 460                 .frequency_max_hz  = ,
 461                 .frequency_step_hz = ,
 462 #endif
 463         },
 464 #if 0
 465         .init              = mxl111sf_tuner_init,
 466         .sleep             = mxl111sf_tuner_sleep,
 467 #endif
 468         .set_params        = mxl111sf_tuner_set_params,
 469         .get_status        = mxl111sf_tuner_get_status,
 470         .get_rf_strength   = mxl111sf_get_rf_strength,
 471         .get_frequency     = mxl111sf_tuner_get_frequency,
 472         .get_bandwidth     = mxl111sf_tuner_get_bandwidth,
 473         .get_if_frequency  = mxl111sf_tuner_get_if_frequency,
 474         .release           = mxl111sf_tuner_release,
 475 };
 476
 477 struct dvb_frontend *mxl111sf_tuner_attach(struct dvb_frontend *fe,
 478                                 struct mxl111sf_state *mxl_state,
 479                                 const struct mxl111sf_tuner_config *cfg)
 480 {
 481         struct mxl111sf_tuner_state *state = NULL;
 482
 483         mxl_dbg("()");
 484
 485         state = kzalloc(sizeof(struct mxl111sf_tuner_state), GFP_KERNEL);
 486         if (state == NULL)
 487                 return NULL;
 488
 489         state->mxl_state = mxl_state;
 490         state->cfg = cfg;
 491
 492         memcpy(&fe->ops.tuner_ops, &mxl111sf_tuner_tuner_ops,
 493                sizeof(struct dvb_tuner_ops));
 494
 495         fe->tuner_priv = state;
 496         return fe;
 497 }
 498 EXPORT_SYMBOL_GPL(mxl111sf_tuner_attach);
 499
 500 MODULE_DESCRIPTION("MaxLinear MxL111SF CMOS tuner driver");
 501 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
 502 MODULE_LICENSE("GPL");
 503 MODULE_VERSION("0.1");