drivers/media/common/tuners/mxl5007t.c

   1 /*
   2  *  mxl5007t.c - driver for the MaxLinear MxL5007T silicon tuner
   3  *
   4  *  Copyright (C) 2008 Michael Krufky <mkrufky@linuxtv.org>
   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 <linux/i2c.h>
  22 #include <linux/types.h>
  23 #include <linux/videodev2.h>
  24 #include "tuner-i2c.h"
  25 #include "mxl5007t.h"
  26
  27 static DEFINE_MUTEX(mxl5007t_list_mutex);
  28 static LIST_HEAD(hybrid_tuner_instance_list);
  29
  30 static int mxl5007t_debug;
  31 module_param_named(debug, mxl5007t_debug, int, 0644);
  32 MODULE_PARM_DESC(debug, "set debug level");
  33
  34 /* ------------------------------------------------------------------------- */
  35
  36 #define mxl_printk(kern, fmt, arg...) \
  37         printk(kern "%s: " fmt "\n", __func__, ##arg)
  38
  39 #define mxl_err(fmt, arg...) \
  40         mxl_printk(KERN_ERR, "%d: " fmt, __LINE__, ##arg)
  41
  42 #define mxl_warn(fmt, arg...) \
  43         mxl_printk(KERN_WARNING, fmt, ##arg)
  44
  45 #define mxl_info(fmt, arg...) \
  46         mxl_printk(KERN_INFO, fmt, ##arg)
  47
  48 #define mxl_debug(fmt, arg...)                          \
  49 ({                                                      \
  50         if (mxl5007t_debug)                             \
  51                 mxl_printk(KERN_DEBUG, fmt, ##arg);     \
  52 })
  53
  54 #define mxl_fail(ret)                                                   \
  55 ({                                                                      \
  56         int __ret;                                                      \
  57         __ret = (ret < 0);                                              \
  58         if (__ret)                                                      \
  59                 mxl_printk(KERN_ERR, "error %d on line %d",             \
  60                            ret, __LINE__);                              \
  61         __ret;                                                          \
  62 })
  63
  64 /* ------------------------------------------------------------------------- */
  65
  66 #define MHz 1000000
  67
  68 enum mxl5007t_mode {
  69         MxL_MODE_OTA_DVBT_ATSC        =    0,
  70         MxL_MODE_OTA_NTSC_PAL_GH      =    1,
  71         MxL_MODE_OTA_PAL_IB           =    2,
  72         MxL_MODE_OTA_PAL_D_SECAM_KL   =    3,
  73         MxL_MODE_OTA_ISDBT            =    4,
  74         MxL_MODE_CABLE_DIGITAL        = 0x10,
  75         MxL_MODE_CABLE_NTSC_PAL_GH    = 0x11,
  76         MxL_MODE_CABLE_PAL_IB         = 0x12,
  77         MxL_MODE_CABLE_PAL_D_SECAM_KL = 0x13,
  78         MxL_MODE_CABLE_SCTE40         = 0x14,
  79 };
  80
  81 enum mxl5007t_chip_version {
  82         MxL_UNKNOWN_ID     = 0x00,
  83         MxL_5007_V1_F1     = 0x11,
  84         MxL_5007_V1_F2     = 0x12,
  85         MxL_5007_V2_100_F1 = 0x21,
  86         MxL_5007_V2_100_F2 = 0x22,
  87         MxL_5007_V2_200_F1 = 0x23,
  88         MxL_5007_V2_200_F2 = 0x24,
  89 };
  90
  91 struct reg_pair_t {
  92         u8 reg;
  93         u8 val;
  94 };
  95
  96 /* ------------------------------------------------------------------------- */
  97
  98 static struct reg_pair_t init_tab[] = {
  99         { 0x0b, 0x44 }, /* XTAL */
 100         { 0x0c, 0x60 }, /* IF */
 101         { 0x10, 0x00 }, /* MISC */
 102         { 0x12, 0xca }, /* IDAC */
 103         { 0x16, 0x90 }, /* MODE */
 104         { 0x32, 0x38 }, /* MODE Analog/Digital */
 105         { 0xd8, 0x18 }, /* CLK_OUT_ENABLE */
 106         { 0x2c, 0x34 }, /* OVERRIDE */
 107         { 0x4d, 0x40 }, /* OVERRIDE */
 108         { 0x7f, 0x02 }, /* OVERRIDE */
 109         { 0x9a, 0x52 }, /* OVERRIDE */
 110         { 0x48, 0x5a }, /* OVERRIDE */
 111         { 0x76, 0x1a }, /* OVERRIDE */
 112         { 0x6a, 0x48 }, /* OVERRIDE */
 113         { 0x64, 0x28 }, /* OVERRIDE */
 114         { 0x66, 0xe6 }, /* OVERRIDE */
 115         { 0x35, 0x0e }, /* OVERRIDE */
 116         { 0x7e, 0x01 }, /* OVERRIDE */
 117         { 0x83, 0x00 }, /* OVERRIDE */
 118         { 0x04, 0x0b }, /* OVERRIDE */
 119         { 0x05, 0x01 }, /* TOP_MASTER_ENABLE */
 120         { 0, 0 }
 121 };
 122
 123 static struct reg_pair_t init_tab_cable[] = {
 124         { 0x0b, 0x44 }, /* XTAL */
 125         { 0x0c, 0x60 }, /* IF */
 126         { 0x10, 0x00 }, /* MISC */
 127         { 0x12, 0xca }, /* IDAC */
 128         { 0x16, 0x90 }, /* MODE */
 129         { 0x32, 0x38 }, /* MODE A/D */
 130         { 0x71, 0x3f }, /* TOP1 */
 131         { 0x72, 0x3f }, /* TOP2 */
 132         { 0x74, 0x3f }, /* TOP3 */
 133         { 0xd8, 0x18 }, /* CLK_OUT_ENABLE */
 134         { 0x2c, 0x34 }, /* OVERRIDE */
 135         { 0x4d, 0x40 }, /* OVERRIDE */
 136         { 0x7f, 0x02 }, /* OVERRIDE */
 137         { 0x9a, 0x52 }, /* OVERRIDE */
 138         { 0x48, 0x5a }, /* OVERRIDE */
 139         { 0x76, 0x1a }, /* OVERRIDE */
 140         { 0x6a, 0x48 }, /* OVERRIDE */
 141         { 0x64, 0x28 }, /* OVERRIDE */
 142         { 0x66, 0xe6 }, /* OVERRIDE */
 143         { 0x35, 0x0e }, /* OVERRIDE */
 144         { 0x7e, 0x01 }, /* OVERRIDE */
 145         { 0x04, 0x0b }, /* OVERRIDE */
 146         { 0x68, 0xb4 }, /* OVERRIDE */
 147         { 0x36, 0x00 }, /* OVERRIDE */
 148         { 0x05, 0x01 }, /* TOP_MASTER_ENABLE */
 149         { 0, 0 }
 150 };
 151
 152 /* ------------------------------------------------------------------------- */
 153
 154 static struct reg_pair_t reg_pair_rftune[] = {
 155         { 0x11, 0x00 }, /* abort tune */
 156         { 0x13, 0x15 },
 157         { 0x14, 0x40 },
 158         { 0x15, 0x0e },
 159         { 0x11, 0x02 }, /* start tune */
 160         { 0, 0 }
 161 };
 162
 163 /* ------------------------------------------------------------------------- */
 164
 165 struct mxl5007t_state {
 166         struct list_head hybrid_tuner_instance_list;
 167         struct tuner_i2c_props i2c_props;
 168
 169         struct mutex lock;
 170
 171         struct mxl5007t_config *config;
 172
 173         enum mxl5007t_chip_version chip_id;
 174
 175         struct reg_pair_t tab_init[ARRAY_SIZE(init_tab)];
 176         struct reg_pair_t tab_init_cable[ARRAY_SIZE(init_tab_cable)];
 177         struct reg_pair_t tab_rftune[ARRAY_SIZE(reg_pair_rftune)];
 178
 179         u32 frequency;
 180         u32 bandwidth;
 181 };
 182
 183 /* ------------------------------------------------------------------------- */
 184
 185 /* called by _init and _rftun to manipulate the register arrays */
 186
 187 static void set_reg_bits(struct reg_pair_t *reg_pair, u8 reg, u8 mask, u8 val)
 188 {
 189         unsigned int i = 0;
 190
 191         while (reg_pair[i].reg || reg_pair[i].val) {
 192                 if (reg_pair[i].reg == reg) {
 193                         reg_pair[i].val &= ~mask;
 194                         reg_pair[i].val |= val;
 195                 }
 196                 i++;
 197
 198         }
 199         return;
 200 }
 201
 202 static void copy_reg_bits(struct reg_pair_t *reg_pair1,
 203                           struct reg_pair_t *reg_pair2)
 204 {
 205         unsigned int i, j;
 206
 207         i = j = 0;
 208
 209         while (reg_pair1[i].reg || reg_pair1[i].val) {
 210                 while (reg_pair2[j].reg || reg_pair2[j].reg) {
 211                         if (reg_pair1[i].reg != reg_pair2[j].reg) {
 212                                 j++;
 213                                 continue;
 214                         }
 215                         reg_pair2[j].val = reg_pair1[i].val;
 216                         break;
 217                 }
 218                 i++;
 219         }
 220         return;
 221 }
 222
 223 /* ------------------------------------------------------------------------- */
 224
 225 static void mxl5007t_set_mode_bits(struct mxl5007t_state *state,
 226                                    enum mxl5007t_mode mode,
 227                                    s32 if_diff_out_level)
 228 {
 229         switch (mode) {
 230         case MxL_MODE_OTA_DVBT_ATSC:
 231                 set_reg_bits(state->tab_init, 0x32, 0x0f, 0x06);
 232                 set_reg_bits(state->tab_init, 0x35, 0xff, 0x0e);
 233                 break;
 234         case MxL_MODE_OTA_ISDBT:
 235                 set_reg_bits(state->tab_init, 0x32, 0x0f, 0x06);
 236                 set_reg_bits(state->tab_init, 0x35, 0xff, 0x12);
 237                 break;
 238         case MxL_MODE_OTA_NTSC_PAL_GH:
 239                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x00);
 240                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 241                 break;
 242         case MxL_MODE_OTA_PAL_IB:
 243                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x10);
 244                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 245                 break;
 246         case MxL_MODE_OTA_PAL_D_SECAM_KL:
 247                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x20);
 248                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 249                 break;
 250         case MxL_MODE_CABLE_DIGITAL:
 251                 set_reg_bits(state->tab_init_cable, 0x71, 0xff, 0x01);
 252                 set_reg_bits(state->tab_init_cable, 0x72, 0xff,
 253                              8 - if_diff_out_level);
 254                 set_reg_bits(state->tab_init_cable, 0x74, 0xff, 0x17);
 255                 break;
 256         case MxL_MODE_CABLE_NTSC_PAL_GH:
 257                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x00);
 258                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 259                 set_reg_bits(state->tab_init_cable, 0x71, 0xff, 0x01);
 260                 set_reg_bits(state->tab_init_cable, 0x72, 0xff,
 261                              8 - if_diff_out_level);
 262                 set_reg_bits(state->tab_init_cable, 0x74, 0xff, 0x17);
 263                 break;
 264         case MxL_MODE_CABLE_PAL_IB:
 265                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x10);
 266                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 267                 set_reg_bits(state->tab_init_cable, 0x71, 0xff, 0x01);
 268                 set_reg_bits(state->tab_init_cable, 0x72, 0xff,
 269                              8 - if_diff_out_level);
 270                 set_reg_bits(state->tab_init_cable, 0x74, 0xff, 0x17);
 271                 break;
 272         case MxL_MODE_CABLE_PAL_D_SECAM_KL:
 273                 set_reg_bits(state->tab_init, 0x16, 0x70, 0x20);
 274                 set_reg_bits(state->tab_init, 0x32, 0xff, 0x85);
 275                 set_reg_bits(state->tab_init_cable, 0x71, 0xff, 0x01);
 276                 set_reg_bits(state->tab_init_cable, 0x72, 0xff,
 277                              8 - if_diff_out_level);
 278                 set_reg_bits(state->tab_init_cable, 0x74, 0xff, 0x17);
 279                 break;
 280         case MxL_MODE_CABLE_SCTE40:
 281                 set_reg_bits(state->tab_init_cable, 0x36, 0xff, 0x08);
 282                 set_reg_bits(state->tab_init_cable, 0x68, 0xff, 0xbc);
 283                 set_reg_bits(state->tab_init_cable, 0x71, 0xff, 0x01);
 284                 set_reg_bits(state->tab_init_cable, 0x72, 0xff,
 285                              8 - if_diff_out_level);
 286                 set_reg_bits(state->tab_init_cable, 0x74, 0xff, 0x17);
 287                 break;
 288         default:
 289                 mxl_fail(-EINVAL);
 290         }
 291         return;
 292 }
 293
 294 static void mxl5007t_set_if_freq_bits(struct mxl5007t_state *state,
 295                                       enum mxl5007t_if_freq if_freq,
 296                                       int invert_if)
 297 {
 298         u8 val;
 299
 300         switch (if_freq) {
 301         case MxL_IF_4_MHZ:
 302                 val = 0x00;
 303                 break;
 304         case MxL_IF_4_5_MHZ:
 305                 val = 0x20;
 306                 break;
 307         case MxL_IF_4_57_MHZ:
 308                 val = 0x30;
 309                 break;
 310         case MxL_IF_5_MHZ:
 311                 val = 0x40;
 312                 break;
 313         case MxL_IF_5_38_MHZ:
 314                 val = 0x50;
 315                 break;
 316         case MxL_IF_6_MHZ:
 317                 val = 0x60;
 318                 break;
 319         case MxL_IF_6_28_MHZ:
 320                 val = 0x70;
 321                 break;
 322         case MxL_IF_9_1915_MHZ:
 323                 val = 0x80;
 324                 break;
 325         case MxL_IF_35_25_MHZ:
 326                 val = 0x90;
 327                 break;
 328         case MxL_IF_36_15_MHZ:
 329                 val = 0xa0;
 330                 break;
 331         case MxL_IF_44_MHZ:
 332                 val = 0xb0;
 333                 break;
 334         default:
 335                 mxl_fail(-EINVAL);
 336                 return;
 337         }
 338         set_reg_bits(state->tab_init, 0x0c, 0xf0, val);
 339
 340         /* set inverted IF or normal IF */
 341         set_reg_bits(state->tab_init, 0x0c, 0x08, invert_if ? 0x08 : 0x00);
 342
 343         return;
 344 }
 345
 346 static void mxl5007t_set_xtal_freq_bits(struct mxl5007t_state *state,
 347                                         enum mxl5007t_xtal_freq xtal_freq)
 348 {
 349         u8 val;
 350
 351         switch (xtal_freq) {
 352         case MxL_XTAL_16_MHZ:
 353                 val = 0x00; /* select xtal freq & Ref Freq */
 354                 break;
 355         case MxL_XTAL_20_MHZ:
 356                 val = 0x11;
 357                 break;
 358         case MxL_XTAL_20_25_MHZ:
 359                 val = 0x22;
 360                 break;
 361         case MxL_XTAL_20_48_MHZ:
 362                 val = 0x33;
 363                 break;
 364         case MxL_XTAL_24_MHZ:
 365                 val = 0x44;
 366                 break;
 367         case MxL_XTAL_25_MHZ:
 368                 val = 0x55;
 369                 break;
 370         case MxL_XTAL_25_14_MHZ:
 371                 val = 0x66;
 372                 break;
 373         case MxL_XTAL_27_MHZ:
 374                 val = 0x77;
 375                 break;
 376         case MxL_XTAL_28_8_MHZ:
 377                 val = 0x88;
 378                 break;
 379         case MxL_XTAL_32_MHZ:
 380                 val = 0x99;
 381                 break;
 382         case MxL_XTAL_40_MHZ:
 383                 val = 0xaa;
 384                 break;
 385         case MxL_XTAL_44_MHZ:
 386                 val = 0xbb;
 387                 break;
 388         case MxL_XTAL_48_MHZ:
 389                 val = 0xcc;
 390                 break;
 391         case MxL_XTAL_49_3811_MHZ:
 392                 val = 0xdd;
 393                 break;
 394         default:
 395                 mxl_fail(-EINVAL);
 396                 return;
 397         }
 398         set_reg_bits(state->tab_init, 0x0b, 0xff, val);
 399
 400         return;
 401 }
 402
 403 static struct reg_pair_t *mxl5007t_calc_init_regs(struct mxl5007t_state *state,
 404                                                   enum mxl5007t_mode mode)
 405 {
 406         struct mxl5007t_config *cfg = state->config;
 407
 408         memcpy(&state->tab_init, &init_tab, sizeof(init_tab));
 409         memcpy(&state->tab_init_cable, &init_tab_cable, sizeof(init_tab_cable));
 410
 411         mxl5007t_set_mode_bits(state, mode, cfg->if_diff_out_level);
 412         mxl5007t_set_if_freq_bits(state, cfg->if_freq_hz, cfg->invert_if);
 413         mxl5007t_set_xtal_freq_bits(state, cfg->xtal_freq_hz);
 414
 415         set_reg_bits(state->tab_init, 0x10, 0x40, cfg->loop_thru_enable << 6);
 416
 417         set_reg_bits(state->tab_init, 0xd8, 0x08, cfg->clk_out_enable << 3);
 418
 419         set_reg_bits(state->tab_init, 0x10, 0x07, cfg->clk_out_amp);
 420
 421         /* set IDAC to automatic mode control by AGC */
 422         set_reg_bits(state->tab_init, 0x12, 0x80, 0x00);
 423
 424         if (mode >= MxL_MODE_CABLE_DIGITAL) {
 425                 copy_reg_bits(state->tab_init, state->tab_init_cable);
 426                 return state->tab_init_cable;
 427         } else
 428                 return state->tab_init;
 429 }
 430
 431 /* ------------------------------------------------------------------------- */
 432
 433 enum mxl5007t_bw_mhz {
 434         MxL_BW_6MHz = 6,
 435         MxL_BW_7MHz = 7,
 436         MxL_BW_8MHz = 8,
 437 };
 438
 439 static void mxl5007t_set_bw_bits(struct mxl5007t_state *state,
 440                                  enum mxl5007t_bw_mhz bw)
 441 {
 442         u8 val;
 443
 444         switch (bw) {
 445         case MxL_BW_6MHz:
 446                 val = 0x15; /* set DIG_MODEINDEX, DIG_MODEINDEX_A,
 447                              * and DIG_MODEINDEX_CSF */
 448                 break;
 449         case MxL_BW_7MHz:
 450                 val = 0x21;
 451                 break;
 452         case MxL_BW_8MHz:
 453                 val = 0x3f;
 454                 break;
 455         default:
 456                 mxl_fail(-EINVAL);
 457                 return;
 458         }
 459         set_reg_bits(state->tab_rftune, 0x13, 0x3f, val);
 460
 461         return;
 462 }
 463
 464 static struct
 465 reg_pair_t *mxl5007t_calc_rf_tune_regs(struct mxl5007t_state *state,
 466                                        u32 rf_freq, enum mxl5007t_bw_mhz bw)
 467 {
 468         u32 dig_rf_freq = 0;
 469         u32 temp;
 470         u32 frac_divider = 1000000;
 471         unsigned int i;
 472
 473         memcpy(&state->tab_rftune, &reg_pair_rftune, sizeof(reg_pair_rftune));
 474
 475         mxl5007t_set_bw_bits(state, bw);
 476
 477         /* Convert RF frequency into 16 bits =>
 478          * 10 bit integer (MHz) + 6 bit fraction */
 479         dig_rf_freq = rf_freq / MHz;
 480
 481         temp = rf_freq % MHz;
 482
 483         for (i = 0; i < 6; i++) {
 484                 dig_rf_freq <<= 1;
 485                 frac_divider /= 2;
 486                 if (temp > frac_divider) {
 487                         temp -= frac_divider;
 488                         dig_rf_freq++;
 489                 }
 490         }
 491
 492         /* add to have shift center point by 7.8124 kHz */
 493         if (temp > 7812)
 494                 dig_rf_freq++;
 495
 496         set_reg_bits(state->tab_rftune, 0x14, 0xff, (u8)dig_rf_freq);
 497         set_reg_bits(state->tab_rftune, 0x15, 0xff, (u8)(dig_rf_freq >> 8));
 498
 499         return state->tab_rftune;
 500 }
 501
 502 /* ------------------------------------------------------------------------- */
 503
 504 static int mxl5007t_write_reg(struct mxl5007t_state *state, u8 reg, u8 val)
 505 {
 506         u8 buf[] = { reg, val };
 507         struct i2c_msg msg = { .addr = state->i2c_props.addr, .flags = 0,
 508                                .buf = buf, .len = 2 };
 509         int ret;
 510
 511         ret = i2c_transfer(state->i2c_props.adap, &msg, 1);
 512         if (ret != 1) {
 513                 mxl_err("failed!");
 514                 return -EREMOTEIO;
 515         }
 516         return 0;
 517 }
 518
 519 static int mxl5007t_write_regs(struct mxl5007t_state *state,
 520                                struct reg_pair_t *reg_pair)
 521 {
 522         unsigned int i = 0;
 523         int ret = 0;
 524
 525         while ((ret == 0) && (reg_pair[i].reg || reg_pair[i].val)) {
 526                 ret = mxl5007t_write_reg(state,
 527                                          reg_pair[i].reg, reg_pair[i].val);
 528                 i++;
 529         }
 530         return ret;
 531 }
 532
 533 static int mxl5007t_read_reg(struct mxl5007t_state *state, u8 reg, u8 *val)
 534 {
 535         struct i2c_msg msg[] = {
 536                 { .addr = state->i2c_props.addr, .flags = 0,
 537                   .buf = &reg, .len = 1 },
 538                 { .addr = state->i2c_props.addr, .flags = I2C_M_RD,
 539                   .buf = val, .len = 1 },
 540         };
 541         int ret;
 542
 543         ret = i2c_transfer(state->i2c_props.adap, msg, 2);
 544         if (ret != 2) {
 545                 mxl_err("failed!");
 546                 return -EREMOTEIO;
 547         }
 548         return 0;
 549 }
 550
 551 static int mxl5007t_soft_reset(struct mxl5007t_state *state)
 552 {
 553         u8 d = 0xff;
 554         struct i2c_msg msg = { .addr = state->i2c_props.addr, .flags = 0,
 555                                .buf = &d, .len = 1 };
 556
 557         int ret = i2c_transfer(state->i2c_props.adap, &msg, 1);
 558
 559         if (ret != 1) {
 560                 mxl_err("failed!");
 561                 return -EREMOTEIO;
 562         }
 563         return 0;
 564 }
 565
 566 static int mxl5007t_tuner_init(struct mxl5007t_state *state,
 567                                enum mxl5007t_mode mode)
 568 {
 569         struct reg_pair_t *init_regs;
 570         int ret;
 571
 572         ret = mxl5007t_soft_reset(state);
 573         if (mxl_fail(ret))
 574                 goto fail;
 575
 576         /* calculate initialization reg array */
 577         init_regs = mxl5007t_calc_init_regs(state, mode);
 578
 579         ret = mxl5007t_write_regs(state, init_regs);
 580         if (mxl_fail(ret))
 581                 goto fail;
 582         mdelay(1);
 583
 584         ret = mxl5007t_write_reg(state, 0x2c, 0x35);
 585         mxl_fail(ret);
 586 fail:
 587         return ret;
 588 }
 589
 590 static int mxl5007t_tuner_rf_tune(struct mxl5007t_state *state, u32 rf_freq_hz,
 591                                   enum mxl5007t_bw_mhz bw)
 592 {
 593         struct reg_pair_t *rf_tune_regs;
 594         int ret;
 595
 596         /* calculate channel change reg array */
 597         rf_tune_regs = mxl5007t_calc_rf_tune_regs(state, rf_freq_hz, bw);
 598
 599         ret = mxl5007t_write_regs(state, rf_tune_regs);
 600         if (mxl_fail(ret))
 601                 goto fail;
 602         msleep(3);
 603 fail:
 604         return ret;
 605 }
 606
 607 /* ------------------------------------------------------------------------- */
 608
 609 static int mxl5007t_synth_lock_status(struct mxl5007t_state *state,
 610                                       int *rf_locked, int *ref_locked)
 611 {
 612         u8 d;
 613         int ret;
 614
 615         *rf_locked = 0;
 616         *ref_locked = 0;
 617
 618         ret = mxl5007t_read_reg(state, 0xcf, &d);
 619         if (mxl_fail(ret))
 620                 goto fail;
 621
 622         if ((d & 0x0c) == 0x0c)
 623                 *rf_locked = 1;
 624
 625         if ((d & 0x03) == 0x03)
 626                 *ref_locked = 1;
 627 fail:
 628         return ret;
 629 }
 630
 631 static int mxl5007t_check_rf_input_power(struct mxl5007t_state *state,
 632                                          s32 *rf_input_level)
 633 {
 634         u8 d1, d2;
 635         int ret;
 636
 637         ret = mxl5007t_read_reg(state, 0xb7, &d1);
 638         if (mxl_fail(ret))
 639                 goto fail;
 640
 641         ret = mxl5007t_read_reg(state, 0xbf, &d2);
 642         if (mxl_fail(ret))
 643                 goto fail;
 644
 645         d2 = d2 >> 4;
 646         if (d2 > 7)
 647                 d2 += 0xf0;
 648
 649         *rf_input_level = (s32)(d1 + d2 - 113);
 650 fail:
 651         return ret;
 652 }
 653
 654 /* ------------------------------------------------------------------------- */
 655
 656 static int mxl5007t_get_status(struct dvb_frontend *fe, u32 *status)
 657 {
 658         struct mxl5007t_state *state = fe->tuner_priv;
 659         int rf_locked, ref_locked;
 660         s32 rf_input_level = 0;
 661         int ret;
 662
 663         if (fe->ops.i2c_gate_ctrl)
 664                 fe->ops.i2c_gate_ctrl(fe, 1);
 665
 666         ret = mxl5007t_synth_lock_status(state, &rf_locked, &ref_locked);
 667         if (mxl_fail(ret))
 668                 goto fail;
 669         mxl_debug("%s%s", rf_locked ? "rf locked " : "",
 670                   ref_locked ? "ref locked" : "");
 671
 672         ret = mxl5007t_check_rf_input_power(state, &rf_input_level);
 673         if (mxl_fail(ret))
 674                 goto fail;
 675         mxl_debug("rf input power: %d", rf_input_level);
 676 fail:
 677         if (fe->ops.i2c_gate_ctrl)
 678                 fe->ops.i2c_gate_ctrl(fe, 0);
 679
 680         return ret;
 681 }
 682
 683 /* ------------------------------------------------------------------------- */
 684
 685 static int mxl5007t_set_params(struct dvb_frontend *fe,
 686                                struct dvb_frontend_parameters *params)
 687 {
 688         struct mxl5007t_state *state = fe->tuner_priv;
 689         enum mxl5007t_bw_mhz bw;
 690         enum mxl5007t_mode mode;
 691         int ret;
 692         u32 freq = params->frequency;
 693
 694         if (fe->ops.info.type == FE_ATSC) {
 695                 switch (params->u.vsb.modulation) {
 696                 case VSB_8:
 697                 case VSB_16:
 698                         mode = MxL_MODE_OTA_DVBT_ATSC;
 699                         break;
 700                 case QAM_64:
 701                 case QAM_256:
 702                         mode = MxL_MODE_CABLE_DIGITAL;
 703                         break;
 704                 default:
 705                         mxl_err("modulation not set!");
 706                         return -EINVAL;
 707                 }
 708                 bw = MxL_BW_6MHz;
 709         } else if (fe->ops.info.type == FE_OFDM) {
 710                 switch (params->u.ofdm.bandwidth) {
 711                 case BANDWIDTH_6_MHZ:
 712                         bw = MxL_BW_6MHz;
 713                         break;
 714                 case BANDWIDTH_7_MHZ:
 715                         bw = MxL_BW_7MHz;
 716                         break;
 717                 case BANDWIDTH_8_MHZ:
 718                         bw = MxL_BW_8MHz;
 719                         break;
 720                 default:
 721                         mxl_err("bandwidth not set!");
 722                         return -EINVAL;
 723                 }
 724                 mode = MxL_MODE_OTA_DVBT_ATSC;
 725         } else {
 726                 mxl_err("modulation type not supported!");
 727                 return -EINVAL;
 728         }
 729
 730         if (fe->ops.i2c_gate_ctrl)
 731                 fe->ops.i2c_gate_ctrl(fe, 1);
 732
 733         mutex_lock(&state->lock);
 734
 735         ret = mxl5007t_tuner_init(state, mode);
 736         if (mxl_fail(ret))
 737                 goto fail;
 738
 739         ret = mxl5007t_tuner_rf_tune(state, freq, bw);
 740         if (mxl_fail(ret))
 741                 goto fail;
 742
 743         state->frequency = freq;
 744         state->bandwidth = (fe->ops.info.type == FE_OFDM) ?
 745                 params->u.ofdm.bandwidth : 0;
 746 fail:
 747         mutex_unlock(&state->lock);
 748
 749         if (fe->ops.i2c_gate_ctrl)
 750                 fe->ops.i2c_gate_ctrl(fe, 0);
 751
 752         return ret;
 753 }
 754
 755 static int mxl5007t_set_analog_params(struct dvb_frontend *fe,
 756                                       struct analog_parameters *params)
 757 {
 758         struct mxl5007t_state *state = fe->tuner_priv;
 759         enum mxl5007t_bw_mhz bw = 0; /* FIXME */
 760         enum mxl5007t_mode cbl_mode;
 761         enum mxl5007t_mode ota_mode;
 762         char *mode_name;
 763         int ret;
 764         u32 freq = params->frequency * 62500;
 765
 766 #define cable 1
 767         if (params->std & V4L2_STD_MN) {
 768                 cbl_mode = MxL_MODE_CABLE_NTSC_PAL_GH;
 769                 ota_mode = MxL_MODE_OTA_NTSC_PAL_GH;
 770                 mode_name = "MN";
 771         } else if (params->std & V4L2_STD_B) {
 772                 cbl_mode = MxL_MODE_CABLE_PAL_IB;
 773                 ota_mode = MxL_MODE_OTA_PAL_IB;
 774                 mode_name = "B";
 775         } else if (params->std & V4L2_STD_GH) {
 776                 cbl_mode = MxL_MODE_CABLE_NTSC_PAL_GH;
 777                 ota_mode = MxL_MODE_OTA_NTSC_PAL_GH;
 778                 mode_name = "GH";
 779         } else if (params->std & V4L2_STD_PAL_I) {
 780                 cbl_mode = MxL_MODE_CABLE_PAL_IB;
 781                 ota_mode = MxL_MODE_OTA_PAL_IB;
 782                 mode_name = "I";
 783         } else if (params->std & V4L2_STD_DK) {
 784                 cbl_mode = MxL_MODE_CABLE_PAL_D_SECAM_KL;
 785                 ota_mode = MxL_MODE_OTA_PAL_D_SECAM_KL;
 786                 mode_name = "DK";
 787         } else if (params->std & V4L2_STD_SECAM_L) {
 788                 cbl_mode = MxL_MODE_CABLE_PAL_D_SECAM_KL;
 789                 ota_mode = MxL_MODE_OTA_PAL_D_SECAM_KL;
 790                 mode_name = "L";
 791         } else if (params->std & V4L2_STD_SECAM_LC) {
 792                 cbl_mode = MxL_MODE_CABLE_PAL_D_SECAM_KL;
 793                 ota_mode = MxL_MODE_OTA_PAL_D_SECAM_KL;
 794                 mode_name = "L'";
 795         } else {
 796                 mode_name = "xx";
 797                 /* FIXME */
 798                 cbl_mode = MxL_MODE_CABLE_NTSC_PAL_GH;
 799                 ota_mode = MxL_MODE_OTA_NTSC_PAL_GH;
 800         }
 801         mxl_debug("setting mxl5007 to system %s", mode_name);
 802
 803         if (fe->ops.i2c_gate_ctrl)
 804                 fe->ops.i2c_gate_ctrl(fe, 1);
 805
 806         mutex_lock(&state->lock);
 807
 808         ret = mxl5007t_tuner_init(state, cable ? cbl_mode : ota_mode);
 809         if (mxl_fail(ret))
 810                 goto fail;
 811
 812         ret = mxl5007t_tuner_rf_tune(state, freq, bw);
 813         if (mxl_fail(ret))
 814                 goto fail;
 815
 816         state->frequency = freq;
 817         state->bandwidth = 0;
 818 fail:
 819         mutex_unlock(&state->lock);
 820
 821         if (fe->ops.i2c_gate_ctrl)
 822                 fe->ops.i2c_gate_ctrl(fe, 0);
 823
 824         return ret;
 825 }
 826
 827 /* ------------------------------------------------------------------------- */
 828
 829 static int mxl5007t_init(struct dvb_frontend *fe)
 830 {
 831         struct mxl5007t_state *state = fe->tuner_priv;
 832         int ret;
 833         u8 d;
 834
 835         if (fe->ops.i2c_gate_ctrl)
 836                 fe->ops.i2c_gate_ctrl(fe, 1);
 837
 838         ret = mxl5007t_read_reg(state, 0x05, &d);
 839         if (mxl_fail(ret))
 840                 goto fail;
 841
 842         ret = mxl5007t_write_reg(state, 0x05, d | 0x01);
 843         mxl_fail(ret);
 844 fail:
 845         if (fe->ops.i2c_gate_ctrl)
 846                 fe->ops.i2c_gate_ctrl(fe, 0);
 847
 848         return ret;
 849 }
 850
 851 static int mxl5007t_sleep(struct dvb_frontend *fe)
 852 {
 853         struct mxl5007t_state *state = fe->tuner_priv;
 854         int ret;
 855         u8 d;
 856
 857         if (fe->ops.i2c_gate_ctrl)
 858                 fe->ops.i2c_gate_ctrl(fe, 1);
 859
 860         ret = mxl5007t_read_reg(state, 0x05, &d);
 861         if (mxl_fail(ret))
 862                 goto fail;
 863
 864         ret = mxl5007t_write_reg(state, 0x05, d & ~0x01);
 865         mxl_fail(ret);
 866 fail:
 867         if (fe->ops.i2c_gate_ctrl)
 868                 fe->ops.i2c_gate_ctrl(fe, 0);
 869
 870         return ret;
 871 }
 872
 873 /* ------------------------------------------------------------------------- */
 874
 875 static int mxl5007t_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 876 {
 877         struct mxl5007t_state *state = fe->tuner_priv;
 878         *frequency = state->frequency;
 879         return 0;
 880 }
 881
 882 static int mxl5007t_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 883 {
 884         struct mxl5007t_state *state = fe->tuner_priv;
 885         *bandwidth = state->bandwidth;
 886         return 0;
 887 }
 888
 889 static int mxl5007t_release(struct dvb_frontend *fe)
 890 {
 891         struct mxl5007t_state *state = fe->tuner_priv;
 892
 893         mutex_lock(&mxl5007t_list_mutex);
 894
 895         if (state)
 896                 hybrid_tuner_release_state(state);
 897
 898         mutex_unlock(&mxl5007t_list_mutex);
 899
 900         fe->tuner_priv = NULL;
 901
 902         return 0;
 903 }
 904
 905 /* ------------------------------------------------------------------------- */
 906
 907 static struct dvb_tuner_ops mxl5007t_tuner_ops = {
 908         .info = {
 909                 .name = "MaxLinear MxL5007T",
 910         },
 911         .init              = mxl5007t_init,
 912         .sleep             = mxl5007t_sleep,
 913         .set_params        = mxl5007t_set_params,
 914         .set_analog_params = mxl5007t_set_analog_params,
 915         .get_status        = mxl5007t_get_status,
 916         .get_frequency     = mxl5007t_get_frequency,
 917         .get_bandwidth     = mxl5007t_get_bandwidth,
 918         .release           = mxl5007t_release,
 919 };
 920
 921 static int mxl5007t_get_chip_id(struct mxl5007t_state *state)
 922 {
 923         char *name;
 924         int ret;
 925         u8 id;
 926
 927         ret = mxl5007t_read_reg(state, 0xd3, &id);
 928         if (mxl_fail(ret))
 929                 goto fail;
 930
 931         switch (id) {
 932         case MxL_5007_V1_F1:
 933                 name = "MxL5007.v1.f1";
 934                 break;
 935         case MxL_5007_V1_F2:
 936                 name = "MxL5007.v1.f2";
 937                 break;
 938         case MxL_5007_V2_100_F1:
 939                 name = "MxL5007.v2.100.f1";
 940                 break;
 941         case MxL_5007_V2_100_F2:
 942                 name = "MxL5007.v2.100.f2";
 943                 break;
 944         case MxL_5007_V2_200_F1:
 945                 name = "MxL5007.v2.200.f1";
 946                 break;
 947         case MxL_5007_V2_200_F2:
 948                 name = "MxL5007.v2.200.f2";
 949                 break;
 950         default:
 951                 name = "MxL5007T";
 952                 id = MxL_UNKNOWN_ID;
 953         }
 954         state->chip_id = id;
 955         mxl_info("%s detected @ %d-%04x", name,
 956                  i2c_adapter_id(state->i2c_props.adap),
 957                  state->i2c_props.addr);
 958         return 0;
 959 fail:
 960         mxl_warn("unable to identify device @ %d-%04x",
 961                  i2c_adapter_id(state->i2c_props.adap),
 962                  state->i2c_props.addr);
 963
 964         state->chip_id = MxL_UNKNOWN_ID;
 965         return ret;
 966 }
 967
 968 struct dvb_frontend *mxl5007t_attach(struct dvb_frontend *fe,
 969                                      struct i2c_adapter *i2c, u8 addr,
 970                                      struct mxl5007t_config *cfg)
 971 {
 972         struct mxl5007t_state *state = NULL;
 973         int instance, ret;
 974
 975         mutex_lock(&mxl5007t_list_mutex);
 976         instance = hybrid_tuner_request_state(struct mxl5007t_state, state,
 977                                               hybrid_tuner_instance_list,
 978                                               i2c, addr, "mxl5007");
 979         switch (instance) {
 980         case 0:
 981                 goto fail;
 982         case 1:
 983                 /* new tuner instance */
 984                 state->config = cfg;
 985
 986                 mutex_init(&state->lock);
 987
 988                 if (fe->ops.i2c_gate_ctrl)
 989                         fe->ops.i2c_gate_ctrl(fe, 1);
 990
 991                 ret = mxl5007t_get_chip_id(state);
 992
 993                 if (fe->ops.i2c_gate_ctrl)
 994                         fe->ops.i2c_gate_ctrl(fe, 0);
 995
 996                 /* check return value of mxl5007t_get_chip_id */
 997                 if (mxl_fail(ret))
 998                         goto fail;
 999                 break;
1000         default:
1001                 /* existing tuner instance */
1002                 break;
1003         }
1004         fe->tuner_priv = state;
1005         mutex_unlock(&mxl5007t_list_mutex);
1006
1007         memcpy(&fe->ops.tuner_ops, &mxl5007t_tuner_ops,
1008                sizeof(struct dvb_tuner_ops));
1009
1010         return fe;
1011 fail:
1012         mutex_unlock(&mxl5007t_list_mutex);
1013
1014         mxl5007t_release(fe);
1015         return NULL;
1016 }
1017 EXPORT_SYMBOL_GPL(mxl5007t_attach);
1018 MODULE_DESCRIPTION("MaxLinear MxL5007T Silicon IC tuner driver");
1019 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
1020 MODULE_LICENSE("GPL");
1021 MODULE_VERSION("0.1");
1022
1023 /*
1024  * Overrides for Emacs so that we follow Linus's tabbing style.
1025  * ---------------------------------------------------------------------------
1026  * Local variables:
1027  * c-basic-offset: 8
1028  * End:
1029  */