drivers/media/common/tuners/mxl5007t.c

   1 /*
   2  *  mxl5007t.c - driver for the MaxLinear MxL5007T silicon tuner
   3  *
   4  *  Copyright (C) 2008, 2009 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_ISDBT     =    0,
  70         MxL_MODE_DVBT      =    1,
  71         MxL_MODE_ATSC      =    2,
  72         MxL_MODE_CABLE     = 0x10,
  73 };
  74
  75 enum mxl5007t_chip_version {
  76         MxL_UNKNOWN_ID     = 0x00,
  77         MxL_5007_V1_F1     = 0x11,
  78         MxL_5007_V1_F2     = 0x12,
  79         MxL_5007_V4        = 0x14,
  80         MxL_5007_V2_100_F1 = 0x21,
  81         MxL_5007_V2_100_F2 = 0x22,
  82         MxL_5007_V2_200_F1 = 0x23,
  83         MxL_5007_V2_200_F2 = 0x24,
  84 };
  85
  86 struct reg_pair_t {
  87         u8 reg;
  88         u8 val;
  89 };
  90
  91 /* ------------------------------------------------------------------------- */
  92
  93 static struct reg_pair_t init_tab[] = {
  94         { 0x02, 0x06 },
  95         { 0x03, 0x48 },
  96         { 0x05, 0x04 },
  97         { 0x06, 0x10 },
  98         { 0x2e, 0x15 }, /* OVERRIDE */
  99         { 0x30, 0x10 }, /* OVERRIDE */
 100         { 0x45, 0x58 }, /* OVERRIDE */
 101         { 0x48, 0x19 }, /* OVERRIDE */
 102         { 0x52, 0x03 }, /* OVERRIDE */
 103         { 0x53, 0x44 }, /* OVERRIDE */
 104         { 0x6a, 0x4b }, /* OVERRIDE */
 105         { 0x76, 0x00 }, /* OVERRIDE */
 106         { 0x78, 0x18 }, /* OVERRIDE */
 107         { 0x7a, 0x17 }, /* OVERRIDE */
 108         { 0x85, 0x06 }, /* OVERRIDE */
 109         { 0x01, 0x01 }, /* TOP_MASTER_ENABLE */
 110         { 0, 0 }
 111 };
 112
 113 static struct reg_pair_t init_tab_cable[] = {
 114         { 0x02, 0x06 },
 115         { 0x03, 0x48 },
 116         { 0x05, 0x04 },
 117         { 0x06, 0x10 },
 118         { 0x09, 0x3f },
 119         { 0x0a, 0x3f },
 120         { 0x0b, 0x3f },
 121         { 0x2e, 0x15 }, /* OVERRIDE */
 122         { 0x30, 0x10 }, /* OVERRIDE */
 123         { 0x45, 0x58 }, /* OVERRIDE */
 124         { 0x48, 0x19 }, /* OVERRIDE */
 125         { 0x52, 0x03 }, /* OVERRIDE */
 126         { 0x53, 0x44 }, /* OVERRIDE */
 127         { 0x6a, 0x4b }, /* OVERRIDE */
 128         { 0x76, 0x00 }, /* OVERRIDE */
 129         { 0x78, 0x18 }, /* OVERRIDE */
 130         { 0x7a, 0x17 }, /* OVERRIDE */
 131         { 0x85, 0x06 }, /* OVERRIDE */
 132         { 0x01, 0x01 }, /* TOP_MASTER_ENABLE */
 133         { 0, 0 }
 134 };
 135
 136 /* ------------------------------------------------------------------------- */
 137
 138 static struct reg_pair_t reg_pair_rftune[] = {
 139         { 0x0f, 0x00 }, /* abort tune */
 140         { 0x0c, 0x15 },
 141         { 0x0d, 0x40 },
 142         { 0x0e, 0x0e },
 143         { 0x1f, 0x87 }, /* OVERRIDE */
 144         { 0x20, 0x1f }, /* OVERRIDE */
 145         { 0x21, 0x87 }, /* OVERRIDE */
 146         { 0x22, 0x1f }, /* OVERRIDE */
 147         { 0x80, 0x01 }, /* freq dependent */
 148         { 0x0f, 0x01 }, /* start tune */
 149         { 0, 0 }
 150 };
 151
 152 /* ------------------------------------------------------------------------- */
 153
 154 struct mxl5007t_state {
 155         struct list_head hybrid_tuner_instance_list;
 156         struct tuner_i2c_props i2c_props;
 157
 158         struct mutex lock;
 159
 160         struct mxl5007t_config *config;
 161
 162         enum mxl5007t_chip_version chip_id;
 163
 164         struct reg_pair_t tab_init[ARRAY_SIZE(init_tab)];
 165         struct reg_pair_t tab_init_cable[ARRAY_SIZE(init_tab_cable)];
 166         struct reg_pair_t tab_rftune[ARRAY_SIZE(reg_pair_rftune)];
 167
 168         u32 frequency;
 169         u32 bandwidth;
 170 };
 171
 172 /* ------------------------------------------------------------------------- */
 173
 174 /* called by _init and _rftun to manipulate the register arrays */
 175
 176 static void set_reg_bits(struct reg_pair_t *reg_pair, u8 reg, u8 mask, u8 val)
 177 {
 178         unsigned int i = 0;
 179
 180         while (reg_pair[i].reg || reg_pair[i].val) {
 181                 if (reg_pair[i].reg == reg) {
 182                         reg_pair[i].val &= ~mask;
 183                         reg_pair[i].val |= val;
 184                 }
 185                 i++;
 186
 187         }
 188         return;
 189 }
 190
 191 static void copy_reg_bits(struct reg_pair_t *reg_pair1,
 192                           struct reg_pair_t *reg_pair2)
 193 {
 194         unsigned int i, j;
 195
 196         i = j = 0;
 197
 198         while (reg_pair1[i].reg || reg_pair1[i].val) {
 199                 while (reg_pair2[j].reg || reg_pair2[j].val) {
 200                         if (reg_pair1[i].reg != reg_pair2[j].reg) {
 201                                 j++;
 202                                 continue;
 203                         }
 204                         reg_pair2[j].val = reg_pair1[i].val;
 205                         break;
 206                 }
 207                 i++;
 208         }
 209         return;
 210 }
 211
 212 /* ------------------------------------------------------------------------- */
 213
 214 static void mxl5007t_set_mode_bits(struct mxl5007t_state *state,
 215                                    enum mxl5007t_mode mode,
 216                                    s32 if_diff_out_level)
 217 {
 218         switch (mode) {
 219         case MxL_MODE_ATSC:
 220                 set_reg_bits(state->tab_init, 0x06, 0x1f, 0x12);
 221                 break;
 222         case MxL_MODE_DVBT:
 223                 set_reg_bits(state->tab_init, 0x06, 0x1f, 0x11);
 224                 break;
 225         case MxL_MODE_ISDBT:
 226                 set_reg_bits(state->tab_init, 0x06, 0x1f, 0x10);
 227                 break;
 228         case MxL_MODE_CABLE:
 229                 set_reg_bits(state->tab_init_cable, 0x09, 0xff, 0xc1);
 230                 set_reg_bits(state->tab_init_cable, 0x0a, 0xff,
 231                              8 - if_diff_out_level);
 232                 set_reg_bits(state->tab_init_cable, 0x0b, 0xff, 0x17);
 233                 break;
 234         default:
 235                 mxl_fail(-EINVAL);
 236         }
 237         return;
 238 }
 239
 240 static void mxl5007t_set_if_freq_bits(struct mxl5007t_state *state,
 241                                       enum mxl5007t_if_freq if_freq,
 242                                       int invert_if)
 243 {
 244         u8 val;
 245
 246         switch (if_freq) {
 247         case MxL_IF_4_MHZ:
 248                 val = 0x00;
 249                 break;
 250         case MxL_IF_4_5_MHZ:
 251                 val = 0x02;
 252                 break;
 253         case MxL_IF_4_57_MHZ:
 254                 val = 0x03;
 255                 break;
 256         case MxL_IF_5_MHZ:
 257                 val = 0x04;
 258                 break;
 259         case MxL_IF_5_38_MHZ:
 260                 val = 0x05;
 261                 break;
 262         case MxL_IF_6_MHZ:
 263                 val = 0x06;
 264                 break;
 265         case MxL_IF_6_28_MHZ:
 266                 val = 0x07;
 267                 break;
 268         case MxL_IF_9_1915_MHZ:
 269                 val = 0x08;
 270                 break;
 271         case MxL_IF_35_25_MHZ:
 272                 val = 0x09;
 273                 break;
 274         case MxL_IF_36_15_MHZ:
 275                 val = 0x0a;
 276                 break;
 277         case MxL_IF_44_MHZ:
 278                 val = 0x0b;
 279                 break;
 280         default:
 281                 mxl_fail(-EINVAL);
 282                 return;
 283         }
 284         set_reg_bits(state->tab_init, 0x02, 0x0f, val);
 285
 286         /* set inverted IF or normal IF */
 287         set_reg_bits(state->tab_init, 0x02, 0x10, invert_if ? 0x10 : 0x00);
 288
 289         return;
 290 }
 291
 292 static void mxl5007t_set_xtal_freq_bits(struct mxl5007t_state *state,
 293                                         enum mxl5007t_xtal_freq xtal_freq)
 294 {
 295         switch (xtal_freq) {
 296         case MxL_XTAL_16_MHZ:
 297                 /* select xtal freq & ref freq */
 298                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x00);
 299                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x00);
 300                 break;
 301         case MxL_XTAL_20_MHZ:
 302                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x10);
 303                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x01);
 304                 break;
 305         case MxL_XTAL_20_25_MHZ:
 306                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x20);
 307                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x02);
 308                 break;
 309         case MxL_XTAL_20_48_MHZ:
 310                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x30);
 311                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x03);
 312                 break;
 313         case MxL_XTAL_24_MHZ:
 314                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x40);
 315                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x04);
 316                 break;
 317         case MxL_XTAL_25_MHZ:
 318                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x50);
 319                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x05);
 320                 break;
 321         case MxL_XTAL_25_14_MHZ:
 322                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x60);
 323                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x06);
 324                 break;
 325         case MxL_XTAL_27_MHZ:
 326                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x70);
 327                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x07);
 328                 break;
 329         case MxL_XTAL_28_8_MHZ:
 330                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x80);
 331                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x08);
 332                 break;
 333         case MxL_XTAL_32_MHZ:
 334                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0x90);
 335                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x09);
 336                 break;
 337         case MxL_XTAL_40_MHZ:
 338                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0xa0);
 339                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x0a);
 340                 break;
 341         case MxL_XTAL_44_MHZ:
 342                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0xb0);
 343                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x0b);
 344                 break;
 345         case MxL_XTAL_48_MHZ:
 346                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0xc0);
 347                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x0c);
 348                 break;
 349         case MxL_XTAL_49_3811_MHZ:
 350                 set_reg_bits(state->tab_init, 0x03, 0xf0, 0xd0);
 351                 set_reg_bits(state->tab_init, 0x05, 0x0f, 0x0d);
 352                 break;
 353         default:
 354                 mxl_fail(-EINVAL);
 355                 return;
 356         }
 357
 358         return;
 359 }
 360
 361 static struct reg_pair_t *mxl5007t_calc_init_regs(struct mxl5007t_state *state,
 362                                                   enum mxl5007t_mode mode)
 363 {
 364         struct mxl5007t_config *cfg = state->config;
 365
 366         memcpy(&state->tab_init, &init_tab, sizeof(init_tab));
 367         memcpy(&state->tab_init_cable, &init_tab_cable, sizeof(init_tab_cable));
 368
 369         mxl5007t_set_mode_bits(state, mode, cfg->if_diff_out_level);
 370         mxl5007t_set_if_freq_bits(state, cfg->if_freq_hz, cfg->invert_if);
 371         mxl5007t_set_xtal_freq_bits(state, cfg->xtal_freq_hz);
 372
 373         set_reg_bits(state->tab_init, 0x04, 0x01, cfg->loop_thru_enable);
 374         set_reg_bits(state->tab_init, 0x03, 0x08, cfg->clk_out_enable << 3);
 375         set_reg_bits(state->tab_init, 0x03, 0x07, cfg->clk_out_amp);
 376
 377         if (mode >= MxL_MODE_CABLE) {
 378                 copy_reg_bits(state->tab_init, state->tab_init_cable);
 379                 return state->tab_init_cable;
 380         } else
 381                 return state->tab_init;
 382 }
 383
 384 /* ------------------------------------------------------------------------- */
 385
 386 enum mxl5007t_bw_mhz {
 387         MxL_BW_6MHz = 6,
 388         MxL_BW_7MHz = 7,
 389         MxL_BW_8MHz = 8,
 390 };
 391
 392 static void mxl5007t_set_bw_bits(struct mxl5007t_state *state,
 393                                  enum mxl5007t_bw_mhz bw)
 394 {
 395         u8 val;
 396
 397         switch (bw) {
 398         case MxL_BW_6MHz:
 399                 val = 0x15; /* set DIG_MODEINDEX, DIG_MODEINDEX_A,
 400                              * and DIG_MODEINDEX_CSF */
 401                 break;
 402         case MxL_BW_7MHz:
 403                 val = 0x2a;
 404                 break;
 405         case MxL_BW_8MHz:
 406                 val = 0x3f;
 407                 break;
 408         default:
 409                 mxl_fail(-EINVAL);
 410                 return;
 411         }
 412         set_reg_bits(state->tab_rftune, 0x0c, 0x3f, val);
 413
 414         return;
 415 }
 416
 417 static struct
 418 reg_pair_t *mxl5007t_calc_rf_tune_regs(struct mxl5007t_state *state,
 419                                        u32 rf_freq, enum mxl5007t_bw_mhz bw)
 420 {
 421         u32 dig_rf_freq = 0;
 422         u32 temp;
 423         u32 frac_divider = 1000000;
 424         unsigned int i;
 425
 426         memcpy(&state->tab_rftune, &reg_pair_rftune, sizeof(reg_pair_rftune));
 427
 428         mxl5007t_set_bw_bits(state, bw);
 429
 430         /* Convert RF frequency into 16 bits =>
 431          * 10 bit integer (MHz) + 6 bit fraction */
 432         dig_rf_freq = rf_freq / MHz;
 433
 434         temp = rf_freq % MHz;
 435
 436         for (i = 0; i < 6; i++) {
 437                 dig_rf_freq <<= 1;
 438                 frac_divider /= 2;
 439                 if (temp > frac_divider) {
 440                         temp -= frac_divider;
 441                         dig_rf_freq++;
 442                 }
 443         }
 444
 445         /* add to have shift center point by 7.8124 kHz */
 446         if (temp > 7812)
 447                 dig_rf_freq++;
 448
 449         set_reg_bits(state->tab_rftune, 0x0d, 0xff, (u8) dig_rf_freq);
 450         set_reg_bits(state->tab_rftune, 0x0e, 0xff, (u8) (dig_rf_freq >> 8));
 451
 452         if (rf_freq >= 333000000)
 453                 set_reg_bits(state->tab_rftune, 0x80, 0x40, 0x40);
 454
 455         return state->tab_rftune;
 456 }
 457
 458 /* ------------------------------------------------------------------------- */
 459
 460 static int mxl5007t_write_reg(struct mxl5007t_state *state, u8 reg, u8 val)
 461 {
 462         u8 buf[] = { reg, val };
 463         struct i2c_msg msg = { .addr = state->i2c_props.addr, .flags = 0,
 464                                .buf = buf, .len = 2 };
 465         int ret;
 466
 467         ret = i2c_transfer(state->i2c_props.adap, &msg, 1);
 468         if (ret != 1) {
 469                 mxl_err("failed!");
 470                 return -EREMOTEIO;
 471         }
 472         return 0;
 473 }
 474
 475 static int mxl5007t_write_regs(struct mxl5007t_state *state,
 476                                struct reg_pair_t *reg_pair)
 477 {
 478         unsigned int i = 0;
 479         int ret = 0;
 480
 481         while ((ret == 0) && (reg_pair[i].reg || reg_pair[i].val)) {
 482                 ret = mxl5007t_write_reg(state,
 483                                          reg_pair[i].reg, reg_pair[i].val);
 484                 i++;
 485         }
 486         return ret;
 487 }
 488
 489 static int mxl5007t_read_reg(struct mxl5007t_state *state, u8 reg, u8 *val)
 490 {
 491         u8 buf[2] = { 0xfb, reg };
 492         struct i2c_msg msg[] = {
 493                 { .addr = state->i2c_props.addr, .flags = 0,
 494                   .buf = buf, .len = 2 },
 495                 { .addr = state->i2c_props.addr, .flags = I2C_M_RD,
 496                   .buf = val, .len = 1 },
 497         };
 498         int ret;
 499
 500         ret = i2c_transfer(state->i2c_props.adap, msg, 2);
 501         if (ret != 2) {
 502                 mxl_err("failed!");
 503                 return -EREMOTEIO;
 504         }
 505         return 0;
 506 }
 507
 508 static int mxl5007t_soft_reset(struct mxl5007t_state *state)
 509 {
 510         u8 d = 0xff;
 511         struct i2c_msg msg = {
 512                 .addr = state->i2c_props.addr, .flags = 0,
 513                 .buf = &d, .len = 1
 514         };
 515         int ret = i2c_transfer(state->i2c_props.adap, &msg, 1);
 516
 517         if (ret != 1) {
 518                 mxl_err("failed!");
 519                 return -EREMOTEIO;
 520         }
 521         return 0;
 522 }
 523
 524 static int mxl5007t_tuner_init(struct mxl5007t_state *state,
 525                                enum mxl5007t_mode mode)
 526 {
 527         struct reg_pair_t *init_regs;
 528         int ret;
 529
 530         ret = mxl5007t_soft_reset(state);
 531         if (mxl_fail(ret))
 532                 goto fail;
 533
 534         /* calculate initialization reg array */
 535         init_regs = mxl5007t_calc_init_regs(state, mode);
 536
 537         ret = mxl5007t_write_regs(state, init_regs);
 538         if (mxl_fail(ret))
 539                 goto fail;
 540         mdelay(1);
 541 fail:
 542         return ret;
 543 }
 544
 545 static int mxl5007t_tuner_rf_tune(struct mxl5007t_state *state, u32 rf_freq_hz,
 546                                   enum mxl5007t_bw_mhz bw)
 547 {
 548         struct reg_pair_t *rf_tune_regs;
 549         int ret;
 550
 551         /* calculate channel change reg array */
 552         rf_tune_regs = mxl5007t_calc_rf_tune_regs(state, rf_freq_hz, bw);
 553
 554         ret = mxl5007t_write_regs(state, rf_tune_regs);
 555         if (mxl_fail(ret))
 556                 goto fail;
 557         msleep(3);
 558 fail:
 559         return ret;
 560 }
 561
 562 /* ------------------------------------------------------------------------- */
 563
 564 static int mxl5007t_synth_lock_status(struct mxl5007t_state *state,
 565                                       int *rf_locked, int *ref_locked)
 566 {
 567         u8 d;
 568         int ret;
 569
 570         *rf_locked = 0;
 571         *ref_locked = 0;
 572
 573         ret = mxl5007t_read_reg(state, 0xd8, &d);
 574         if (mxl_fail(ret))
 575                 goto fail;
 576
 577         if ((d & 0x0c) == 0x0c)
 578                 *rf_locked = 1;
 579
 580         if ((d & 0x03) == 0x03)
 581                 *ref_locked = 1;
 582 fail:
 583         return ret;
 584 }
 585
 586 /* ------------------------------------------------------------------------- */
 587
 588 static int mxl5007t_get_status(struct dvb_frontend *fe, u32 *status)
 589 {
 590         struct mxl5007t_state *state = fe->tuner_priv;
 591         int rf_locked, ref_locked, ret;
 592
 593         *status = 0;
 594
 595         if (fe->ops.i2c_gate_ctrl)
 596                 fe->ops.i2c_gate_ctrl(fe, 1);
 597
 598         ret = mxl5007t_synth_lock_status(state, &rf_locked, &ref_locked);
 599         if (mxl_fail(ret))
 600                 goto fail;
 601         mxl_debug("%s%s", rf_locked ? "rf locked " : "",
 602                   ref_locked ? "ref locked" : "");
 603
 604         if ((rf_locked) || (ref_locked))
 605                 *status |= TUNER_STATUS_LOCKED;
 606 fail:
 607         if (fe->ops.i2c_gate_ctrl)
 608                 fe->ops.i2c_gate_ctrl(fe, 0);
 609
 610         return ret;
 611 }
 612
 613 /* ------------------------------------------------------------------------- */
 614
 615 static int mxl5007t_set_params(struct dvb_frontend *fe,
 616                                struct dvb_frontend_parameters *params)
 617 {
 618         struct mxl5007t_state *state = fe->tuner_priv;
 619         enum mxl5007t_bw_mhz bw;
 620         enum mxl5007t_mode mode;
 621         int ret;
 622         u32 freq = params->frequency;
 623
 624         if (fe->ops.info.type == FE_ATSC) {
 625                 switch (params->u.vsb.modulation) {
 626                 case VSB_8:
 627                 case VSB_16:
 628                         mode = MxL_MODE_ATSC;
 629                         break;
 630                 case QAM_64:
 631                 case QAM_256:
 632                         mode = MxL_MODE_CABLE;
 633                         break;
 634                 default:
 635                         mxl_err("modulation not set!");
 636                         return -EINVAL;
 637                 }
 638                 bw = MxL_BW_6MHz;
 639         } else if (fe->ops.info.type == FE_OFDM) {
 640                 switch (params->u.ofdm.bandwidth) {
 641                 case BANDWIDTH_6_MHZ:
 642                         bw = MxL_BW_6MHz;
 643                         break;
 644                 case BANDWIDTH_7_MHZ:
 645                         bw = MxL_BW_7MHz;
 646                         break;
 647                 case BANDWIDTH_8_MHZ:
 648                         bw = MxL_BW_8MHz;
 649                         break;
 650                 default:
 651                         mxl_err("bandwidth not set!");
 652                         return -EINVAL;
 653                 }
 654                 mode = MxL_MODE_DVBT;
 655         } else {
 656                 mxl_err("modulation type not supported!");
 657                 return -EINVAL;
 658         }
 659
 660         if (fe->ops.i2c_gate_ctrl)
 661                 fe->ops.i2c_gate_ctrl(fe, 1);
 662
 663         mutex_lock(&state->lock);
 664
 665         ret = mxl5007t_tuner_init(state, mode);
 666         if (mxl_fail(ret))
 667                 goto fail;
 668
 669         ret = mxl5007t_tuner_rf_tune(state, freq, bw);
 670         if (mxl_fail(ret))
 671                 goto fail;
 672
 673         state->frequency = freq;
 674         state->bandwidth = (fe->ops.info.type == FE_OFDM) ?
 675                 params->u.ofdm.bandwidth : 0;
 676 fail:
 677         mutex_unlock(&state->lock);
 678
 679         if (fe->ops.i2c_gate_ctrl)
 680                 fe->ops.i2c_gate_ctrl(fe, 0);
 681
 682         return ret;
 683 }
 684
 685 /* ------------------------------------------------------------------------- */
 686
 687 static int mxl5007t_init(struct dvb_frontend *fe)
 688 {
 689         struct mxl5007t_state *state = fe->tuner_priv;
 690         int ret;
 691
 692         if (fe->ops.i2c_gate_ctrl)
 693                 fe->ops.i2c_gate_ctrl(fe, 1);
 694
 695         /* wake from standby */
 696         ret = mxl5007t_write_reg(state, 0x01, 0x01);
 697         mxl_fail(ret);
 698
 699         if (fe->ops.i2c_gate_ctrl)
 700                 fe->ops.i2c_gate_ctrl(fe, 0);
 701
 702         return ret;
 703 }
 704
 705 static int mxl5007t_sleep(struct dvb_frontend *fe)
 706 {
 707         struct mxl5007t_state *state = fe->tuner_priv;
 708         int ret;
 709
 710         if (fe->ops.i2c_gate_ctrl)
 711                 fe->ops.i2c_gate_ctrl(fe, 1);
 712
 713         /* enter standby mode */
 714         ret = mxl5007t_write_reg(state, 0x01, 0x00);
 715         mxl_fail(ret);
 716         ret = mxl5007t_write_reg(state, 0x0f, 0x00);
 717         mxl_fail(ret);
 718
 719         if (fe->ops.i2c_gate_ctrl)
 720                 fe->ops.i2c_gate_ctrl(fe, 0);
 721
 722         return ret;
 723 }
 724
 725 /* ------------------------------------------------------------------------- */
 726
 727 static int mxl5007t_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 728 {
 729         struct mxl5007t_state *state = fe->tuner_priv;
 730         *frequency = state->frequency;
 731         return 0;
 732 }
 733
 734 static int mxl5007t_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 735 {
 736         struct mxl5007t_state *state = fe->tuner_priv;
 737         *bandwidth = state->bandwidth;
 738         return 0;
 739 }
 740
 741 static int mxl5007t_release(struct dvb_frontend *fe)
 742 {
 743         struct mxl5007t_state *state = fe->tuner_priv;
 744
 745         mutex_lock(&mxl5007t_list_mutex);
 746
 747         if (state)
 748                 hybrid_tuner_release_state(state);
 749
 750         mutex_unlock(&mxl5007t_list_mutex);
 751
 752         fe->tuner_priv = NULL;
 753
 754         return 0;
 755 }
 756
 757 /* ------------------------------------------------------------------------- */
 758
 759 static struct dvb_tuner_ops mxl5007t_tuner_ops = {
 760         .info = {
 761                 .name = "MaxLinear MxL5007T",
 762         },
 763         .init              = mxl5007t_init,
 764         .sleep             = mxl5007t_sleep,
 765         .set_params        = mxl5007t_set_params,
 766         .get_status        = mxl5007t_get_status,
 767         .get_frequency     = mxl5007t_get_frequency,
 768         .get_bandwidth     = mxl5007t_get_bandwidth,
 769         .release           = mxl5007t_release,
 770 };
 771
 772 static int mxl5007t_get_chip_id(struct mxl5007t_state *state)
 773 {
 774         char *name;
 775         int ret;
 776         u8 id;
 777
 778         ret = mxl5007t_read_reg(state, 0xd9, &id);
 779         if (mxl_fail(ret))
 780                 goto fail;
 781
 782         switch (id) {
 783         case MxL_5007_V1_F1:
 784                 name = "MxL5007.v1.f1";
 785                 break;
 786         case MxL_5007_V1_F2:
 787                 name = "MxL5007.v1.f2";
 788                 break;
 789         case MxL_5007_V2_100_F1:
 790                 name = "MxL5007.v2.100.f1";
 791                 break;
 792         case MxL_5007_V2_100_F2:
 793                 name = "MxL5007.v2.100.f2";
 794                 break;
 795         case MxL_5007_V2_200_F1:
 796                 name = "MxL5007.v2.200.f1";
 797                 break;
 798         case MxL_5007_V2_200_F2:
 799                 name = "MxL5007.v2.200.f2";
 800                 break;
 801         case MxL_5007_V4:
 802                 name = "MxL5007T.v4";
 803                 break;
 804         default:
 805                 name = "MxL5007T";
 806                 printk(KERN_WARNING "%s: unknown rev (%02x)\n", __func__, id);
 807                 id = MxL_UNKNOWN_ID;
 808         }
 809         state->chip_id = id;
 810         mxl_info("%s detected @ %d-%04x", name,
 811                  i2c_adapter_id(state->i2c_props.adap),
 812                  state->i2c_props.addr);
 813         return 0;
 814 fail:
 815         mxl_warn("unable to identify device @ %d-%04x",
 816                  i2c_adapter_id(state->i2c_props.adap),
 817                  state->i2c_props.addr);
 818
 819         state->chip_id = MxL_UNKNOWN_ID;
 820         return ret;
 821 }
 822
 823 struct dvb_frontend *mxl5007t_attach(struct dvb_frontend *fe,
 824                                      struct i2c_adapter *i2c, u8 addr,
 825                                      struct mxl5007t_config *cfg)
 826 {
 827         struct mxl5007t_state *state = NULL;
 828         int instance, ret;
 829
 830         mutex_lock(&mxl5007t_list_mutex);
 831         instance = hybrid_tuner_request_state(struct mxl5007t_state, state,
 832                                               hybrid_tuner_instance_list,
 833                                               i2c, addr, "mxl5007t");
 834         switch (instance) {
 835         case 0:
 836                 goto fail;
 837         case 1:
 838                 /* new tuner instance */
 839                 state->config = cfg;
 840
 841                 mutex_init(&state->lock);
 842
 843                 if (fe->ops.i2c_gate_ctrl)
 844                         fe->ops.i2c_gate_ctrl(fe, 1);
 845
 846                 ret = mxl5007t_get_chip_id(state);
 847
 848                 if (fe->ops.i2c_gate_ctrl)
 849                         fe->ops.i2c_gate_ctrl(fe, 0);
 850
 851                 /* check return value of mxl5007t_get_chip_id */
 852                 if (mxl_fail(ret))
 853                         goto fail;
 854                 break;
 855         default:
 856                 /* existing tuner instance */
 857                 break;
 858         }
 859         fe->tuner_priv = state;
 860         mutex_unlock(&mxl5007t_list_mutex);
 861
 862         memcpy(&fe->ops.tuner_ops, &mxl5007t_tuner_ops,
 863                sizeof(struct dvb_tuner_ops));
 864
 865         return fe;
 866 fail:
 867         mutex_unlock(&mxl5007t_list_mutex);
 868
 869         mxl5007t_release(fe);
 870         return NULL;
 871 }
 872 EXPORT_SYMBOL_GPL(mxl5007t_attach);
 873 MODULE_DESCRIPTION("MaxLinear MxL5007T Silicon IC tuner driver");
 874 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
 875 MODULE_LICENSE("GPL");
 876 MODULE_VERSION("0.2");
 877
 878 /*
 879  * Overrides for Emacs so that we follow Linus's tabbing style.
 880  * ---------------------------------------------------------------------------
 881  * Local variables:
 882  * c-basic-offset: 8
 883  * End:
 884  */