drivers/media/dvb/frontends/tda1004x.c

   1   /*
   2      Driver for Philips tda1004xh OFDM Demodulator
   3
   4      (c) 2003, 2004 Andrew de Quincey & Robert Schlabbach
   5
   6      This program is free software; you can redistribute it and/or modify
   7      it under the terms of the GNU General Public License as published by
   8      the Free Software Foundation; either version 2 of the License, or
   9      (at your option) any later version.
  10
  11      This program is distributed in the hope that it will be useful,
  12      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14
  15      GNU General Public License for more details.
  16
  17      You should have received a copy of the GNU General Public License
  18      along with this program; if not, write to the Free Software
  19      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21    */
  22 /*
  23  * This driver needs external firmware. Please use the commands
  24  * "<kerneldir>/Documentation/dvb/get_dvb_firmware tda10045",
  25  * "<kerneldir>/Documentation/dvb/get_dvb_firmware tda10046" to
  26  * download/extract them, and then copy them to /usr/lib/hotplug/firmware
  27  * or /lib/firmware (depending on configuration of firmware hotplug).
  28  */
  29 #define TDA10045_DEFAULT_FIRMWARE "dvb-fe-tda10045.fw"
  30 #define TDA10046_DEFAULT_FIRMWARE "dvb-fe-tda10046.fw"
  31
  32 #include <linux/init.h>
  33 #include <linux/module.h>
  34 #include <linux/device.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/string.h>
  37 #include <linux/slab.h>
  38
  39 #include "dvb_frontend.h"
  40 #include "tda1004x.h"
  41
  42 static int debug;
  43 #define dprintk(args...) \
  44         do { \
  45                 if (debug) printk(KERN_DEBUG "tda1004x: " args); \
  46         } while (0)
  47
  48 #define TDA1004X_CHIPID          0x00
  49 #define TDA1004X_AUTO            0x01
  50 #define TDA1004X_IN_CONF1        0x02
  51 #define TDA1004X_IN_CONF2        0x03
  52 #define TDA1004X_OUT_CONF1       0x04
  53 #define TDA1004X_OUT_CONF2       0x05
  54 #define TDA1004X_STATUS_CD       0x06
  55 #define TDA1004X_CONFC4          0x07
  56 #define TDA1004X_DSSPARE2        0x0C
  57 #define TDA10045H_CODE_IN        0x0D
  58 #define TDA10045H_FWPAGE         0x0E
  59 #define TDA1004X_SCAN_CPT        0x10
  60 #define TDA1004X_DSP_CMD         0x11
  61 #define TDA1004X_DSP_ARG         0x12
  62 #define TDA1004X_DSP_DATA1       0x13
  63 #define TDA1004X_DSP_DATA2       0x14
  64 #define TDA1004X_CONFADC1        0x15
  65 #define TDA1004X_CONFC1          0x16
  66 #define TDA10045H_S_AGC          0x1a
  67 #define TDA10046H_AGC_TUN_LEVEL  0x1a
  68 #define TDA1004X_SNR             0x1c
  69 #define TDA1004X_CONF_TS1        0x1e
  70 #define TDA1004X_CONF_TS2        0x1f
  71 #define TDA1004X_CBER_RESET      0x20
  72 #define TDA1004X_CBER_MSB        0x21
  73 #define TDA1004X_CBER_LSB        0x22
  74 #define TDA1004X_CVBER_LUT       0x23
  75 #define TDA1004X_VBER_MSB        0x24
  76 #define TDA1004X_VBER_MID        0x25
  77 #define TDA1004X_VBER_LSB        0x26
  78 #define TDA1004X_UNCOR           0x27
  79
  80 #define TDA10045H_CONFPLL_P      0x2D
  81 #define TDA10045H_CONFPLL_M_MSB  0x2E
  82 #define TDA10045H_CONFPLL_M_LSB  0x2F
  83 #define TDA10045H_CONFPLL_N      0x30
  84
  85 #define TDA10046H_CONFPLL1       0x2D
  86 #define TDA10046H_CONFPLL2       0x2F
  87 #define TDA10046H_CONFPLL3       0x30
  88 #define TDA10046H_TIME_WREF1     0x31
  89 #define TDA10046H_TIME_WREF2     0x32
  90 #define TDA10046H_TIME_WREF3     0x33
  91 #define TDA10046H_TIME_WREF4     0x34
  92 #define TDA10046H_TIME_WREF5     0x35
  93
  94 #define TDA10045H_UNSURW_MSB     0x31
  95 #define TDA10045H_UNSURW_LSB     0x32
  96 #define TDA10045H_WREF_MSB       0x33
  97 #define TDA10045H_WREF_MID       0x34
  98 #define TDA10045H_WREF_LSB       0x35
  99 #define TDA10045H_MUXOUT         0x36
 100 #define TDA1004X_CONFADC2        0x37
 101
 102 #define TDA10045H_IOFFSET        0x38
 103
 104 #define TDA10046H_CONF_TRISTATE1 0x3B
 105 #define TDA10046H_CONF_TRISTATE2 0x3C
 106 #define TDA10046H_CONF_POLARITY  0x3D
 107 #define TDA10046H_FREQ_OFFSET    0x3E
 108 #define TDA10046H_GPIO_OUT_SEL   0x41
 109 #define TDA10046H_GPIO_SELECT    0x42
 110 #define TDA10046H_AGC_CONF       0x43
 111 #define TDA10046H_AGC_THR        0x44
 112 #define TDA10046H_AGC_RENORM     0x45
 113 #define TDA10046H_AGC_GAINS      0x46
 114 #define TDA10046H_AGC_TUN_MIN    0x47
 115 #define TDA10046H_AGC_TUN_MAX    0x48
 116 #define TDA10046H_AGC_IF_MIN     0x49
 117 #define TDA10046H_AGC_IF_MAX     0x4A
 118
 119 #define TDA10046H_FREQ_PHY2_MSB  0x4D
 120 #define TDA10046H_FREQ_PHY2_LSB  0x4E
 121
 122 #define TDA10046H_CVBER_CTRL     0x4F
 123 #define TDA10046H_AGC_IF_LEVEL   0x52
 124 #define TDA10046H_CODE_CPT       0x57
 125 #define TDA10046H_CODE_IN        0x58
 126
 127
 128 static int tda1004x_write_byteI(struct tda1004x_state *state, int reg, int data)
 129 {
 130         int ret;
 131         u8 buf[] = { reg, data };
 132         struct i2c_msg msg = { .flags = 0, .buf = buf, .len = 2 };
 133
 134         dprintk("%s: reg=0x%x, data=0x%x\n", __func__, reg, data);
 135
 136         msg.addr = state->config->demod_address;
 137         ret = i2c_transfer(state->i2c, &msg, 1);
 138
 139         if (ret != 1)
 140                 dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
 141                         __func__, reg, data, ret);
 142
 143         dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
 144                 reg, data, ret);
 145         return (ret != 1) ? -1 : 0;
 146 }
 147
 148 static int tda1004x_read_byte(struct tda1004x_state *state, int reg)
 149 {
 150         int ret;
 151         u8 b0[] = { reg };
 152         u8 b1[] = { 0 };
 153         struct i2c_msg msg[] = {{ .flags = 0, .buf = b0, .len = 1 },
 154                                 { .flags = I2C_M_RD, .buf = b1, .len = 1 }};
 155
 156         dprintk("%s: reg=0x%x\n", __func__, reg);
 157
 158         msg[0].addr = state->config->demod_address;
 159         msg[1].addr = state->config->demod_address;
 160         ret = i2c_transfer(state->i2c, msg, 2);
 161
 162         if (ret != 2) {
 163                 dprintk("%s: error reg=0x%x, ret=%i\n", __func__, reg,
 164                         ret);
 165                 return -EINVAL;
 166         }
 167
 168         dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
 169                 reg, b1[0], ret);
 170         return b1[0];
 171 }
 172
 173 static int tda1004x_write_mask(struct tda1004x_state *state, int reg, int mask, int data)
 174 {
 175         int val;
 176         dprintk("%s: reg=0x%x, mask=0x%x, data=0x%x\n", __func__, reg,
 177                 mask, data);
 178
 179         // read a byte and check
 180         val = tda1004x_read_byte(state, reg);
 181         if (val < 0)
 182                 return val;
 183
 184         // mask if off
 185         val = val & ~mask;
 186         val |= data & 0xff;
 187
 188         // write it out again
 189         return tda1004x_write_byteI(state, reg, val);
 190 }
 191
 192 static int tda1004x_write_buf(struct tda1004x_state *state, int reg, unsigned char *buf, int len)
 193 {
 194         int i;
 195         int result;
 196
 197         dprintk("%s: reg=0x%x, len=0x%x\n", __func__, reg, len);
 198
 199         result = 0;
 200         for (i = 0; i < len; i++) {
 201                 result = tda1004x_write_byteI(state, reg + i, buf[i]);
 202                 if (result != 0)
 203                         break;
 204         }
 205
 206         return result;
 207 }
 208
 209 static int tda1004x_enable_tuner_i2c(struct tda1004x_state *state)
 210 {
 211         int result;
 212         dprintk("%s\n", __func__);
 213
 214         result = tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 2);
 215         msleep(20);
 216         return result;
 217 }
 218
 219 static int tda1004x_disable_tuner_i2c(struct tda1004x_state *state)
 220 {
 221         dprintk("%s\n", __func__);
 222
 223         return tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 0);
 224 }
 225
 226 static int tda10045h_set_bandwidth(struct tda1004x_state *state,
 227                                    fe_bandwidth_t bandwidth)
 228 {
 229         static u8 bandwidth_6mhz[] = { 0x02, 0x00, 0x3d, 0x00, 0x60, 0x1e, 0xa7, 0x45, 0x4f };
 230         static u8 bandwidth_7mhz[] = { 0x02, 0x00, 0x37, 0x00, 0x4a, 0x2f, 0x6d, 0x76, 0xdb };
 231         static u8 bandwidth_8mhz[] = { 0x02, 0x00, 0x3d, 0x00, 0x48, 0x17, 0x89, 0xc7, 0x14 };
 232
 233         switch (bandwidth) {
 234         case BANDWIDTH_6_MHZ:
 235                 tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_6mhz, sizeof(bandwidth_6mhz));
 236                 break;
 237
 238         case BANDWIDTH_7_MHZ:
 239                 tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_7mhz, sizeof(bandwidth_7mhz));
 240                 break;
 241
 242         case BANDWIDTH_8_MHZ:
 243                 tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_8mhz, sizeof(bandwidth_8mhz));
 244                 break;
 245
 246         default:
 247                 return -EINVAL;
 248         }
 249
 250         tda1004x_write_byteI(state, TDA10045H_IOFFSET, 0);
 251
 252         return 0;
 253 }
 254
 255 static int tda10046h_set_bandwidth(struct tda1004x_state *state,
 256                                    fe_bandwidth_t bandwidth)
 257 {
 258         static u8 bandwidth_6mhz_53M[] = { 0x7b, 0x2e, 0x11, 0xf0, 0xd2 };
 259         static u8 bandwidth_7mhz_53M[] = { 0x6a, 0x02, 0x6a, 0x43, 0x9f };
 260         static u8 bandwidth_8mhz_53M[] = { 0x5c, 0x32, 0xc2, 0x96, 0x6d };
 261
 262         static u8 bandwidth_6mhz_48M[] = { 0x70, 0x02, 0x49, 0x24, 0x92 };
 263         static u8 bandwidth_7mhz_48M[] = { 0x60, 0x02, 0xaa, 0xaa, 0xab };
 264         static u8 bandwidth_8mhz_48M[] = { 0x54, 0x03, 0x0c, 0x30, 0xc3 };
 265         int tda10046_clk53m;
 266
 267         if ((state->config->if_freq == TDA10046_FREQ_045) ||
 268             (state->config->if_freq == TDA10046_FREQ_052))
 269                 tda10046_clk53m = 0;
 270         else
 271                 tda10046_clk53m = 1;
 272         switch (bandwidth) {
 273         case BANDWIDTH_6_MHZ:
 274                 if (tda10046_clk53m)
 275                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_6mhz_53M,
 276                                                   sizeof(bandwidth_6mhz_53M));
 277                 else
 278                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_6mhz_48M,
 279                                                   sizeof(bandwidth_6mhz_48M));
 280                 if (state->config->if_freq == TDA10046_FREQ_045) {
 281                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0a);
 282                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0xab);
 283                 }
 284                 break;
 285
 286         case BANDWIDTH_7_MHZ:
 287                 if (tda10046_clk53m)
 288                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_7mhz_53M,
 289                                                   sizeof(bandwidth_7mhz_53M));
 290                 else
 291                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_7mhz_48M,
 292                                                   sizeof(bandwidth_7mhz_48M));
 293                 if (state->config->if_freq == TDA10046_FREQ_045) {
 294                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0c);
 295                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x00);
 296                 }
 297                 break;
 298
 299         case BANDWIDTH_8_MHZ:
 300                 if (tda10046_clk53m)
 301                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_8mhz_53M,
 302                                                   sizeof(bandwidth_8mhz_53M));
 303                 else
 304                         tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_8mhz_48M,
 305                                                   sizeof(bandwidth_8mhz_48M));
 306                 if (state->config->if_freq == TDA10046_FREQ_045) {
 307                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0d);
 308                         tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x55);
 309                 }
 310                 break;
 311
 312         default:
 313                 return -EINVAL;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int tda1004x_do_upload(struct tda1004x_state *state,
 320                               const unsigned char *mem, unsigned int len,
 321                               u8 dspCodeCounterReg, u8 dspCodeInReg)
 322 {
 323         u8 buf[65];
 324         struct i2c_msg fw_msg = { .flags = 0, .buf = buf, .len = 0 };
 325         int tx_size;
 326         int pos = 0;
 327
 328         /* clear code counter */
 329         tda1004x_write_byteI(state, dspCodeCounterReg, 0);
 330         fw_msg.addr = state->config->demod_address;
 331
 332         buf[0] = dspCodeInReg;
 333         while (pos != len) {
 334                 // work out how much to send this time
 335                 tx_size = len - pos;
 336                 if (tx_size > 0x10)
 337                         tx_size = 0x10;
 338
 339                 // send the chunk
 340                 memcpy(buf + 1, mem + pos, tx_size);
 341                 fw_msg.len = tx_size + 1;
 342                 if (i2c_transfer(state->i2c, &fw_msg, 1) != 1) {
 343                         printk(KERN_ERR "tda1004x: Error during firmware upload\n");
 344                         return -EIO;
 345                 }
 346                 pos += tx_size;
 347
 348                 dprintk("%s: fw_pos=0x%x\n", __func__, pos);
 349         }
 350         // give the DSP a chance to settle 03/10/05 Hac
 351         msleep(100);
 352
 353         return 0;
 354 }
 355
 356 static int tda1004x_check_upload_ok(struct tda1004x_state *state)
 357 {
 358         u8 data1, data2;
 359         unsigned long timeout;
 360
 361         if (state->demod_type == TDA1004X_DEMOD_TDA10046) {
 362                 timeout = jiffies + 2 * HZ;
 363                 while(!(tda1004x_read_byte(state, TDA1004X_STATUS_CD) & 0x20)) {
 364                         if (time_after(jiffies, timeout)) {
 365                                 printk(KERN_ERR "tda1004x: timeout waiting for DSP ready\n");
 366                                 break;
 367                         }
 368                         msleep(1);
 369                 }
 370         } else
 371                 msleep(100);
 372
 373         // check upload was OK
 374         tda1004x_write_mask(state, TDA1004X_CONFC4, 0x10, 0); // we want to read from the DSP
 375         tda1004x_write_byteI(state, TDA1004X_DSP_CMD, 0x67);
 376
 377         data1 = tda1004x_read_byte(state, TDA1004X_DSP_DATA1);
 378         data2 = tda1004x_read_byte(state, TDA1004X_DSP_DATA2);
 379         if (data1 != 0x67 || data2 < 0x20 || data2 > 0x2e) {
 380                 printk(KERN_INFO "tda1004x: found firmware revision %x -- invalid\n", data2);
 381                 return -EIO;
 382         }
 383         printk(KERN_INFO "tda1004x: found firmware revision %x -- ok\n", data2);
 384         return 0;
 385 }
 386
 387 static int tda10045_fwupload(struct dvb_frontend* fe)
 388 {
 389         struct tda1004x_state* state = fe->demodulator_priv;
 390         int ret;
 391         const struct firmware *fw;
 392
 393         /* don't re-upload unless necessary */
 394         if (tda1004x_check_upload_ok(state) == 0)
 395                 return 0;
 396
 397         /* request the firmware, this will block until someone uploads it */
 398         printk(KERN_INFO "tda1004x: waiting for firmware upload (%s)...\n", TDA10045_DEFAULT_FIRMWARE);
 399         ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
 400         if (ret) {
 401                 printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
 402                 return ret;
 403         }
 404
 405         /* reset chip */
 406         tda1004x_write_mask(state, TDA1004X_CONFC4, 0x10, 0);
 407         tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8);
 408         tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 0);
 409         msleep(10);
 410
 411         /* set parameters */
 412         tda10045h_set_bandwidth(state, BANDWIDTH_8_MHZ);
 413
 414         ret = tda1004x_do_upload(state, fw->data, fw->size, TDA10045H_FWPAGE, TDA10045H_CODE_IN);
 415         release_firmware(fw);
 416         if (ret)
 417                 return ret;
 418         printk(KERN_INFO "tda1004x: firmware upload complete\n");
 419
 420         /* wait for DSP to initialise */
 421         /* DSPREADY doesn't seem to work on the TDA10045H */
 422         msleep(100);
 423
 424         return tda1004x_check_upload_ok(state);
 425 }
 426
 427 static void tda10046_init_plls(struct dvb_frontend* fe)
 428 {
 429         struct tda1004x_state* state = fe->demodulator_priv;
 430         int tda10046_clk53m;
 431
 432         if ((state->config->if_freq == TDA10046_FREQ_045) ||
 433             (state->config->if_freq == TDA10046_FREQ_052))
 434                 tda10046_clk53m = 0;
 435         else
 436                 tda10046_clk53m = 1;
 437
 438         tda1004x_write_byteI(state, TDA10046H_CONFPLL1, 0xf0);
 439         if(tda10046_clk53m) {
 440                 printk(KERN_INFO "tda1004x: setting up plls for 53MHz sampling clock\n");
 441                 tda1004x_write_byteI(state, TDA10046H_CONFPLL2, 0x08); // PLL M = 8
 442         } else {
 443                 printk(KERN_INFO "tda1004x: setting up plls for 48MHz sampling clock\n");
 444                 tda1004x_write_byteI(state, TDA10046H_CONFPLL2, 0x03); // PLL M = 3
 445         }
 446         if (state->config->xtal_freq == TDA10046_XTAL_4M ) {
 447                 dprintk("%s: setting up PLLs for a 4 MHz Xtal\n", __func__);
 448                 tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 0); // PLL P = N = 0
 449         } else {
 450                 dprintk("%s: setting up PLLs for a 16 MHz Xtal\n", __func__);
 451                 tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 3); // PLL P = 0, N = 3
 452         }
 453         if(tda10046_clk53m)
 454                 tda1004x_write_byteI(state, TDA10046H_FREQ_OFFSET, 0x67);
 455         else
 456                 tda1004x_write_byteI(state, TDA10046H_FREQ_OFFSET, 0x72);
 457         /* Note clock frequency is handled implicitly */
 458         switch (state->config->if_freq) {
 459         case TDA10046_FREQ_045:
 460                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0c);
 461                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x00);
 462                 break;
 463         case TDA10046_FREQ_052:
 464                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0d);
 465                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0xc7);
 466                 break;
 467         case TDA10046_FREQ_3617:
 468                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0xd7);
 469                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x59);
 470                 break;
 471         case TDA10046_FREQ_3613:
 472                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0xd7);
 473                 tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x3f);
 474                 break;
 475         }
 476         tda10046h_set_bandwidth(state, BANDWIDTH_8_MHZ); // default bandwidth 8 MHz
 477         /* let the PLLs settle */
 478         msleep(120);
 479 }
 480
 481 static int tda10046_fwupload(struct dvb_frontend* fe)
 482 {
 483         struct tda1004x_state* state = fe->demodulator_priv;
 484         int ret, confc4;
 485         const struct firmware *fw;
 486
 487         /* reset + wake up chip */
 488         if (state->config->xtal_freq == TDA10046_XTAL_4M) {
 489                 confc4 = 0;
 490         } else {
 491                 dprintk("%s: 16MHz Xtal, reducing I2C speed\n", __func__);
 492                 confc4 = 0x80;
 493         }
 494         tda1004x_write_byteI(state, TDA1004X_CONFC4, confc4);
 495
 496         tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 1, 0);
 497         /* set GPIO 1 and 3 */
 498         if (state->config->gpio_config != TDA10046_GPTRI) {
 499                 tda1004x_write_byteI(state, TDA10046H_CONF_TRISTATE2, 0x33);
 500                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x0f, state->config->gpio_config &0x0f);
 501         }
 502         /* let the clocks recover from sleep */
 503         msleep(10);
 504
 505         /* The PLLs need to be reprogrammed after sleep */
 506         tda10046_init_plls(fe);
 507         tda1004x_write_mask(state, TDA1004X_CONFADC2, 0xc0, 0);
 508
 509         /* don't re-upload unless necessary */
 510         if (tda1004x_check_upload_ok(state) == 0)
 511                 return 0;
 512
 513         /*
 514            For i2c normal work, we need to slow down the bus speed.
 515            However, the slow down breaks the eeprom firmware load.
 516            So, use normal speed for eeprom booting and then restore the
 517            i2c speed after that. Tested with MSI TV @nyware A/D board,
 518            that comes with firmware version 29 inside their eeprom.
 519
 520            It should also be noticed that no other I2C transfer should
 521            be in course while booting from eeprom, otherwise, tda10046
 522            goes into an instable state. So, proper locking are needed
 523            at the i2c bus master.
 524          */
 525         printk(KERN_INFO "tda1004x: trying to boot from eeprom\n");
 526         tda1004x_write_byteI(state, TDA1004X_CONFC4, 4);
 527         msleep(300);
 528         tda1004x_write_byteI(state, TDA1004X_CONFC4, confc4);
 529
 530         /* Checks if eeprom firmware went without troubles */
 531         if (tda1004x_check_upload_ok(state) == 0)
 532                 return 0;
 533
 534         /* eeprom firmware didn't work. Load one manually. */
 535
 536         if (state->config->request_firmware != NULL) {
 537                 /* request the firmware, this will block until someone uploads it */
 538                 printk(KERN_INFO "tda1004x: waiting for firmware upload...\n");
 539                 ret = state->config->request_firmware(fe, &fw, TDA10046_DEFAULT_FIRMWARE);
 540                 if (ret) {
 541                         /* remain compatible to old bug: try to load with tda10045 image name */
 542                         ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
 543                         if (ret) {
 544                                 printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
 545                                 return ret;
 546                         } else {
 547                                 printk(KERN_INFO "tda1004x: please rename the firmware file to %s\n",
 548                                                   TDA10046_DEFAULT_FIRMWARE);
 549                         }
 550                 }
 551         } else {
 552                 printk(KERN_ERR "tda1004x: no request function defined, can't upload from file\n");
 553                 return -EIO;
 554         }
 555         tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8); // going to boot from HOST
 556         ret = tda1004x_do_upload(state, fw->data, fw->size, TDA10046H_CODE_CPT, TDA10046H_CODE_IN);
 557         release_firmware(fw);
 558         return tda1004x_check_upload_ok(state);
 559 }
 560
 561 static int tda1004x_encode_fec(int fec)
 562 {
 563         // convert known FEC values
 564         switch (fec) {
 565         case FEC_1_2:
 566                 return 0;
 567         case FEC_2_3:
 568                 return 1;
 569         case FEC_3_4:
 570                 return 2;
 571         case FEC_5_6:
 572                 return 3;
 573         case FEC_7_8:
 574                 return 4;
 575         }
 576
 577         // unsupported
 578         return -EINVAL;
 579 }
 580
 581 static int tda1004x_decode_fec(int tdafec)
 582 {
 583         // convert known FEC values
 584         switch (tdafec) {
 585         case 0:
 586                 return FEC_1_2;
 587         case 1:
 588                 return FEC_2_3;
 589         case 2:
 590                 return FEC_3_4;
 591         case 3:
 592                 return FEC_5_6;
 593         case 4:
 594                 return FEC_7_8;
 595         }
 596
 597         // unsupported
 598         return -1;
 599 }
 600
 601 static int tda1004x_write(struct dvb_frontend* fe, const u8 buf[], int len)
 602 {
 603         struct tda1004x_state* state = fe->demodulator_priv;
 604
 605         if (len != 2)
 606                 return -EINVAL;
 607
 608         return tda1004x_write_byteI(state, buf[0], buf[1]);
 609 }
 610
 611 static int tda10045_init(struct dvb_frontend* fe)
 612 {
 613         struct tda1004x_state* state = fe->demodulator_priv;
 614
 615         dprintk("%s\n", __func__);
 616
 617         if (tda10045_fwupload(fe)) {
 618                 printk("tda1004x: firmware upload failed\n");
 619                 return -EIO;
 620         }
 621
 622         tda1004x_write_mask(state, TDA1004X_CONFADC1, 0x10, 0); // wake up the ADC
 623
 624         // tda setup
 625         tda1004x_write_mask(state, TDA1004X_CONFC4, 0x20, 0); // disable DSP watchdog timer
 626         tda1004x_write_mask(state, TDA1004X_AUTO, 8, 0); // select HP stream
 627         tda1004x_write_mask(state, TDA1004X_CONFC1, 0x40, 0); // set polarity of VAGC signal
 628         tda1004x_write_mask(state, TDA1004X_CONFC1, 0x80, 0x80); // enable pulse killer
 629         tda1004x_write_mask(state, TDA1004X_AUTO, 0x10, 0x10); // enable auto offset
 630         tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0xC0, 0x0); // no frequency offset
 631         tda1004x_write_byteI(state, TDA1004X_CONF_TS1, 0); // setup MPEG2 TS interface
 632         tda1004x_write_byteI(state, TDA1004X_CONF_TS2, 0); // setup MPEG2 TS interface
 633         tda1004x_write_mask(state, TDA1004X_VBER_MSB, 0xe0, 0xa0); // 10^6 VBER measurement bits
 634         tda1004x_write_mask(state, TDA1004X_CONFC1, 0x10, 0); // VAGC polarity
 635         tda1004x_write_byteI(state, TDA1004X_CONFADC1, 0x2e);
 636
 637         tda1004x_write_mask(state, 0x1f, 0x01, state->config->invert_oclk);
 638
 639         return 0;
 640 }
 641
 642 static int tda10046_init(struct dvb_frontend* fe)
 643 {
 644         struct tda1004x_state* state = fe->demodulator_priv;
 645         dprintk("%s\n", __func__);
 646
 647         if (tda10046_fwupload(fe)) {
 648                 printk("tda1004x: firmware upload failed\n");
 649                         return -EIO;
 650         }
 651
 652         // tda setup
 653         tda1004x_write_mask(state, TDA1004X_CONFC4, 0x20, 0); // disable DSP watchdog timer
 654         tda1004x_write_byteI(state, TDA1004X_AUTO, 0x87);    // 100 ppm crystal, select HP stream
 655         tda1004x_write_byteI(state, TDA1004X_CONFC1, 0x88);      // enable pulse killer
 656
 657         switch (state->config->agc_config) {
 658         case TDA10046_AGC_DEFAULT:
 659                 tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x00); // AGC setup
 660                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
 661                 break;
 662         case TDA10046_AGC_IFO_AUTO_NEG:
 663                 tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x0a); // AGC setup
 664                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
 665                 break;
 666         case TDA10046_AGC_IFO_AUTO_POS:
 667                 tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x0a); // AGC setup
 668                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x00);  // set AGC polarities
 669                 break;
 670         case TDA10046_AGC_TDA827X:
 671                 tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x02);   // AGC setup
 672                 tda1004x_write_byteI(state, TDA10046H_AGC_THR, 0x70);    // AGC Threshold
 673                 tda1004x_write_byteI(state, TDA10046H_AGC_RENORM, 0x08); // Gain Renormalize
 674                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
 675                 break;
 676         }
 677         if (state->config->ts_mode == 0) {
 678                 tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 0xc0, 0x40);
 679                 tda1004x_write_mask(state, 0x3a, 0x80, state->config->invert_oclk << 7);
 680         } else {
 681                 tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 0xc0, 0x80);
 682                 tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x10,
 683                                                         state->config->invert_oclk << 4);
 684         }
 685         tda1004x_write_byteI(state, TDA1004X_CONFADC2, 0x38);
 686         tda1004x_write_mask (state, TDA10046H_CONF_TRISTATE1, 0x3e, 0x38); // Turn IF AGC output on
 687         tda1004x_write_byteI(state, TDA10046H_AGC_TUN_MIN, 0);    // }
 688         tda1004x_write_byteI(state, TDA10046H_AGC_TUN_MAX, 0xff); // } AGC min/max values
 689         tda1004x_write_byteI(state, TDA10046H_AGC_IF_MIN, 0);     // }
 690         tda1004x_write_byteI(state, TDA10046H_AGC_IF_MAX, 0xff);  // }
 691         tda1004x_write_byteI(state, TDA10046H_AGC_GAINS, 0x12); // IF gain 2, TUN gain 1
 692         tda1004x_write_byteI(state, TDA10046H_CVBER_CTRL, 0x1a); // 10^6 VBER measurement bits
 693         tda1004x_write_byteI(state, TDA1004X_CONF_TS1, 7); // MPEG2 interface config
 694         tda1004x_write_byteI(state, TDA1004X_CONF_TS2, 0xc0); // MPEG2 interface config
 695         // tda1004x_write_mask(state, 0x50, 0x80, 0x80);         // handle out of guard echoes
 696
 697         return 0;
 698 }
 699
 700 static int tda1004x_set_fe(struct dvb_frontend* fe,
 701                            struct dvb_frontend_parameters *fe_params)
 702 {
 703         struct tda1004x_state* state = fe->demodulator_priv;
 704         int tmp;
 705         int inversion;
 706
 707         dprintk("%s\n", __func__);
 708
 709         if (state->demod_type == TDA1004X_DEMOD_TDA10046) {
 710                 // setup auto offset
 711                 tda1004x_write_mask(state, TDA1004X_AUTO, 0x10, 0x10);
 712                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x80, 0);
 713                 tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0xC0, 0);
 714
 715                 // disable agc_conf[2]
 716                 tda1004x_write_mask(state, TDA10046H_AGC_CONF, 4, 0);
 717         }
 718
 719         // set frequency
 720         if (fe->ops.tuner_ops.set_params) {
 721                 fe->ops.tuner_ops.set_params(fe, fe_params);
 722                 if (fe->ops.i2c_gate_ctrl)
 723                         fe->ops.i2c_gate_ctrl(fe, 0);
 724         }
 725
 726         // Hardcoded to use auto as much as possible on the TDA10045 as it
 727         // is very unreliable if AUTO mode is _not_ used.
 728         if (state->demod_type == TDA1004X_DEMOD_TDA10045) {
 729                 fe_params->u.ofdm.code_rate_HP = FEC_AUTO;
 730                 fe_params->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
 731                 fe_params->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
 732         }
 733
 734         // Set standard params.. or put them to auto
 735         if ((fe_params->u.ofdm.code_rate_HP == FEC_AUTO) ||
 736                 (fe_params->u.ofdm.code_rate_LP == FEC_AUTO) ||
 737                 (fe_params->u.ofdm.constellation == QAM_AUTO) ||
 738                 (fe_params->u.ofdm.hierarchy_information == HIERARCHY_AUTO)) {
 739                 tda1004x_write_mask(state, TDA1004X_AUTO, 1, 1);        // enable auto
 740                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x03, 0); // turn off constellation bits
 741                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 0); // turn off hierarchy bits
 742                 tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0x3f, 0); // turn off FEC bits
 743         } else {
 744                 tda1004x_write_mask(state, TDA1004X_AUTO, 1, 0);        // disable auto
 745
 746                 // set HP FEC
 747                 tmp = tda1004x_encode_fec(fe_params->u.ofdm.code_rate_HP);
 748                 if (tmp < 0)
 749                         return tmp;
 750                 tda1004x_write_mask(state, TDA1004X_IN_CONF2, 7, tmp);
 751
 752                 // set LP FEC
 753                 tmp = tda1004x_encode_fec(fe_params->u.ofdm.code_rate_LP);
 754                 if (tmp < 0)
 755                         return tmp;
 756                 tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0x38, tmp << 3);
 757
 758                 // set constellation
 759                 switch (fe_params->u.ofdm.constellation) {
 760                 case QPSK:
 761                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 0);
 762                         break;
 763
 764                 case QAM_16:
 765                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 1);
 766                         break;
 767
 768                 case QAM_64:
 769                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 2);
 770                         break;
 771
 772                 default:
 773                         return -EINVAL;
 774                 }
 775
 776                 // set hierarchy
 777                 switch (fe_params->u.ofdm.hierarchy_information) {
 778                 case HIERARCHY_NONE:
 779                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 0 << 5);
 780                         break;
 781
 782                 case HIERARCHY_1:
 783                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 1 << 5);
 784                         break;
 785
 786                 case HIERARCHY_2:
 787                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 2 << 5);
 788                         break;
 789
 790                 case HIERARCHY_4:
 791                         tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 3 << 5);
 792                         break;
 793
 794                 default:
 795                         return -EINVAL;
 796                 }
 797         }
 798
 799         // set bandwidth
 800         switch (state->demod_type) {
 801         case TDA1004X_DEMOD_TDA10045:
 802                 tda10045h_set_bandwidth(state, fe_params->u.ofdm.bandwidth);
 803                 break;
 804
 805         case TDA1004X_DEMOD_TDA10046:
 806                 tda10046h_set_bandwidth(state, fe_params->u.ofdm.bandwidth);
 807                 break;
 808         }
 809
 810         // set inversion
 811         inversion = fe_params->inversion;
 812         if (state->config->invert)
 813                 inversion = inversion ? INVERSION_OFF : INVERSION_ON;
 814         switch (inversion) {
 815         case INVERSION_OFF:
 816                 tda1004x_write_mask(state, TDA1004X_CONFC1, 0x20, 0);
 817                 break;
 818
 819         case INVERSION_ON:
 820                 tda1004x_write_mask(state, TDA1004X_CONFC1, 0x20, 0x20);
 821                 break;
 822
 823         default:
 824                 return -EINVAL;
 825         }
 826
 827         // set guard interval
 828         switch (fe_params->u.ofdm.guard_interval) {
 829         case GUARD_INTERVAL_1_32:
 830                 tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
 831                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 0 << 2);
 832                 break;
 833
 834         case GUARD_INTERVAL_1_16:
 835                 tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
 836                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 1 << 2);
 837                 break;
 838
 839         case GUARD_INTERVAL_1_8:
 840                 tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
 841                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 2 << 2);
 842                 break;
 843
 844         case GUARD_INTERVAL_1_4:
 845                 tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
 846                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 3 << 2);
 847                 break;
 848
 849         case GUARD_INTERVAL_AUTO:
 850                 tda1004x_write_mask(state, TDA1004X_AUTO, 2, 2);
 851                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 0 << 2);
 852                 break;
 853
 854         default:
 855                 return -EINVAL;
 856         }
 857
 858         // set transmission mode
 859         switch (fe_params->u.ofdm.transmission_mode) {
 860         case TRANSMISSION_MODE_2K:
 861                 tda1004x_write_mask(state, TDA1004X_AUTO, 4, 0);
 862                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 0 << 4);
 863                 break;
 864
 865         case TRANSMISSION_MODE_8K:
 866                 tda1004x_write_mask(state, TDA1004X_AUTO, 4, 0);
 867                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 1 << 4);
 868                 break;
 869
 870         case TRANSMISSION_MODE_AUTO:
 871                 tda1004x_write_mask(state, TDA1004X_AUTO, 4, 4);
 872                 tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 0);
 873                 break;
 874
 875         default:
 876                 return -EINVAL;
 877         }
 878
 879         // start the lock
 880         switch (state->demod_type) {
 881         case TDA1004X_DEMOD_TDA10045:
 882                 tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8);
 883                 tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 0);
 884                 break;
 885
 886         case TDA1004X_DEMOD_TDA10046:
 887                 tda1004x_write_mask(state, TDA1004X_AUTO, 0x40, 0x40);
 888                 msleep(1);
 889                 tda1004x_write_mask(state, TDA10046H_AGC_CONF, 4, 1);
 890                 break;
 891         }
 892
 893         msleep(10);
 894
 895         return 0;
 896 }
 897
 898 static int tda1004x_get_fe(struct dvb_frontend* fe, struct dvb_frontend_parameters *fe_params)
 899 {
 900         struct tda1004x_state* state = fe->demodulator_priv;
 901         int status;
 902
 903         dprintk("%s\n", __func__);
 904
 905         status = tda1004x_read_byte(state, TDA1004X_STATUS_CD);
 906         if (status == -1)
 907                 return -EIO;
 908
 909         /* Only update the properties cache if device is locked */
 910         if (!(status & 8))
 911                 return 0;
 912
 913         // inversion status
 914         fe_params->inversion = INVERSION_OFF;
 915         if (tda1004x_read_byte(state, TDA1004X_CONFC1) & 0x20)
 916                 fe_params->inversion = INVERSION_ON;
 917         if (state->config->invert)
 918                 fe_params->inversion = fe_params->inversion ? INVERSION_OFF : INVERSION_ON;
 919
 920         // bandwidth
 921         switch (state->demod_type) {
 922         case TDA1004X_DEMOD_TDA10045:
 923                 switch (tda1004x_read_byte(state, TDA10045H_WREF_LSB)) {
 924                 case 0x14:
 925                         fe_params->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
 926                         break;
 927                 case 0xdb:
 928                         fe_params->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
 929                         break;
 930                 case 0x4f:
 931                         fe_params->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
 932                         break;
 933                 }
 934                 break;
 935         case TDA1004X_DEMOD_TDA10046:
 936                 switch (tda1004x_read_byte(state, TDA10046H_TIME_WREF1)) {
 937                 case 0x5c:
 938                 case 0x54:
 939                         fe_params->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
 940                         break;
 941                 case 0x6a:
 942                 case 0x60:
 943                         fe_params->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
 944                         break;
 945                 case 0x7b:
 946                 case 0x70:
 947                         fe_params->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
 948                         break;
 949                 }
 950                 break;
 951         }
 952
 953         // FEC
 954         fe_params->u.ofdm.code_rate_HP =
 955             tda1004x_decode_fec(tda1004x_read_byte(state, TDA1004X_OUT_CONF2) & 7);
 956         fe_params->u.ofdm.code_rate_LP =
 957             tda1004x_decode_fec((tda1004x_read_byte(state, TDA1004X_OUT_CONF2) >> 3) & 7);
 958
 959         // constellation
 960         switch (tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 3) {
 961         case 0:
 962                 fe_params->u.ofdm.constellation = QPSK;
 963                 break;
 964         case 1:
 965                 fe_params->u.ofdm.constellation = QAM_16;
 966                 break;
 967         case 2:
 968                 fe_params->u.ofdm.constellation = QAM_64;
 969                 break;
 970         }
 971
 972         // transmission mode
 973         fe_params->u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
 974         if (tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x10)
 975                 fe_params->u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
 976
 977         // guard interval
 978         switch ((tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x0c) >> 2) {
 979         case 0:
 980                 fe_params->u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
 981                 break;
 982         case 1:
 983                 fe_params->u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
 984                 break;
 985         case 2:
 986                 fe_params->u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
 987                 break;
 988         case 3:
 989                 fe_params->u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
 990                 break;
 991         }
 992
 993         // hierarchy
 994         switch ((tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x60) >> 5) {
 995         case 0:
 996                 fe_params->u.ofdm.hierarchy_information = HIERARCHY_NONE;
 997                 break;
 998         case 1:
 999                 fe_params->u.ofdm.hierarchy_information = HIERARCHY_1;
1000                 break;
1001         case 2:
1002                 fe_params->u.ofdm.hierarchy_information = HIERARCHY_2;
1003                 break;
1004         case 3:
1005                 fe_params->u.ofdm.hierarchy_information = HIERARCHY_4;
1006                 break;
1007         }
1008
1009         return 0;
1010 }
1011
1012 static int tda1004x_read_status(struct dvb_frontend* fe, fe_status_t * fe_status)
1013 {
1014         struct tda1004x_state* state = fe->demodulator_priv;
1015         int status;
1016         int cber;
1017         int vber;
1018
1019         dprintk("%s\n", __func__);
1020
1021         // read status
1022         status = tda1004x_read_byte(state, TDA1004X_STATUS_CD);
1023         if (status == -1)
1024                 return -EIO;
1025
1026         // decode
1027         *fe_status = 0;
1028         if (status & 4)
1029                 *fe_status |= FE_HAS_SIGNAL;
1030         if (status & 2)
1031                 *fe_status |= FE_HAS_CARRIER;
1032         if (status & 8)
1033                 *fe_status |= FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
1034
1035         // if we don't already have VITERBI (i.e. not LOCKED), see if the viterbi
1036         // is getting anything valid
1037         if (!(*fe_status & FE_HAS_VITERBI)) {
1038                 // read the CBER
1039                 cber = tda1004x_read_byte(state, TDA1004X_CBER_LSB);
1040                 if (cber == -1)
1041                         return -EIO;
1042                 status = tda1004x_read_byte(state, TDA1004X_CBER_MSB);
1043                 if (status == -1)
1044                         return -EIO;
1045                 cber |= (status << 8);
1046                 // The address 0x20 should be read to cope with a TDA10046 bug
1047                 tda1004x_read_byte(state, TDA1004X_CBER_RESET);
1048
1049                 if (cber != 65535)
1050                         *fe_status |= FE_HAS_VITERBI;
1051         }
1052
1053         // if we DO have some valid VITERBI output, but don't already have SYNC
1054         // bytes (i.e. not LOCKED), see if the RS decoder is getting anything valid.
1055         if ((*fe_status & FE_HAS_VITERBI) && (!(*fe_status & FE_HAS_SYNC))) {
1056                 // read the VBER
1057                 vber = tda1004x_read_byte(state, TDA1004X_VBER_LSB);
1058                 if (vber == -1)
1059                         return -EIO;
1060                 status = tda1004x_read_byte(state, TDA1004X_VBER_MID);
1061                 if (status == -1)
1062                         return -EIO;
1063                 vber |= (status << 8);
1064                 status = tda1004x_read_byte(state, TDA1004X_VBER_MSB);
1065                 if (status == -1)
1066                         return -EIO;
1067                 vber |= (status & 0x0f) << 16;
1068                 // The CVBER_LUT should be read to cope with TDA10046 hardware bug
1069                 tda1004x_read_byte(state, TDA1004X_CVBER_LUT);
1070
1071                 // if RS has passed some valid TS packets, then we must be
1072                 // getting some SYNC bytes
1073                 if (vber < 16632)
1074                         *fe_status |= FE_HAS_SYNC;
1075         }
1076
1077         // success
1078         dprintk("%s: fe_status=0x%x\n", __func__, *fe_status);
1079         return 0;
1080 }
1081
1082 static int tda1004x_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
1083 {
1084         struct tda1004x_state* state = fe->demodulator_priv;
1085         int tmp;
1086         int reg = 0;
1087
1088         dprintk("%s\n", __func__);
1089
1090         // determine the register to use
1091         switch (state->demod_type) {
1092         case TDA1004X_DEMOD_TDA10045:
1093                 reg = TDA10045H_S_AGC;
1094                 break;
1095
1096         case TDA1004X_DEMOD_TDA10046:
1097                 reg = TDA10046H_AGC_IF_LEVEL;
1098                 break;
1099         }
1100
1101         // read it
1102         tmp = tda1004x_read_byte(state, reg);
1103         if (tmp < 0)
1104                 return -EIO;
1105
1106         *signal = (tmp << 8) | tmp;
1107         dprintk("%s: signal=0x%x\n", __func__, *signal);
1108         return 0;
1109 }
1110
1111 static int tda1004x_read_snr(struct dvb_frontend* fe, u16 * snr)
1112 {
1113         struct tda1004x_state* state = fe->demodulator_priv;
1114         int tmp;
1115
1116         dprintk("%s\n", __func__);
1117
1118         // read it
1119         tmp = tda1004x_read_byte(state, TDA1004X_SNR);
1120         if (tmp < 0)
1121                 return -EIO;
1122         tmp = 255 - tmp;
1123
1124         *snr = ((tmp << 8) | tmp);
1125         dprintk("%s: snr=0x%x\n", __func__, *snr);
1126         return 0;
1127 }
1128
1129 static int tda1004x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
1130 {
1131         struct tda1004x_state* state = fe->demodulator_priv;
1132         int tmp;
1133         int tmp2;
1134         int counter;
1135
1136         dprintk("%s\n", __func__);
1137
1138         // read the UCBLOCKS and reset
1139         counter = 0;
1140         tmp = tda1004x_read_byte(state, TDA1004X_UNCOR);
1141         if (tmp < 0)
1142                 return -EIO;
1143         tmp &= 0x7f;
1144         while (counter++ < 5) {
1145                 tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1146                 tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1147                 tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1148
1149                 tmp2 = tda1004x_read_byte(state, TDA1004X_UNCOR);
1150                 if (tmp2 < 0)
1151                         return -EIO;
1152                 tmp2 &= 0x7f;
1153                 if ((tmp2 < tmp) || (tmp2 == 0))
1154                         break;
1155         }
1156
1157         if (tmp != 0x7f)
1158                 *ucblocks = tmp;
1159         else
1160                 *ucblocks = 0xffffffff;
1161
1162         dprintk("%s: ucblocks=0x%x\n", __func__, *ucblocks);
1163         return 0;
1164 }
1165
1166 static int tda1004x_read_ber(struct dvb_frontend* fe, u32* ber)
1167 {
1168         struct tda1004x_state* state = fe->demodulator_priv;
1169         int tmp;
1170
1171         dprintk("%s\n", __func__);
1172
1173         // read it in
1174         tmp = tda1004x_read_byte(state, TDA1004X_CBER_LSB);
1175         if (tmp < 0)
1176                 return -EIO;
1177         *ber = tmp << 1;
1178         tmp = tda1004x_read_byte(state, TDA1004X_CBER_MSB);
1179         if (tmp < 0)
1180                 return -EIO;
1181         *ber |= (tmp << 9);
1182         // The address 0x20 should be read to cope with a TDA10046 bug
1183         tda1004x_read_byte(state, TDA1004X_CBER_RESET);
1184
1185         dprintk("%s: ber=0x%x\n", __func__, *ber);
1186         return 0;
1187 }
1188
1189 static int tda1004x_sleep(struct dvb_frontend* fe)
1190 {
1191         struct tda1004x_state* state = fe->demodulator_priv;
1192         int gpio_conf;
1193
1194         switch (state->demod_type) {
1195         case TDA1004X_DEMOD_TDA10045:
1196                 tda1004x_write_mask(state, TDA1004X_CONFADC1, 0x10, 0x10);
1197                 break;
1198
1199         case TDA1004X_DEMOD_TDA10046:
1200                 /* set outputs to tristate */
1201                 tda1004x_write_byteI(state, TDA10046H_CONF_TRISTATE1, 0xff);
1202                 /* invert GPIO 1 and 3 if desired*/
1203                 gpio_conf = state->config->gpio_config;
1204                 if (gpio_conf >= TDA10046_GP00_I)
1205                         tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x0f,
1206                                                         (gpio_conf & 0x0f) ^ 0x0a);
1207
1208                 tda1004x_write_mask(state, TDA1004X_CONFADC2, 0xc0, 0xc0);
1209                 tda1004x_write_mask(state, TDA1004X_CONFC4, 1, 1);
1210                 break;
1211         }
1212
1213         return 0;
1214 }
1215
1216 static int tda1004x_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
1217 {
1218         struct tda1004x_state* state = fe->demodulator_priv;
1219
1220         if (enable) {
1221                 return tda1004x_enable_tuner_i2c(state);
1222         } else {
1223                 return tda1004x_disable_tuner_i2c(state);
1224         }
1225 }
1226
1227 static int tda1004x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
1228 {
1229         fesettings->min_delay_ms = 800;
1230         /* Drift compensation makes no sense for DVB-T */
1231         fesettings->step_size = 0;
1232         fesettings->max_drift = 0;
1233         return 0;
1234 }
1235
1236 static void tda1004x_release(struct dvb_frontend* fe)
1237 {
1238         struct tda1004x_state *state = fe->demodulator_priv;
1239         kfree(state);
1240 }
1241
1242 static struct dvb_frontend_ops tda10045_ops = {
1243         .info = {
1244                 .name = "Philips TDA10045H DVB-T",
1245                 .type = FE_OFDM,
1246                 .frequency_min = 51000000,
1247                 .frequency_max = 858000000,
1248                 .frequency_stepsize = 166667,
1249                 .caps =
1250                     FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1251                     FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1252                     FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
1253                     FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO
1254         },
1255
1256         .release = tda1004x_release,
1257
1258         .init = tda10045_init,
1259         .sleep = tda1004x_sleep,
1260         .write = tda1004x_write,
1261         .i2c_gate_ctrl = tda1004x_i2c_gate_ctrl,
1262
1263         .set_frontend = tda1004x_set_fe,
1264         .get_frontend = tda1004x_get_fe,
1265         .get_tune_settings = tda1004x_get_tune_settings,
1266
1267         .read_status = tda1004x_read_status,
1268         .read_ber = tda1004x_read_ber,
1269         .read_signal_strength = tda1004x_read_signal_strength,
1270         .read_snr = tda1004x_read_snr,
1271         .read_ucblocks = tda1004x_read_ucblocks,
1272 };
1273
1274 struct dvb_frontend* tda10045_attach(const struct tda1004x_config* config,
1275                                      struct i2c_adapter* i2c)
1276 {
1277         struct tda1004x_state *state;
1278         int id;
1279
1280         /* allocate memory for the internal state */
1281         state = kzalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
1282         if (!state) {
1283                 printk(KERN_ERR "Can't alocate memory for tda10045 state\n");
1284                 return NULL;
1285         }
1286
1287         /* setup the state */
1288         state->config = config;
1289         state->i2c = i2c;
1290         state->demod_type = TDA1004X_DEMOD_TDA10045;
1291
1292         /* check if the demod is there */
1293         id = tda1004x_read_byte(state, TDA1004X_CHIPID);
1294         if (id < 0) {
1295                 printk(KERN_ERR "tda10045: chip is not answering. Giving up.\n");
1296                 kfree(state);
1297                 return NULL;
1298         }
1299
1300         if (id != 0x25) {
1301                 printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
1302                 kfree(state);
1303                 return NULL;
1304         }
1305
1306         /* create dvb_frontend */
1307         memcpy(&state->frontend.ops, &tda10045_ops, sizeof(struct dvb_frontend_ops));
1308         state->frontend.demodulator_priv = state;
1309         return &state->frontend;
1310 }
1311
1312 static struct dvb_frontend_ops tda10046_ops = {
1313         .info = {
1314                 .name = "Philips TDA10046H DVB-T",
1315                 .type = FE_OFDM,
1316                 .frequency_min = 51000000,
1317                 .frequency_max = 858000000,
1318                 .frequency_stepsize = 166667,
1319                 .caps =
1320                     FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1321                     FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1322                     FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
1323                     FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO
1324         },
1325
1326         .release = tda1004x_release,
1327
1328         .init = tda10046_init,
1329         .sleep = tda1004x_sleep,
1330         .write = tda1004x_write,
1331         .i2c_gate_ctrl = tda1004x_i2c_gate_ctrl,
1332
1333         .set_frontend = tda1004x_set_fe,
1334         .get_frontend = tda1004x_get_fe,
1335         .get_tune_settings = tda1004x_get_tune_settings,
1336
1337         .read_status = tda1004x_read_status,
1338         .read_ber = tda1004x_read_ber,
1339         .read_signal_strength = tda1004x_read_signal_strength,
1340         .read_snr = tda1004x_read_snr,
1341         .read_ucblocks = tda1004x_read_ucblocks,
1342 };
1343
1344 struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config,
1345                                      struct i2c_adapter* i2c)
1346 {
1347         struct tda1004x_state *state;
1348         int id;
1349
1350         /* allocate memory for the internal state */
1351         state = kzalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
1352         if (!state) {
1353                 printk(KERN_ERR "Can't alocate memory for tda10046 state\n");
1354                 return NULL;
1355         }
1356
1357         /* setup the state */
1358         state->config = config;
1359         state->i2c = i2c;
1360         state->demod_type = TDA1004X_DEMOD_TDA10046;
1361
1362         /* check if the demod is there */
1363         id = tda1004x_read_byte(state, TDA1004X_CHIPID);
1364         if (id < 0) {
1365                 printk(KERN_ERR "tda10046: chip is not answering. Giving up.\n");
1366                 kfree(state);
1367                 return NULL;
1368         }
1369         if (id != 0x46) {
1370                 printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
1371                 kfree(state);
1372                 return NULL;
1373         }
1374
1375         /* create dvb_frontend */
1376         memcpy(&state->frontend.ops, &tda10046_ops, sizeof(struct dvb_frontend_ops));
1377         state->frontend.demodulator_priv = state;
1378         return &state->frontend;
1379 }
1380
1381 module_param(debug, int, 0644);
1382 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
1383
1384 MODULE_DESCRIPTION("Philips TDA10045H & TDA10046H DVB-T Demodulator");
1385 MODULE_AUTHOR("Andrew de Quincey & Robert Schlabbach");
1386 MODULE_LICENSE("GPL");
1387
1388 EXPORT_SYMBOL(tda10045_attach);
1389 EXPORT_SYMBOL(tda10046_attach);