Pileus Git - ~andy/linux/blob - drivers/media/dvb/dvb-usb/mxl111sf-tuner.c

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