drivers/media/dvb-frontends/tda1004x.c

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