drivers/media/i2c/cx25840/cx25840-core.c

   1 /* cx25840 - Conexant CX25840 audio/video decoder driver
   2  *
   3  * Copyright (C) 2004 Ulf Eklund
   4  *
   5  * Based on the saa7115 driver and on the first version of Chris Kennedy's
   6  * cx25840 driver.
   7  *
   8  * Changes by Tyler Trafford <tatrafford@comcast.net>
   9  *    - cleanup/rewrite for V4L2 API (2005)
  10  *
  11  * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
  12  *
  13  * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
  14  * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
  15  *
  16  * CX23885 support by Steven Toth <stoth@linuxtv.org>.
  17  *
  18  * CX2388[578] IRQ handling, IO Pin mux configuration and other small fixes are
  19  * Copyright (C) 2010 Andy Walls <awalls@md.metrocast.net>
  20  *
  21  * CX23888 DIF support for the HVR1850
  22  * Copyright (C) 2011 Steven Toth <stoth@kernellabs.com>
  23  *
  24  * This program is free software; you can redistribute it and/or
  25  * modify it under the terms of the GNU General Public License
  26  * as published by the Free Software Foundation; either version 2
  27  * of the License, or (at your option) any later version.
  28  *
  29  * This program is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  * You should have received a copy of the GNU General Public License
  35  * along with this program; if not, write to the Free Software
  36  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  37  */
  38
  39
  40 #include <linux/kernel.h>
  41 #include <linux/module.h>
  42 #include <linux/slab.h>
  43 #include <linux/videodev2.h>
  44 #include <linux/i2c.h>
  45 #include <linux/delay.h>
  46 #include <linux/math64.h>
  47 #include <media/v4l2-common.h>
  48 #include <media/cx25840.h>
  49
  50 #include "cx25840-core.h"
  51
  52 MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
  53 MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
  54 MODULE_LICENSE("GPL");
  55
  56 #define CX25840_VID_INT_STAT_REG 0x410
  57 #define CX25840_VID_INT_STAT_BITS 0x0000ffff
  58 #define CX25840_VID_INT_MASK_BITS 0xffff0000
  59 #define CX25840_VID_INT_MASK_SHFT 16
  60 #define CX25840_VID_INT_MASK_REG 0x412
  61
  62 #define CX23885_AUD_MC_INT_MASK_REG 0x80c
  63 #define CX23885_AUD_MC_INT_STAT_BITS 0xffff0000
  64 #define CX23885_AUD_MC_INT_CTRL_BITS 0x0000ffff
  65 #define CX23885_AUD_MC_INT_STAT_SHFT 16
  66
  67 #define CX25840_AUD_INT_CTRL_REG 0x812
  68 #define CX25840_AUD_INT_STAT_REG 0x813
  69
  70 #define CX23885_PIN_CTRL_IRQ_REG 0x123
  71 #define CX23885_PIN_CTRL_IRQ_IR_STAT  0x40
  72 #define CX23885_PIN_CTRL_IRQ_AUD_STAT 0x20
  73 #define CX23885_PIN_CTRL_IRQ_VID_STAT 0x10
  74
  75 #define CX25840_IR_STATS_REG    0x210
  76 #define CX25840_IR_IRQEN_REG    0x214
  77
  78 static int cx25840_debug;
  79
  80 module_param_named(debug,cx25840_debug, int, 0644);
  81
  82 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
  83
  84
  85 /* ----------------------------------------------------------------------- */
  86 static void cx23888_std_setup(struct i2c_client *client);
  87
  88 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
  89 {
  90         u8 buffer[3];
  91         buffer[0] = addr >> 8;
  92         buffer[1] = addr & 0xff;
  93         buffer[2] = value;
  94         return i2c_master_send(client, buffer, 3);
  95 }
  96
  97 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
  98 {
  99         u8 buffer[6];
 100         buffer[0] = addr >> 8;
 101         buffer[1] = addr & 0xff;
 102         buffer[2] = value & 0xff;
 103         buffer[3] = (value >> 8) & 0xff;
 104         buffer[4] = (value >> 16) & 0xff;
 105         buffer[5] = value >> 24;
 106         return i2c_master_send(client, buffer, 6);
 107 }
 108
 109 u8 cx25840_read(struct i2c_client * client, u16 addr)
 110 {
 111         struct i2c_msg msgs[2];
 112         u8 tx_buf[2], rx_buf[1];
 113
 114         /* Write register address */
 115         tx_buf[0] = addr >> 8;
 116         tx_buf[1] = addr & 0xff;
 117         msgs[0].addr = client->addr;
 118         msgs[0].flags = 0;
 119         msgs[0].len = 2;
 120         msgs[0].buf = (char *) tx_buf;
 121
 122         /* Read data from register */
 123         msgs[1].addr = client->addr;
 124         msgs[1].flags = I2C_M_RD;
 125         msgs[1].len = 1;
 126         msgs[1].buf = (char *) rx_buf;
 127
 128         if (i2c_transfer(client->adapter, msgs, 2) < 2)
 129                 return 0;
 130
 131         return rx_buf[0];
 132 }
 133
 134 u32 cx25840_read4(struct i2c_client * client, u16 addr)
 135 {
 136         struct i2c_msg msgs[2];
 137         u8 tx_buf[2], rx_buf[4];
 138
 139         /* Write register address */
 140         tx_buf[0] = addr >> 8;
 141         tx_buf[1] = addr & 0xff;
 142         msgs[0].addr = client->addr;
 143         msgs[0].flags = 0;
 144         msgs[0].len = 2;
 145         msgs[0].buf = (char *) tx_buf;
 146
 147         /* Read data from registers */
 148         msgs[1].addr = client->addr;
 149         msgs[1].flags = I2C_M_RD;
 150         msgs[1].len = 4;
 151         msgs[1].buf = (char *) rx_buf;
 152
 153         if (i2c_transfer(client->adapter, msgs, 2) < 2)
 154                 return 0;
 155
 156         return (rx_buf[3] << 24) | (rx_buf[2] << 16) | (rx_buf[1] << 8) |
 157                 rx_buf[0];
 158 }
 159
 160 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
 161                    u8 or_value)
 162 {
 163         return cx25840_write(client, addr,
 164                              (cx25840_read(client, addr) & and_mask) |
 165                              or_value);
 166 }
 167
 168 int cx25840_and_or4(struct i2c_client *client, u16 addr, u32 and_mask,
 169                     u32 or_value)
 170 {
 171         return cx25840_write4(client, addr,
 172                               (cx25840_read4(client, addr) & and_mask) |
 173                               or_value);
 174 }
 175
 176 /* ----------------------------------------------------------------------- */
 177
 178 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
 179                                                 enum cx25840_audio_input aud_input);
 180
 181 /* ----------------------------------------------------------------------- */
 182
 183 static int cx23885_s_io_pin_config(struct v4l2_subdev *sd, size_t n,
 184                                       struct v4l2_subdev_io_pin_config *p)
 185 {
 186         struct i2c_client *client = v4l2_get_subdevdata(sd);
 187         int i;
 188         u32 pin_ctrl;
 189         u8 gpio_oe, gpio_data, strength;
 190
 191         pin_ctrl = cx25840_read4(client, 0x120);
 192         gpio_oe = cx25840_read(client, 0x160);
 193         gpio_data = cx25840_read(client, 0x164);
 194
 195         for (i = 0; i < n; i++) {
 196                 strength = p[i].strength;
 197                 if (strength > CX25840_PIN_DRIVE_FAST)
 198                         strength = CX25840_PIN_DRIVE_FAST;
 199
 200                 switch (p[i].pin) {
 201                 case CX23885_PIN_IRQ_N_GPIO16:
 202                         if (p[i].function != CX23885_PAD_IRQ_N) {
 203                                 /* GPIO16 */
 204                                 pin_ctrl &= ~(0x1 << 25);
 205                         } else {
 206                                 /* IRQ_N */
 207                                 if (p[i].flags &
 208                                         (V4L2_SUBDEV_IO_PIN_DISABLE |
 209                                          V4L2_SUBDEV_IO_PIN_INPUT)) {
 210                                         pin_ctrl &= ~(0x1 << 25);
 211                                 } else {
 212                                         pin_ctrl |= (0x1 << 25);
 213                                 }
 214                                 if (p[i].flags &
 215                                         V4L2_SUBDEV_IO_PIN_ACTIVE_LOW) {
 216                                         pin_ctrl &= ~(0x1 << 24);
 217                                 } else {
 218                                         pin_ctrl |= (0x1 << 24);
 219                                 }
 220                         }
 221                         break;
 222                 case CX23885_PIN_IR_RX_GPIO19:
 223                         if (p[i].function != CX23885_PAD_GPIO19) {
 224                                 /* IR_RX */
 225                                 gpio_oe |= (0x1 << 0);
 226                                 pin_ctrl &= ~(0x3 << 18);
 227                                 pin_ctrl |= (strength << 18);
 228                         } else {
 229                                 /* GPIO19 */
 230                                 gpio_oe &= ~(0x1 << 0);
 231                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_SET_VALUE) {
 232                                         gpio_data &= ~(0x1 << 0);
 233                                         gpio_data |= ((p[i].value & 0x1) << 0);
 234                                 }
 235                                 pin_ctrl &= ~(0x3 << 12);
 236                                 pin_ctrl |= (strength << 12);
 237                         }
 238                         break;
 239                 case CX23885_PIN_IR_TX_GPIO20:
 240                         if (p[i].function != CX23885_PAD_GPIO20) {
 241                                 /* IR_TX */
 242                                 gpio_oe |= (0x1 << 1);
 243                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_DISABLE)
 244                                         pin_ctrl &= ~(0x1 << 10);
 245                                 else
 246                                         pin_ctrl |= (0x1 << 10);
 247                                 pin_ctrl &= ~(0x3 << 18);
 248                                 pin_ctrl |= (strength << 18);
 249                         } else {
 250                                 /* GPIO20 */
 251                                 gpio_oe &= ~(0x1 << 1);
 252                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_SET_VALUE) {
 253                                         gpio_data &= ~(0x1 << 1);
 254                                         gpio_data |= ((p[i].value & 0x1) << 1);
 255                                 }
 256                                 pin_ctrl &= ~(0x3 << 12);
 257                                 pin_ctrl |= (strength << 12);
 258                         }
 259                         break;
 260                 case CX23885_PIN_I2S_SDAT_GPIO21:
 261                         if (p[i].function != CX23885_PAD_GPIO21) {
 262                                 /* I2S_SDAT */
 263                                 /* TODO: Input or Output config */
 264                                 gpio_oe |= (0x1 << 2);
 265                                 pin_ctrl &= ~(0x3 << 22);
 266                                 pin_ctrl |= (strength << 22);
 267                         } else {
 268                                 /* GPIO21 */
 269                                 gpio_oe &= ~(0x1 << 2);
 270                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_SET_VALUE) {
 271                                         gpio_data &= ~(0x1 << 2);
 272                                         gpio_data |= ((p[i].value & 0x1) << 2);
 273                                 }
 274                                 pin_ctrl &= ~(0x3 << 12);
 275                                 pin_ctrl |= (strength << 12);
 276                         }
 277                         break;
 278                 case CX23885_PIN_I2S_WCLK_GPIO22:
 279                         if (p[i].function != CX23885_PAD_GPIO22) {
 280                                 /* I2S_WCLK */
 281                                 /* TODO: Input or Output config */
 282                                 gpio_oe |= (0x1 << 3);
 283                                 pin_ctrl &= ~(0x3 << 22);
 284                                 pin_ctrl |= (strength << 22);
 285                         } else {
 286                                 /* GPIO22 */
 287                                 gpio_oe &= ~(0x1 << 3);
 288                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_SET_VALUE) {
 289                                         gpio_data &= ~(0x1 << 3);
 290                                         gpio_data |= ((p[i].value & 0x1) << 3);
 291                                 }
 292                                 pin_ctrl &= ~(0x3 << 12);
 293                                 pin_ctrl |= (strength << 12);
 294                         }
 295                         break;
 296                 case CX23885_PIN_I2S_BCLK_GPIO23:
 297                         if (p[i].function != CX23885_PAD_GPIO23) {
 298                                 /* I2S_BCLK */
 299                                 /* TODO: Input or Output config */
 300                                 gpio_oe |= (0x1 << 4);
 301                                 pin_ctrl &= ~(0x3 << 22);
 302                                 pin_ctrl |= (strength << 22);
 303                         } else {
 304                                 /* GPIO23 */
 305                                 gpio_oe &= ~(0x1 << 4);
 306                                 if (p[i].flags & V4L2_SUBDEV_IO_PIN_SET_VALUE) {
 307                                         gpio_data &= ~(0x1 << 4);
 308                                         gpio_data |= ((p[i].value & 0x1) << 4);
 309                                 }
 310                                 pin_ctrl &= ~(0x3 << 12);
 311                                 pin_ctrl |= (strength << 12);
 312                         }
 313                         break;
 314                 }
 315         }
 316
 317         cx25840_write(client, 0x164, gpio_data);
 318         cx25840_write(client, 0x160, gpio_oe);
 319         cx25840_write4(client, 0x120, pin_ctrl);
 320         return 0;
 321 }
 322
 323 static int common_s_io_pin_config(struct v4l2_subdev *sd, size_t n,
 324                                       struct v4l2_subdev_io_pin_config *pincfg)
 325 {
 326         struct cx25840_state *state = to_state(sd);
 327
 328         if (is_cx2388x(state))
 329                 return cx23885_s_io_pin_config(sd, n, pincfg);
 330         return 0;
 331 }
 332
 333 /* ----------------------------------------------------------------------- */
 334
 335 static void init_dll1(struct i2c_client *client)
 336 {
 337         /* This is the Hauppauge sequence used to
 338          * initialize the Delay Lock Loop 1 (ADC DLL). */
 339         cx25840_write(client, 0x159, 0x23);
 340         cx25840_write(client, 0x15a, 0x87);
 341         cx25840_write(client, 0x15b, 0x06);
 342         udelay(10);
 343         cx25840_write(client, 0x159, 0xe1);
 344         udelay(10);
 345         cx25840_write(client, 0x15a, 0x86);
 346         cx25840_write(client, 0x159, 0xe0);
 347         cx25840_write(client, 0x159, 0xe1);
 348         cx25840_write(client, 0x15b, 0x10);
 349 }
 350
 351 static void init_dll2(struct i2c_client *client)
 352 {
 353         /* This is the Hauppauge sequence used to
 354          * initialize the Delay Lock Loop 2 (ADC DLL). */
 355         cx25840_write(client, 0x15d, 0xe3);
 356         cx25840_write(client, 0x15e, 0x86);
 357         cx25840_write(client, 0x15f, 0x06);
 358         udelay(10);
 359         cx25840_write(client, 0x15d, 0xe1);
 360         cx25840_write(client, 0x15d, 0xe0);
 361         cx25840_write(client, 0x15d, 0xe1);
 362 }
 363
 364 static void cx25836_initialize(struct i2c_client *client)
 365 {
 366         /* reset configuration is described on page 3-77 of the CX25836 datasheet */
 367         /* 2. */
 368         cx25840_and_or(client, 0x000, ~0x01, 0x01);
 369         cx25840_and_or(client, 0x000, ~0x01, 0x00);
 370         /* 3a. */
 371         cx25840_and_or(client, 0x15a, ~0x70, 0x00);
 372         /* 3b. */
 373         cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
 374         /* 3c. */
 375         cx25840_and_or(client, 0x159, ~0x02, 0x02);
 376         /* 3d. */
 377         udelay(10);
 378         /* 3e. */
 379         cx25840_and_or(client, 0x159, ~0x02, 0x00);
 380         /* 3f. */
 381         cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
 382         /* 3g. */
 383         cx25840_and_or(client, 0x159, ~0x01, 0x00);
 384         cx25840_and_or(client, 0x159, ~0x01, 0x01);
 385         /* 3h. */
 386         cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
 387 }
 388
 389 static void cx25840_work_handler(struct work_struct *work)
 390 {
 391         struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
 392         cx25840_loadfw(state->c);
 393         wake_up(&state->fw_wait);
 394 }
 395
 396 static void cx25840_initialize(struct i2c_client *client)
 397 {
 398         DEFINE_WAIT(wait);
 399         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 400         struct workqueue_struct *q;
 401
 402         /* datasheet startup in numbered steps, refer to page 3-77 */
 403         /* 2. */
 404         cx25840_and_or(client, 0x803, ~0x10, 0x00);
 405         /* The default of this register should be 4, but I get 0 instead.
 406          * Set this register to 4 manually. */
 407         cx25840_write(client, 0x000, 0x04);
 408         /* 3. */
 409         init_dll1(client);
 410         init_dll2(client);
 411         cx25840_write(client, 0x136, 0x0a);
 412         /* 4. */
 413         cx25840_write(client, 0x13c, 0x01);
 414         cx25840_write(client, 0x13c, 0x00);
 415         /* 5. */
 416         /* Do the firmware load in a work handler to prevent.
 417            Otherwise the kernel is blocked waiting for the
 418            bit-banging i2c interface to finish uploading the
 419            firmware. */
 420         INIT_WORK(&state->fw_work, cx25840_work_handler);
 421         init_waitqueue_head(&state->fw_wait);
 422         q = create_singlethread_workqueue("cx25840_fw");
 423         if (q) {
 424                 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
 425                 queue_work(q, &state->fw_work);
 426                 schedule();
 427                 finish_wait(&state->fw_wait, &wait);
 428                 destroy_workqueue(q);
 429         }
 430
 431         /* 6. */
 432         cx25840_write(client, 0x115, 0x8c);
 433         cx25840_write(client, 0x116, 0x07);
 434         cx25840_write(client, 0x118, 0x02);
 435         /* 7. */
 436         cx25840_write(client, 0x4a5, 0x80);
 437         cx25840_write(client, 0x4a5, 0x00);
 438         cx25840_write(client, 0x402, 0x00);
 439         /* 8. */
 440         cx25840_and_or(client, 0x401, ~0x18, 0);
 441         cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
 442         /* steps 8c and 8d are done in change_input() */
 443         /* 10. */
 444         cx25840_write(client, 0x8d3, 0x1f);
 445         cx25840_write(client, 0x8e3, 0x03);
 446
 447         cx25840_std_setup(client);
 448
 449         /* trial and error says these are needed to get audio */
 450         cx25840_write(client, 0x914, 0xa0);
 451         cx25840_write(client, 0x918, 0xa0);
 452         cx25840_write(client, 0x919, 0x01);
 453
 454         /* stereo preferred */
 455         cx25840_write(client, 0x809, 0x04);
 456         /* AC97 shift */
 457         cx25840_write(client, 0x8cf, 0x0f);
 458
 459         /* (re)set input */
 460         set_input(client, state->vid_input, state->aud_input);
 461
 462         /* start microcontroller */
 463         cx25840_and_or(client, 0x803, ~0x10, 0x10);
 464 }
 465
 466 static void cx23885_initialize(struct i2c_client *client)
 467 {
 468         DEFINE_WAIT(wait);
 469         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 470         u32 clk_freq = 0;
 471         struct workqueue_struct *q;
 472
 473         /* cx23885 sets hostdata to clk_freq pointer */
 474         if (v4l2_get_subdev_hostdata(&state->sd))
 475                 clk_freq = *((u32 *)v4l2_get_subdev_hostdata(&state->sd));
 476
 477         /*
 478          * Come out of digital power down
 479          * The CX23888, at least, needs this, otherwise registers aside from
 480          * 0x0-0x2 can't be read or written.
 481          */
 482         cx25840_write(client, 0x000, 0);
 483
 484         /* Internal Reset */
 485         cx25840_and_or(client, 0x102, ~0x01, 0x01);
 486         cx25840_and_or(client, 0x102, ~0x01, 0x00);
 487
 488         /* Stop microcontroller */
 489         cx25840_and_or(client, 0x803, ~0x10, 0x00);
 490
 491         /* DIF in reset? */
 492         cx25840_write(client, 0x398, 0);
 493
 494         /*
 495          * Trust the default xtal, no division
 496          * '885: 28.636363... MHz
 497          * '887: 25.000000 MHz
 498          * '888: 50.000000 MHz
 499          */
 500         cx25840_write(client, 0x2, 0x76);
 501
 502         /* Power up all the PLL's and DLL */
 503         cx25840_write(client, 0x1, 0x40);
 504
 505         /* Sys PLL */
 506         switch (state->id) {
 507         case CX23888_AV:
 508                 /*
 509                  * 50.0 MHz * (0xb + 0xe8ba26/0x2000000)/4 = 5 * 28.636363 MHz
 510                  * 572.73 MHz before post divide
 511                  */
 512                 if (clk_freq == 25000000) {
 513                         /* 888/ImpactVCBe or 25Mhz xtal */
 514                         ; /* nothing to do */
 515                 } else {
 516                         /* HVR1850 or 50MHz xtal */
 517                         cx25840_write(client, 0x2, 0x71);
 518                 }
 519                 cx25840_write4(client, 0x11c, 0x01d1744c);
 520                 cx25840_write4(client, 0x118, 0x00000416);
 521                 cx25840_write4(client, 0x404, 0x0010253e);
 522                 cx25840_write4(client, 0x42c, 0x42600000);
 523                 cx25840_write4(client, 0x44c, 0x161f1000);
 524                 break;
 525         case CX23887_AV:
 526                 /*
 527                  * 25.0 MHz * (0x16 + 0x1d1744c/0x2000000)/4 = 5 * 28.636363 MHz
 528                  * 572.73 MHz before post divide
 529                  */
 530                 cx25840_write4(client, 0x11c, 0x01d1744c);
 531                 cx25840_write4(client, 0x118, 0x00000416);
 532                 break;
 533         case CX23885_AV:
 534         default:
 535                 /*
 536                  * 28.636363 MHz * (0x14 + 0x0/0x2000000)/4 = 5 * 28.636363 MHz
 537                  * 572.73 MHz before post divide
 538                  */
 539                 cx25840_write4(client, 0x11c, 0x00000000);
 540                 cx25840_write4(client, 0x118, 0x00000414);
 541                 break;
 542         }
 543
 544         /* Disable DIF bypass */
 545         cx25840_write4(client, 0x33c, 0x00000001);
 546
 547         /* DIF Src phase inc */
 548         cx25840_write4(client, 0x340, 0x0df7df83);
 549
 550         /*
 551          * Vid PLL
 552          * Setup for a BT.656 pixel clock of 13.5 Mpixels/second
 553          *
 554          * 28.636363 MHz * (0xf + 0x02be2c9/0x2000000)/4 = 8 * 13.5 MHz
 555          * 432.0 MHz before post divide
 556          */
 557
 558         /* HVR1850 */
 559         switch (state->id) {
 560         case CX23888_AV:
 561                 if (clk_freq == 25000000) {
 562                         /* 888/ImpactVCBe or 25MHz xtal */
 563                         cx25840_write4(client, 0x10c, 0x01b6db7b);
 564                         cx25840_write4(client, 0x108, 0x00000512);
 565                 } else {
 566                         /* 888/HVR1250 or 50MHz xtal */
 567                         cx25840_write4(client, 0x10c, 0x13333333);
 568                         cx25840_write4(client, 0x108, 0x00000515);
 569                 }
 570                 break;
 571         default:
 572                 cx25840_write4(client, 0x10c, 0x002be2c9);
 573                 cx25840_write4(client, 0x108, 0x0000040f);
 574         }
 575
 576         /* Luma */
 577         cx25840_write4(client, 0x414, 0x00107d12);
 578
 579         /* Chroma */
 580         cx25840_write4(client, 0x420, 0x3d008282);
 581
 582         /*
 583          * Aux PLL
 584          * Initial setup for audio sample clock:
 585          * 48 ksps, 16 bits/sample, x160 multiplier = 122.88 MHz
 586          * Initial I2S output/master clock(?):
 587          * 48 ksps, 16 bits/sample, x16 multiplier = 12.288 MHz
 588          */
 589         switch (state->id) {
 590         case CX23888_AV:
 591                 /*
 592                  * 50.0 MHz * (0x7 + 0x0bedfa4/0x2000000)/3 = 122.88 MHz
 593                  * 368.64 MHz before post divide
 594                  * 122.88 MHz / 0xa = 12.288 MHz
 595                  */
 596                 /* HVR1850 or 50MHz xtal or 25MHz xtal */
 597                 cx25840_write4(client, 0x114, 0x017dbf48);
 598                 cx25840_write4(client, 0x110, 0x000a030e);
 599                 break;
 600         case CX23887_AV:
 601                 /*
 602                  * 25.0 MHz * (0xe + 0x17dbf48/0x2000000)/3 = 122.88 MHz
 603                  * 368.64 MHz before post divide
 604                  * 122.88 MHz / 0xa = 12.288 MHz
 605                  */
 606                 cx25840_write4(client, 0x114, 0x017dbf48);
 607                 cx25840_write4(client, 0x110, 0x000a030e);
 608                 break;
 609         case CX23885_AV:
 610         default:
 611                 /*
 612                  * 28.636363 MHz * (0xc + 0x1bf0c9e/0x2000000)/3 = 122.88 MHz
 613                  * 368.64 MHz before post divide
 614                  * 122.88 MHz / 0xa = 12.288 MHz
 615                  */
 616                 cx25840_write4(client, 0x114, 0x01bf0c9e);
 617                 cx25840_write4(client, 0x110, 0x000a030c);
 618                 break;
 619         }
 620
 621         /* ADC2 input select */
 622         cx25840_write(client, 0x102, 0x10);
 623
 624         /* VIN1 & VIN5 */
 625         cx25840_write(client, 0x103, 0x11);
 626
 627         /* Enable format auto detect */
 628         cx25840_write(client, 0x400, 0);
 629         /* Fast subchroma lock */
 630         /* White crush, Chroma AGC & Chroma Killer enabled */
 631         cx25840_write(client, 0x401, 0xe8);
 632
 633         /* Select AFE clock pad output source */
 634         cx25840_write(client, 0x144, 0x05);
 635
 636         /* Drive GPIO2 direction and values for HVR1700
 637          * where an onboard mux selects the output of demodulator
 638          * vs the 417. Failure to set this results in no DTV.
 639          * It's safe to set this across all Hauppauge boards
 640          * currently, regardless of the board type.
 641          */
 642         cx25840_write(client, 0x160, 0x1d);
 643         cx25840_write(client, 0x164, 0x00);
 644
 645         /* Do the firmware load in a work handler to prevent.
 646            Otherwise the kernel is blocked waiting for the
 647            bit-banging i2c interface to finish uploading the
 648            firmware. */
 649         INIT_WORK(&state->fw_work, cx25840_work_handler);
 650         init_waitqueue_head(&state->fw_wait);
 651         q = create_singlethread_workqueue("cx25840_fw");
 652         if (q) {
 653                 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
 654                 queue_work(q, &state->fw_work);
 655                 schedule();
 656                 finish_wait(&state->fw_wait, &wait);
 657                 destroy_workqueue(q);
 658         }
 659
 660         /* Call the cx23888 specific std setup func, we no longer rely on
 661          * the generic cx24840 func.
 662          */
 663         if (is_cx23888(state))
 664                 cx23888_std_setup(client);
 665         else
 666                 cx25840_std_setup(client);
 667
 668         /* (re)set input */
 669         set_input(client, state->vid_input, state->aud_input);
 670
 671         /* start microcontroller */
 672         cx25840_and_or(client, 0x803, ~0x10, 0x10);
 673
 674         /* Disable and clear video interrupts - we don't use them */
 675         cx25840_write4(client, CX25840_VID_INT_STAT_REG, 0xffffffff);
 676
 677         /* Disable and clear audio interrupts - we don't use them */
 678         cx25840_write(client, CX25840_AUD_INT_CTRL_REG, 0xff);
 679         cx25840_write(client, CX25840_AUD_INT_STAT_REG, 0xff);
 680
 681         /* CC raw enable */
 682         /*  - VIP 1.1 control codes - 10bit, blue field enable.
 683          *  - enable raw data during vertical blanking.
 684          *  - enable ancillary Data insertion for 656 or VIP.
 685          */
 686         cx25840_write4(client, 0x404, 0x0010253e);
 687
 688         /* CC on  - Undocumented Register */
 689         cx25840_write(client, 0x42f, 0x66);
 690
 691         /* HVR-1250 / HVR1850 DIF related */
 692         /* Power everything up */
 693         cx25840_write4(client, 0x130, 0x0);
 694
 695         /* Undocumented */
 696         cx25840_write4(client, 0x478, 0x6628021F);
 697
 698         /* AFE_CLK_OUT_CTRL - Select the clock output source as output */
 699         cx25840_write4(client, 0x144, 0x5);
 700
 701         /* I2C_OUT_CTL - I2S output configuration as
 702          * Master, Sony, Left justified, left sample on WS=1
 703          */
 704         cx25840_write4(client, 0x918, 0x1a0);
 705
 706         /* AFE_DIAG_CTRL1 */
 707         cx25840_write4(client, 0x134, 0x000a1800);
 708
 709         /* AFE_DIAG_CTRL3 - Inverted Polarity for Audio and Video */
 710         cx25840_write4(client, 0x13c, 0x00310000);
 711 }
 712
 713 /* ----------------------------------------------------------------------- */
 714
 715 static void cx231xx_initialize(struct i2c_client *client)
 716 {
 717         DEFINE_WAIT(wait);
 718         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 719         struct workqueue_struct *q;
 720
 721         /* Internal Reset */
 722         cx25840_and_or(client, 0x102, ~0x01, 0x01);
 723         cx25840_and_or(client, 0x102, ~0x01, 0x00);
 724
 725         /* Stop microcontroller */
 726         cx25840_and_or(client, 0x803, ~0x10, 0x00);
 727
 728         /* DIF in reset? */
 729         cx25840_write(client, 0x398, 0);
 730
 731         /* Trust the default xtal, no division */
 732         /* This changes for the cx23888 products */
 733         cx25840_write(client, 0x2, 0x76);
 734
 735         /* Bring down the regulator for AUX clk */
 736         cx25840_write(client, 0x1, 0x40);
 737
 738         /* Disable DIF bypass */
 739         cx25840_write4(client, 0x33c, 0x00000001);
 740
 741         /* DIF Src phase inc */
 742         cx25840_write4(client, 0x340, 0x0df7df83);
 743
 744         /* Luma */
 745         cx25840_write4(client, 0x414, 0x00107d12);
 746
 747         /* Chroma */
 748         cx25840_write4(client, 0x420, 0x3d008282);
 749
 750         /* ADC2 input select */
 751         cx25840_write(client, 0x102, 0x10);
 752
 753         /* VIN1 & VIN5 */
 754         cx25840_write(client, 0x103, 0x11);
 755
 756         /* Enable format auto detect */
 757         cx25840_write(client, 0x400, 0);
 758         /* Fast subchroma lock */
 759         /* White crush, Chroma AGC & Chroma Killer enabled */
 760         cx25840_write(client, 0x401, 0xe8);
 761
 762         /* Do the firmware load in a work handler to prevent.
 763            Otherwise the kernel is blocked waiting for the
 764            bit-banging i2c interface to finish uploading the
 765            firmware. */
 766         INIT_WORK(&state->fw_work, cx25840_work_handler);
 767         init_waitqueue_head(&state->fw_wait);
 768         q = create_singlethread_workqueue("cx25840_fw");
 769         if (q) {
 770                 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
 771                 queue_work(q, &state->fw_work);
 772                 schedule();
 773                 finish_wait(&state->fw_wait, &wait);
 774                 destroy_workqueue(q);
 775         }
 776
 777         cx25840_std_setup(client);
 778
 779         /* (re)set input */
 780         set_input(client, state->vid_input, state->aud_input);
 781
 782         /* start microcontroller */
 783         cx25840_and_or(client, 0x803, ~0x10, 0x10);
 784
 785         /* CC raw enable */
 786         cx25840_write(client, 0x404, 0x0b);
 787
 788         /* CC on */
 789         cx25840_write(client, 0x42f, 0x66);
 790         cx25840_write4(client, 0x474, 0x1e1e601a);
 791 }
 792
 793 /* ----------------------------------------------------------------------- */
 794
 795 void cx25840_std_setup(struct i2c_client *client)
 796 {
 797         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 798         v4l2_std_id std = state->std;
 799         int hblank, hactive, burst, vblank, vactive, sc;
 800         int vblank656, src_decimation;
 801         int luma_lpf, uv_lpf, comb;
 802         u32 pll_int, pll_frac, pll_post;
 803
 804         /* datasheet startup, step 8d */
 805         if (std & ~V4L2_STD_NTSC)
 806                 cx25840_write(client, 0x49f, 0x11);
 807         else
 808                 cx25840_write(client, 0x49f, 0x14);
 809
 810         if (std & V4L2_STD_625_50) {
 811                 hblank = 132;
 812                 hactive = 720;
 813                 burst = 93;
 814                 vblank = 36;
 815                 vactive = 580;
 816                 vblank656 = 40;
 817                 src_decimation = 0x21f;
 818                 luma_lpf = 2;
 819
 820                 if (std & V4L2_STD_SECAM) {
 821                         uv_lpf = 0;
 822                         comb = 0;
 823                         sc = 0x0a425f;
 824                 } else if (std == V4L2_STD_PAL_Nc) {
 825                         uv_lpf = 1;
 826                         comb = 0x20;
 827                         sc = 556453;
 828                 } else {
 829                         uv_lpf = 1;
 830                         comb = 0x20;
 831                         sc = 688739;
 832                 }
 833         } else {
 834                 hactive = 720;
 835                 hblank = 122;
 836                 vactive = 487;
 837                 luma_lpf = 1;
 838                 uv_lpf = 1;
 839
 840                 src_decimation = 0x21f;
 841                 if (std == V4L2_STD_PAL_60) {
 842                         vblank = 26;
 843                         vblank656 = 26;
 844                         burst = 0x5b;
 845                         luma_lpf = 2;
 846                         comb = 0x20;
 847                         sc = 688739;
 848                 } else if (std == V4L2_STD_PAL_M) {
 849                         vblank = 20;
 850                         vblank656 = 24;
 851                         burst = 0x61;
 852                         comb = 0x20;
 853                         sc = 555452;
 854                 } else {
 855                         vblank = 26;
 856                         vblank656 = 26;
 857                         burst = 0x5b;
 858                         comb = 0x66;
 859                         sc = 556063;
 860                 }
 861         }
 862
 863         /* DEBUG: Displays configured PLL frequency */
 864         if (!is_cx231xx(state)) {
 865                 pll_int = cx25840_read(client, 0x108);
 866                 pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
 867                 pll_post = cx25840_read(client, 0x109);
 868                 v4l_dbg(1, cx25840_debug, client,
 869                         "PLL regs = int: %u, frac: %u, post: %u\n",
 870                         pll_int, pll_frac, pll_post);
 871
 872                 if (pll_post) {
 873                         int fin, fsc;
 874                         int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
 875
 876                         pll /= pll_post;
 877                         v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
 878                                         pll / 1000000, pll % 1000000);
 879                         v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
 880                                         pll / 8000000, (pll / 8) % 1000000);
 881
 882                         fin = ((u64)src_decimation * pll) >> 12;
 883                         v4l_dbg(1, cx25840_debug, client,
 884                                         "ADC Sampling freq = %d.%06d MHz\n",
 885                                         fin / 1000000, fin % 1000000);
 886
 887                         fsc = (((u64)sc) * pll) >> 24L;
 888                         v4l_dbg(1, cx25840_debug, client,
 889                                         "Chroma sub-carrier freq = %d.%06d MHz\n",
 890                                         fsc / 1000000, fsc % 1000000);
 891
 892                         v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
 893                                 "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
 894                                 "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
 895                                 "sc 0x%06x\n",
 896                                 hblank, hactive, vblank, vactive, vblank656,
 897                                 src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
 898                 }
 899         }
 900
 901         /* Sets horizontal blanking delay and active lines */
 902         cx25840_write(client, 0x470, hblank);
 903         cx25840_write(client, 0x471,
 904                       (((hblank >> 8) & 0x3) | (hactive << 4)) & 0xff);
 905         cx25840_write(client, 0x472, hactive >> 4);
 906
 907         /* Sets burst gate delay */
 908         cx25840_write(client, 0x473, burst);
 909
 910         /* Sets vertical blanking delay and active duration */
 911         cx25840_write(client, 0x474, vblank);
 912         cx25840_write(client, 0x475,
 913                       (((vblank >> 8) & 0x3) | (vactive << 4)) & 0xff);
 914         cx25840_write(client, 0x476, vactive >> 4);
 915         cx25840_write(client, 0x477, vblank656);
 916
 917         /* Sets src decimation rate */
 918         cx25840_write(client, 0x478, src_decimation & 0xff);
 919         cx25840_write(client, 0x479, (src_decimation >> 8) & 0xff);
 920
 921         /* Sets Luma and UV Low pass filters */
 922         cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
 923
 924         /* Enables comb filters */
 925         cx25840_write(client, 0x47b, comb);
 926
 927         /* Sets SC Step*/
 928         cx25840_write(client, 0x47c, sc);
 929         cx25840_write(client, 0x47d, (sc >> 8) & 0xff);
 930         cx25840_write(client, 0x47e, (sc >> 16) & 0xff);
 931
 932         /* Sets VBI parameters */
 933         if (std & V4L2_STD_625_50) {
 934                 cx25840_write(client, 0x47f, 0x01);
 935                 state->vbi_line_offset = 5;
 936         } else {
 937                 cx25840_write(client, 0x47f, 0x00);
 938                 state->vbi_line_offset = 8;
 939         }
 940 }
 941
 942 /* ----------------------------------------------------------------------- */
 943
 944 static void input_change(struct i2c_client *client)
 945 {
 946         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 947         v4l2_std_id std = state->std;
 948
 949         /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
 950         if (std & V4L2_STD_SECAM) {
 951                 cx25840_write(client, 0x402, 0);
 952         }
 953         else {
 954                 cx25840_write(client, 0x402, 0x04);
 955                 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
 956         }
 957         cx25840_and_or(client, 0x401, ~0x60, 0);
 958         cx25840_and_or(client, 0x401, ~0x60, 0x60);
 959
 960         /* Don't write into audio registers on cx2583x chips */
 961         if (is_cx2583x(state))
 962                 return;
 963
 964         cx25840_and_or(client, 0x810, ~0x01, 1);
 965
 966         if (state->radio) {
 967                 cx25840_write(client, 0x808, 0xf9);
 968                 cx25840_write(client, 0x80b, 0x00);
 969         }
 970         else if (std & V4L2_STD_525_60) {
 971                 /* Certain Hauppauge PVR150 models have a hardware bug
 972                    that causes audio to drop out. For these models the
 973                    audio standard must be set explicitly.
 974                    To be precise: it affects cards with tuner models
 975                    85, 99 and 112 (model numbers from tveeprom). */
 976                 int hw_fix = state->pvr150_workaround;
 977
 978                 if (std == V4L2_STD_NTSC_M_JP) {
 979                         /* Japan uses EIAJ audio standard */
 980                         cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
 981                 } else if (std == V4L2_STD_NTSC_M_KR) {
 982                         /* South Korea uses A2 audio standard */
 983                         cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
 984                 } else {
 985                         /* Others use the BTSC audio standard */
 986                         cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
 987                 }
 988                 cx25840_write(client, 0x80b, 0x00);
 989         } else if (std & V4L2_STD_PAL) {
 990                 /* Autodetect audio standard and audio system */
 991                 cx25840_write(client, 0x808, 0xff);
 992                 /* Since system PAL-L is pretty much non-existent and
 993                    not used by any public broadcast network, force
 994                    6.5 MHz carrier to be interpreted as System DK,
 995                    this avoids DK audio detection instability */
 996                 cx25840_write(client, 0x80b, 0x00);
 997         } else if (std & V4L2_STD_SECAM) {
 998                 /* Autodetect audio standard and audio system */
 999                 cx25840_write(client, 0x808, 0xff);
1000                 /* If only one of SECAM-DK / SECAM-L is required, then force
1001                   6.5MHz carrier, else autodetect it */
1002                 if ((std & V4L2_STD_SECAM_DK) &&
1003                     !(std & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC))) {
1004                         /* 6.5 MHz carrier to be interpreted as System DK */
1005                         cx25840_write(client, 0x80b, 0x00);
1006                } else if (!(std & V4L2_STD_SECAM_DK) &&
1007                           (std & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC))) {
1008                         /* 6.5 MHz carrier to be interpreted as System L */
1009                         cx25840_write(client, 0x80b, 0x08);
1010                } else {
1011                         /* 6.5 MHz carrier to be autodetected */
1012                         cx25840_write(client, 0x80b, 0x10);
1013                }
1014         }
1015
1016         cx25840_and_or(client, 0x810, ~0x01, 0);
1017 }
1018
1019 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
1020                                                 enum cx25840_audio_input aud_input)
1021 {
1022         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1023         u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
1024                            vid_input <= CX25840_COMPOSITE8);
1025         u8 is_component = (vid_input & CX25840_COMPONENT_ON) ==
1026                         CX25840_COMPONENT_ON;
1027         u8 is_dif = (vid_input & CX25840_DIF_ON) ==
1028                         CX25840_DIF_ON;
1029         u8 is_svideo = (vid_input & CX25840_SVIDEO_ON) ==
1030                         CX25840_SVIDEO_ON;
1031         int luma = vid_input & 0xf0;
1032         int chroma = vid_input & 0xf00;
1033         u8 reg;
1034         u32 val;
1035
1036         v4l_dbg(1, cx25840_debug, client,
1037                 "decoder set video input %d, audio input %d\n",
1038                 vid_input, aud_input);
1039
1040         if (vid_input >= CX25840_VIN1_CH1) {
1041                 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
1042                         vid_input);
1043                 reg = vid_input & 0xff;
1044                 is_composite = !is_component &&
1045                         ((vid_input & CX25840_SVIDEO_ON) != CX25840_SVIDEO_ON);
1046
1047                 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
1048                         reg, is_composite);
1049         } else if (is_composite) {
1050                 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
1051         } else {
1052                 if ((vid_input & ~0xff0) ||
1053                     luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
1054                     chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
1055                         v4l_err(client, "0x%04x is not a valid video input!\n",
1056                                 vid_input);
1057                         return -EINVAL;
1058                 }
1059                 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
1060                 if (chroma >= CX25840_SVIDEO_CHROMA7) {
1061                         reg &= 0x3f;
1062                         reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
1063                 } else {
1064                         reg &= 0xcf;
1065                         reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
1066                 }
1067         }
1068
1069         /* The caller has previously prepared the correct routing
1070          * configuration in reg (for the cx23885) so we have no
1071          * need to attempt to flip bits for earlier av decoders.
1072          */
1073         if (!is_cx2388x(state) && !is_cx231xx(state)) {
1074                 switch (aud_input) {
1075                 case CX25840_AUDIO_SERIAL:
1076                         /* do nothing, use serial audio input */
1077                         break;
1078                 case CX25840_AUDIO4: reg &= ~0x30; break;
1079                 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
1080                 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
1081                 case CX25840_AUDIO7: reg &= ~0xc0; break;
1082                 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
1083
1084                 default:
1085                         v4l_err(client, "0x%04x is not a valid audio input!\n",
1086                                 aud_input);
1087                         return -EINVAL;
1088                 }
1089         }
1090
1091         cx25840_write(client, 0x103, reg);
1092
1093         /* Set INPUT_MODE to Composite, S-Video or Component */
1094         if (is_component)
1095                 cx25840_and_or(client, 0x401, ~0x6, 0x6);
1096         else
1097                 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
1098
1099         if (is_cx2388x(state)) {
1100
1101                 /* Enable or disable the DIF for tuner use */
1102                 if (is_dif) {
1103                         cx25840_and_or(client, 0x102, ~0x80, 0x80);
1104
1105                         /* Set of defaults for NTSC and PAL */
1106                         cx25840_write4(client, 0x31c, 0xc2262600);
1107                         cx25840_write4(client, 0x320, 0xc2262600);
1108
1109                         /* 18271 IF - Nobody else yet uses a different
1110                          * tuner with the DIF, so these are reasonable
1111                          * assumptions (HVR1250 and HVR1850 specific).
1112                          */
1113                         cx25840_write4(client, 0x318, 0xda262600);
1114                         cx25840_write4(client, 0x33c, 0x2a24c800);
1115                         cx25840_write4(client, 0x104, 0x0704dd00);
1116                 } else {
1117                         cx25840_write4(client, 0x300, 0x015c28f5);
1118
1119                         cx25840_and_or(client, 0x102, ~0x80, 0);
1120                         cx25840_write4(client, 0x340, 0xdf7df83);
1121                         cx25840_write4(client, 0x104, 0x0704dd80);
1122                         cx25840_write4(client, 0x314, 0x22400600);
1123                         cx25840_write4(client, 0x318, 0x40002600);
1124                         cx25840_write4(client, 0x324, 0x40002600);
1125                         cx25840_write4(client, 0x32c, 0x0250e620);
1126                         cx25840_write4(client, 0x39c, 0x01FF0B00);
1127
1128                         cx25840_write4(client, 0x410, 0xffff0dbf);
1129                         cx25840_write4(client, 0x414, 0x00137d03);
1130
1131                         /* on the 887, 0x418 is HSCALE_CTRL, on the 888 it is
1132                            CHROMA_CTRL */
1133                         if (is_cx23888(state))
1134                                 cx25840_write4(client, 0x418, 0x01008080);
1135                         else
1136                                 cx25840_write4(client, 0x418, 0x01000000);
1137
1138                         cx25840_write4(client, 0x41c, 0x00000000);
1139
1140                         /* on the 887, 0x420 is CHROMA_CTRL, on the 888 it is
1141                            CRUSH_CTRL */
1142                         if (is_cx23888(state))
1143                                 cx25840_write4(client, 0x420, 0x001c3e0f);
1144                         else
1145                                 cx25840_write4(client, 0x420, 0x001c8282);
1146
1147                         cx25840_write4(client, 0x42c, 0x42600000);
1148                         cx25840_write4(client, 0x430, 0x0000039b);
1149                         cx25840_write4(client, 0x438, 0x00000000);
1150
1151                         cx25840_write4(client, 0x440, 0xF8E3E824);
1152                         cx25840_write4(client, 0x444, 0x401040dc);
1153                         cx25840_write4(client, 0x448, 0xcd3f02a0);
1154                         cx25840_write4(client, 0x44c, 0x161f1000);
1155                         cx25840_write4(client, 0x450, 0x00000802);
1156
1157                         cx25840_write4(client, 0x91c, 0x01000000);
1158                         cx25840_write4(client, 0x8e0, 0x03063870);
1159                         cx25840_write4(client, 0x8d4, 0x7FFF0024);
1160                         cx25840_write4(client, 0x8d0, 0x00063073);
1161
1162                         cx25840_write4(client, 0x8c8, 0x00010000);
1163                         cx25840_write4(client, 0x8cc, 0x00080023);
1164
1165                         /* DIF BYPASS */
1166                         cx25840_write4(client, 0x33c, 0x2a04c800);
1167                 }
1168
1169                 /* Reset the DIF */
1170                 cx25840_write4(client, 0x398, 0);
1171         }
1172
1173         if (!is_cx2388x(state) && !is_cx231xx(state)) {
1174                 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
1175                 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
1176                 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
1177                 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
1178                         cx25840_and_or(client, 0x102, ~0x4, 4);
1179                 else
1180                         cx25840_and_or(client, 0x102, ~0x4, 0);
1181         } else {
1182                 /* Set DUAL_MODE_ADC2 to 1 if component*/
1183                 cx25840_and_or(client, 0x102, ~0x4, is_component ? 0x4 : 0x0);
1184                 if (is_composite) {
1185                         /* ADC2 input select channel 2 */
1186                         cx25840_and_or(client, 0x102, ~0x2, 0);
1187                 } else if (!is_component) {
1188                         /* S-Video */
1189                         if (chroma >= CX25840_SVIDEO_CHROMA7) {
1190                                 /* ADC2 input select channel 3 */
1191                                 cx25840_and_or(client, 0x102, ~0x2, 2);
1192                         } else {
1193                                 /* ADC2 input select channel 2 */
1194                                 cx25840_and_or(client, 0x102, ~0x2, 0);
1195                         }
1196                 }
1197
1198                 /* cx23885 / SVIDEO */
1199                 if (is_cx2388x(state) && is_svideo) {
1200 #define AFE_CTRL  (0x104)
1201 #define MODE_CTRL (0x400)
1202                         cx25840_and_or(client, 0x102, ~0x2, 0x2);
1203
1204                         val = cx25840_read4(client, MODE_CTRL);
1205                         val &= 0xFFFFF9FF;
1206
1207                         /* YC */
1208                         val |= 0x00000200;
1209                         val &= ~0x2000;
1210                         cx25840_write4(client, MODE_CTRL, val);
1211
1212                         val = cx25840_read4(client, AFE_CTRL);
1213
1214                         /* Chroma in select */
1215                         val |= 0x00001000;
1216                         val &= 0xfffffe7f;
1217                         /* Clear VGA_SEL_CH2 and VGA_SEL_CH3 (bits 7 and 8).
1218                          * This sets them to use video rather than audio.
1219                          * Only one of the two will be in use.
1220                          */
1221                         cx25840_write4(client, AFE_CTRL, val);
1222                 } else
1223                         cx25840_and_or(client, 0x102, ~0x2, 0);
1224         }
1225
1226         state->vid_input = vid_input;
1227         state->aud_input = aud_input;
1228         cx25840_audio_set_path(client);
1229         input_change(client);
1230
1231         if (is_cx2388x(state)) {
1232                 /* Audio channel 1 src : Parallel 1 */
1233                 cx25840_write(client, 0x124, 0x03);
1234
1235                 /* Select AFE clock pad output source */
1236                 cx25840_write(client, 0x144, 0x05);
1237
1238                 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
1239                 cx25840_write(client, 0x914, 0xa0);
1240
1241                 /* I2S_OUT_CTL:
1242                  * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
1243                  * I2S_OUT_MASTER_MODE = Master
1244                  */
1245                 cx25840_write(client, 0x918, 0xa0);
1246                 cx25840_write(client, 0x919, 0x01);
1247         } else if (is_cx231xx(state)) {
1248                 /* Audio channel 1 src : Parallel 1 */
1249                 cx25840_write(client, 0x124, 0x03);
1250
1251                 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
1252                 cx25840_write(client, 0x914, 0xa0);
1253
1254                 /* I2S_OUT_CTL:
1255                  * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
1256                  * I2S_OUT_MASTER_MODE = Master
1257                  */
1258                 cx25840_write(client, 0x918, 0xa0);
1259                 cx25840_write(client, 0x919, 0x01);
1260         }
1261
1262         if (is_cx2388x(state) && ((aud_input == CX25840_AUDIO7) ||
1263                 (aud_input == CX25840_AUDIO6))) {
1264                 /* Configure audio from LR1 or LR2 input */
1265                 cx25840_write4(client, 0x910, 0);
1266                 cx25840_write4(client, 0x8d0, 0x63073);
1267         } else
1268         if (is_cx2388x(state) && (aud_input == CX25840_AUDIO8)) {
1269                 /* Configure audio from tuner/sif input */
1270                 cx25840_write4(client, 0x910, 0x12b000c9);
1271                 cx25840_write4(client, 0x8d0, 0x1f063870);
1272         }
1273
1274         if (is_cx23888(state)) {
1275                 /* HVR1850 */
1276                 /* AUD_IO_CTRL - I2S Input, Parallel1*/
1277                 /*  - Channel 1 src - Parallel1 (Merlin out) */
1278                 /*  - Channel 2 src - Parallel2 (Merlin out) */
1279                 /*  - Channel 3 src - Parallel3 (Merlin AC97 out) */
1280                 /*  - I2S source and dir - Merlin, output */
1281                 cx25840_write4(client, 0x124, 0x100);
1282
1283                 if (!is_dif) {
1284                         /* Stop microcontroller if we don't need it
1285                          * to avoid audio popping on svideo/composite use.
1286                          */
1287                         cx25840_and_or(client, 0x803, ~0x10, 0x00);
1288                 }
1289         }
1290
1291         return 0;
1292 }
1293
1294 /* ----------------------------------------------------------------------- */
1295
1296 static int set_v4lstd(struct i2c_client *client)
1297 {
1298         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1299         u8 fmt = 0;     /* zero is autodetect */
1300         u8 pal_m = 0;
1301
1302         /* First tests should be against specific std */
1303         if (state->std == V4L2_STD_NTSC_M_JP) {
1304                 fmt = 0x2;
1305         } else if (state->std == V4L2_STD_NTSC_443) {
1306                 fmt = 0x3;
1307         } else if (state->std == V4L2_STD_PAL_M) {
1308                 pal_m = 1;
1309                 fmt = 0x5;
1310         } else if (state->std == V4L2_STD_PAL_N) {
1311                 fmt = 0x6;
1312         } else if (state->std == V4L2_STD_PAL_Nc) {
1313                 fmt = 0x7;
1314         } else if (state->std == V4L2_STD_PAL_60) {
1315                 fmt = 0x8;
1316         } else {
1317                 /* Then, test against generic ones */
1318                 if (state->std & V4L2_STD_NTSC)
1319                         fmt = 0x1;
1320                 else if (state->std & V4L2_STD_PAL)
1321                         fmt = 0x4;
1322                 else if (state->std & V4L2_STD_SECAM)
1323                         fmt = 0xc;
1324         }
1325
1326         v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
1327
1328         /* Follow step 9 of section 3.16 in the cx25840 datasheet.
1329            Without this PAL may display a vertical ghosting effect.
1330            This happens for example with the Yuan MPC622. */
1331         if (fmt >= 4 && fmt < 8) {
1332                 /* Set format to NTSC-M */
1333                 cx25840_and_or(client, 0x400, ~0xf, 1);
1334                 /* Turn off LCOMB */
1335                 cx25840_and_or(client, 0x47b, ~6, 0);
1336         }
1337         cx25840_and_or(client, 0x400, ~0xf, fmt);
1338         cx25840_and_or(client, 0x403, ~0x3, pal_m);
1339         if (is_cx23888(state))
1340                 cx23888_std_setup(client);
1341         else
1342                 cx25840_std_setup(client);
1343         if (!is_cx2583x(state))
1344                 input_change(client);
1345         return 0;
1346 }
1347
1348 /* ----------------------------------------------------------------------- */
1349
1350 static int cx25840_s_ctrl(struct v4l2_ctrl *ctrl)
1351 {
1352         struct v4l2_subdev *sd = to_sd(ctrl);
1353         struct cx25840_state *state = to_state(sd);
1354         struct i2c_client *client = v4l2_get_subdevdata(sd);
1355
1356         switch (ctrl->id) {
1357         case V4L2_CID_BRIGHTNESS:
1358                 cx25840_write(client, 0x414, ctrl->val - 128);
1359                 break;
1360
1361         case V4L2_CID_CONTRAST:
1362                 cx25840_write(client, 0x415, ctrl->val << 1);
1363                 break;
1364
1365         case V4L2_CID_SATURATION:
1366                 if (is_cx23888(state)) {
1367                         cx25840_write(client, 0x418, ctrl->val << 1);
1368                         cx25840_write(client, 0x419, ctrl->val << 1);
1369                 } else {
1370                         cx25840_write(client, 0x420, ctrl->val << 1);
1371                         cx25840_write(client, 0x421, ctrl->val << 1);
1372                 }
1373                 break;
1374
1375         case V4L2_CID_HUE:
1376                 if (is_cx23888(state))
1377                         cx25840_write(client, 0x41a, ctrl->val);
1378                 else
1379                         cx25840_write(client, 0x422, ctrl->val);
1380                 break;
1381
1382         default:
1383                 return -EINVAL;
1384         }
1385
1386         return 0;
1387 }
1388
1389 /* ----------------------------------------------------------------------- */
1390
1391 static int cx25840_set_fmt(struct v4l2_subdev *sd,
1392                 struct v4l2_subdev_pad_config *cfg,
1393                 struct v4l2_subdev_format *format)
1394 {
1395         struct v4l2_mbus_framefmt *fmt = &format->format;
1396         struct cx25840_state *state = to_state(sd);
1397         struct i2c_client *client = v4l2_get_subdevdata(sd);
1398         int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
1399         int is_50Hz = !(state->std & V4L2_STD_525_60);
1400
1401         if (format->pad || fmt->code != MEDIA_BUS_FMT_FIXED)
1402                 return -EINVAL;
1403
1404         fmt->field = V4L2_FIELD_INTERLACED;
1405         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
1406
1407         if (is_cx23888(state)) {
1408                 Vsrc = (cx25840_read(client, 0x42a) & 0x3f) << 4;
1409                 Vsrc |= (cx25840_read(client, 0x429) & 0xf0) >> 4;
1410         } else {
1411                 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
1412                 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
1413         }
1414
1415         if (is_cx23888(state)) {
1416                 Hsrc = (cx25840_read(client, 0x426) & 0x3f) << 4;
1417                 Hsrc |= (cx25840_read(client, 0x425) & 0xf0) >> 4;
1418         } else {
1419                 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
1420                 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
1421         }
1422
1423         Vlines = fmt->height + (is_50Hz ? 4 : 7);
1424
1425         if ((fmt->width * 16 < Hsrc) || (Hsrc < fmt->width) ||
1426                         (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
1427                 v4l_err(client, "%dx%d is not a valid size!\n",
1428                                 fmt->width, fmt->height);
1429                 return -ERANGE;
1430         }
1431         if (format->which == V4L2_SUBDEV_FORMAT_TRY)
1432                 return 0;
1433
1434         HSC = (Hsrc * (1 << 20)) / fmt->width - (1 << 20);
1435         VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
1436         VSC &= 0x1fff;
1437
1438         if (fmt->width >= 385)
1439                 filter = 0;
1440         else if (fmt->width > 192)
1441                 filter = 1;
1442         else if (fmt->width > 96)
1443                 filter = 2;
1444         else
1445                 filter = 3;
1446
1447         v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale  %ux%u\n",
1448                         fmt->width, fmt->height, HSC, VSC);
1449
1450         /* HSCALE=HSC */
1451         cx25840_write(client, 0x418, HSC & 0xff);
1452         cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
1453         cx25840_write(client, 0x41a, HSC >> 16);
1454         /* VSCALE=VSC */
1455         cx25840_write(client, 0x41c, VSC & 0xff);
1456         cx25840_write(client, 0x41d, VSC >> 8);
1457         /* VS_INTRLACE=1 VFILT=filter */
1458         cx25840_write(client, 0x41e, 0x8 | filter);
1459         return 0;
1460 }
1461
1462 /* ----------------------------------------------------------------------- */
1463
1464 static void log_video_status(struct i2c_client *client)
1465 {
1466         static const char *const fmt_strs[] = {
1467                 "0x0",
1468                 "NTSC-M", "NTSC-J", "NTSC-4.43",
1469                 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
1470                 "0x9", "0xA", "0xB",
1471                 "SECAM",
1472                 "0xD", "0xE", "0xF"
1473         };
1474
1475         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1476         u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
1477         u8 gen_stat1 = cx25840_read(client, 0x40d);
1478         u8 gen_stat2 = cx25840_read(client, 0x40e);
1479         int vid_input = state->vid_input;
1480
1481         v4l_info(client, "Video signal:              %spresent\n",
1482                     (gen_stat2 & 0x20) ? "" : "not ");
1483         v4l_info(client, "Detected format:           %s\n",
1484                     fmt_strs[gen_stat1 & 0xf]);
1485
1486         v4l_info(client, "Specified standard:        %s\n",
1487                     vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
1488
1489         if (vid_input >= CX25840_COMPOSITE1 &&
1490             vid_input <= CX25840_COMPOSITE8) {
1491                 v4l_info(client, "Specified video input:     Composite %d\n",
1492                         vid_input - CX25840_COMPOSITE1 + 1);
1493         } else {
1494                 v4l_info(client, "Specified video input:     S-Video (Luma In%d, Chroma In%d)\n",
1495                         (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
1496         }
1497
1498         v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
1499 }
1500
1501 /* ----------------------------------------------------------------------- */
1502
1503 static void log_audio_status(struct i2c_client *client)
1504 {
1505         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1506         u8 download_ctl = cx25840_read(client, 0x803);
1507         u8 mod_det_stat0 = cx25840_read(client, 0x804);
1508         u8 mod_det_stat1 = cx25840_read(client, 0x805);
1509         u8 audio_config = cx25840_read(client, 0x808);
1510         u8 pref_mode = cx25840_read(client, 0x809);
1511         u8 afc0 = cx25840_read(client, 0x80b);
1512         u8 mute_ctl = cx25840_read(client, 0x8d3);
1513         int aud_input = state->aud_input;
1514         char *p;
1515
1516         switch (mod_det_stat0) {
1517         case 0x00: p = "mono"; break;
1518         case 0x01: p = "stereo"; break;
1519         case 0x02: p = "dual"; break;
1520         case 0x04: p = "tri"; break;
1521         case 0x10: p = "mono with SAP"; break;
1522         case 0x11: p = "stereo with SAP"; break;
1523         case 0x12: p = "dual with SAP"; break;
1524         case 0x14: p = "tri with SAP"; break;
1525         case 0xfe: p = "forced mode"; break;
1526         default: p = "not defined";
1527         }
1528         v4l_info(client, "Detected audio mode:       %s\n", p);
1529
1530         switch (mod_det_stat1) {
1531         case 0x00: p = "not defined"; break;
1532         case 0x01: p = "EIAJ"; break;
1533         case 0x02: p = "A2-M"; break;
1534         case 0x03: p = "A2-BG"; break;
1535         case 0x04: p = "A2-DK1"; break;
1536         case 0x05: p = "A2-DK2"; break;
1537         case 0x06: p = "A2-DK3"; break;
1538         case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
1539         case 0x08: p = "AM-L"; break;
1540         case 0x09: p = "NICAM-BG"; break;
1541         case 0x0a: p = "NICAM-DK"; break;
1542         case 0x0b: p = "NICAM-I"; break;
1543         case 0x0c: p = "NICAM-L"; break;
1544         case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
1545         case 0x0e: p = "IF FM Radio"; break;
1546         case 0x0f: p = "BTSC"; break;
1547         case 0x10: p = "high-deviation FM"; break;
1548         case 0x11: p = "very high-deviation FM"; break;
1549         case 0xfd: p = "unknown audio standard"; break;
1550         case 0xfe: p = "forced audio standard"; break;
1551         case 0xff: p = "no detected audio standard"; break;
1552         default: p = "not defined";
1553         }
1554         v4l_info(client, "Detected audio standard:   %s\n", p);
1555         v4l_info(client, "Audio microcontroller:     %s\n",
1556                     (download_ctl & 0x10) ?
1557                                 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1558
1559         switch (audio_config >> 4) {
1560         case 0x00: p = "undefined"; break;
1561         case 0x01: p = "BTSC"; break;
1562         case 0x02: p = "EIAJ"; break;
1563         case 0x03: p = "A2-M"; break;
1564         case 0x04: p = "A2-BG"; break;
1565         case 0x05: p = "A2-DK1"; break;
1566         case 0x06: p = "A2-DK2"; break;
1567         case 0x07: p = "A2-DK3"; break;
1568         case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1569         case 0x09: p = "AM-L"; break;
1570         case 0x0a: p = "NICAM-BG"; break;
1571         case 0x0b: p = "NICAM-DK"; break;
1572         case 0x0c: p = "NICAM-I"; break;
1573         case 0x0d: p = "NICAM-L"; break;
1574         case 0x0e: p = "FM radio"; break;
1575         case 0x0f: p = "automatic detection"; break;
1576         default: p = "undefined";
1577         }
1578         v4l_info(client, "Configured audio standard: %s\n", p);
1579
1580         if ((audio_config >> 4) < 0xF) {
1581                 switch (audio_config & 0xF) {
1582                 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1583                 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1584                 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1585                 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1586                 case 0x04: p = "STEREO"; break;
1587                 case 0x05: p = "DUAL1 (AB)"; break;
1588                 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1589                 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1590                 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1591                 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1592                 case 0x0a: p = "SAP"; break;
1593                 default: p = "undefined";
1594                 }
1595                 v4l_info(client, "Configured audio mode:     %s\n", p);
1596         } else {
1597                 switch (audio_config & 0xF) {
1598                 case 0x00: p = "BG"; break;
1599                 case 0x01: p = "DK1"; break;
1600                 case 0x02: p = "DK2"; break;
1601                 case 0x03: p = "DK3"; break;
1602                 case 0x04: p = "I"; break;
1603                 case 0x05: p = "L"; break;
1604                 case 0x06: p = "BTSC"; break;
1605                 case 0x07: p = "EIAJ"; break;
1606                 case 0x08: p = "A2-M"; break;
1607                 case 0x09: p = "FM Radio"; break;
1608                 case 0x0f: p = "automatic standard and mode detection"; break;
1609                 default: p = "undefined";
1610                 }
1611                 v4l_info(client, "Configured audio system:   %s\n", p);
1612         }
1613
1614         if (aud_input) {
1615                 v4l_info(client, "Specified audio input:     Tuner (In%d)\n", aud_input);
1616         } else {
1617                 v4l_info(client, "Specified audio input:     External\n");
1618         }
1619
1620         switch (pref_mode & 0xf) {
1621         case 0: p = "mono/language A"; break;
1622         case 1: p = "language B"; break;
1623         case 2: p = "language C"; break;
1624         case 3: p = "analog fallback"; break;
1625         case 4: p = "stereo"; break;
1626         case 5: p = "language AC"; break;
1627         case 6: p = "language BC"; break;
1628         case 7: p = "language AB"; break;
1629         default: p = "undefined";
1630         }
1631         v4l_info(client, "Preferred audio mode:      %s\n", p);
1632
1633         if ((audio_config & 0xf) == 0xf) {
1634                 switch ((afc0 >> 3) & 0x3) {
1635                 case 0: p = "system DK"; break;
1636                 case 1: p = "system L"; break;
1637                 case 2: p = "autodetect"; break;
1638                 default: p = "undefined";
1639                 }
1640                 v4l_info(client, "Selected 65 MHz format:    %s\n", p);
1641
1642                 switch (afc0 & 0x7) {
1643                 case 0: p = "chroma"; break;
1644                 case 1: p = "BTSC"; break;
1645                 case 2: p = "EIAJ"; break;
1646                 case 3: p = "A2-M"; break;
1647                 case 4: p = "autodetect"; break;
1648                 default: p = "undefined";
1649                 }
1650                 v4l_info(client, "Selected 45 MHz format:    %s\n", p);
1651         }
1652 }
1653
1654 /* ----------------------------------------------------------------------- */
1655
1656 /* This load_fw operation must be called to load the driver's firmware.
1657    Without this the audio standard detection will fail and you will
1658    only get mono.
1659
1660    Since loading the firmware is often problematic when the driver is
1661    compiled into the kernel I recommend postponing calling this function
1662    until the first open of the video device. Another reason for
1663    postponing it is that loading this firmware takes a long time (seconds)
1664    due to the slow i2c bus speed. So it will speed up the boot process if
1665    you can avoid loading the fw as long as the video device isn't used.  */
1666 static int cx25840_load_fw(struct v4l2_subdev *sd)
1667 {
1668         struct cx25840_state *state = to_state(sd);
1669         struct i2c_client *client = v4l2_get_subdevdata(sd);
1670
1671         if (!state->is_initialized) {
1672                 /* initialize and load firmware */
1673                 state->is_initialized = 1;
1674                 if (is_cx2583x(state))
1675                         cx25836_initialize(client);
1676                 else if (is_cx2388x(state))
1677                         cx23885_initialize(client);
1678                 else if (is_cx231xx(state))
1679                         cx231xx_initialize(client);
1680                 else
1681                         cx25840_initialize(client);
1682         }
1683         return 0;
1684 }
1685
1686 #ifdef CONFIG_VIDEO_ADV_DEBUG
1687 static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1688 {
1689         struct i2c_client *client = v4l2_get_subdevdata(sd);
1690
1691         reg->size = 1;
1692         reg->val = cx25840_read(client, reg->reg & 0x0fff);
1693         return 0;
1694 }
1695
1696 static int cx25840_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
1697 {
1698         struct i2c_client *client = v4l2_get_subdevdata(sd);
1699
1700         cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1701         return 0;
1702 }
1703 #endif
1704
1705 static int cx25840_s_audio_stream(struct v4l2_subdev *sd, int enable)
1706 {
1707         struct cx25840_state *state = to_state(sd);
1708         struct i2c_client *client = v4l2_get_subdevdata(sd);
1709         u8 v;
1710
1711         if (is_cx2583x(state) || is_cx2388x(state) || is_cx231xx(state))
1712                 return 0;
1713
1714         v4l_dbg(1, cx25840_debug, client, "%s audio output\n",
1715                         enable ? "enable" : "disable");
1716
1717         if (enable) {
1718                 v = cx25840_read(client, 0x115) | 0x80;
1719                 cx25840_write(client, 0x115, v);
1720                 v = cx25840_read(client, 0x116) | 0x03;
1721                 cx25840_write(client, 0x116, v);
1722         } else {
1723                 v = cx25840_read(client, 0x115) & ~(0x80);
1724                 cx25840_write(client, 0x115, v);
1725                 v = cx25840_read(client, 0x116) & ~(0x03);
1726                 cx25840_write(client, 0x116, v);
1727         }
1728         return 0;
1729 }
1730
1731 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1732 {
1733         struct cx25840_state *state = to_state(sd);
1734         struct i2c_client *client = v4l2_get_subdevdata(sd);
1735         u8 v;
1736
1737         v4l_dbg(1, cx25840_debug, client, "%s video output\n",
1738                         enable ? "enable" : "disable");
1739         if (enable) {
1740                 if (is_cx2388x(state) || is_cx231xx(state)) {
1741                         v = cx25840_read(client, 0x421) | 0x0b;
1742                         cx25840_write(client, 0x421, v);
1743                 } else {
1744                         v = cx25840_read(client, 0x115) | 0x0c;
1745                         cx25840_write(client, 0x115, v);
1746                         v = cx25840_read(client, 0x116) | 0x04;
1747                         cx25840_write(client, 0x116, v);
1748                 }
1749         } else {
1750                 if (is_cx2388x(state) || is_cx231xx(state)) {
1751                         v = cx25840_read(client, 0x421) & ~(0x0b);
1752                         cx25840_write(client, 0x421, v);
1753                 } else {
1754                         v = cx25840_read(client, 0x115) & ~(0x0c);
1755                         cx25840_write(client, 0x115, v);
1756                         v = cx25840_read(client, 0x116) & ~(0x04);
1757                         cx25840_write(client, 0x116, v);
1758                 }
1759         }
1760         return 0;
1761 }
1762
1763 /* Query the current detected video format */
1764 static int cx25840_g_std(struct v4l2_subdev *sd, v4l2_std_id *std)
1765 {
1766         struct i2c_client *client = v4l2_get_subdevdata(sd);
1767
1768         v4l2_std_id stds[] = {
1769                 /* 0000 */ V4L2_STD_UNKNOWN,
1770
1771                 /* 0001 */ V4L2_STD_NTSC_M,
1772                 /* 0010 */ V4L2_STD_NTSC_M_JP,
1773                 /* 0011 */ V4L2_STD_NTSC_443,
1774                 /* 0100 */ V4L2_STD_PAL,
1775                 /* 0101 */ V4L2_STD_PAL_M,
1776                 /* 0110 */ V4L2_STD_PAL_N,
1777                 /* 0111 */ V4L2_STD_PAL_Nc,
1778                 /* 1000 */ V4L2_STD_PAL_60,
1779
1780                 /* 1001 */ V4L2_STD_UNKNOWN,
1781                 /* 1010 */ V4L2_STD_UNKNOWN,
1782                 /* 1001 */ V4L2_STD_UNKNOWN,
1783                 /* 1010 */ V4L2_STD_UNKNOWN,
1784                 /* 1011 */ V4L2_STD_UNKNOWN,
1785                 /* 1110 */ V4L2_STD_UNKNOWN,
1786                 /* 1111 */ V4L2_STD_UNKNOWN
1787         };
1788
1789         u32 fmt = (cx25840_read4(client, 0x40c) >> 8) & 0xf;
1790         *std = stds[ fmt ];
1791
1792         v4l_dbg(1, cx25840_debug, client, "g_std fmt = %x, v4l2_std_id = 0x%x\n",
1793                 fmt, (unsigned int)stds[ fmt ]);
1794
1795         return 0;
1796 }
1797
1798 static int cx25840_g_input_status(struct v4l2_subdev *sd, u32 *status)
1799 {
1800         struct i2c_client *client = v4l2_get_subdevdata(sd);
1801
1802         /* A limited function that checks for signal status and returns
1803          * the state.
1804          */
1805
1806         /* Check for status of Horizontal lock (SRC lock isn't reliable) */
1807         if ((cx25840_read4(client, 0x40c) & 0x00010000) == 0)
1808                 *status |= V4L2_IN_ST_NO_SIGNAL;
1809
1810         return 0;
1811 }
1812
1813 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1814 {
1815         struct cx25840_state *state = to_state(sd);
1816         struct i2c_client *client = v4l2_get_subdevdata(sd);
1817
1818         if (state->radio == 0 && state->std == std)
1819                 return 0;
1820         state->radio = 0;
1821         state->std = std;
1822         return set_v4lstd(client);
1823 }
1824
1825 static int cx25840_s_radio(struct v4l2_subdev *sd)
1826 {
1827         struct cx25840_state *state = to_state(sd);
1828
1829         state->radio = 1;
1830         return 0;
1831 }
1832
1833 static int cx25840_s_video_routing(struct v4l2_subdev *sd,
1834                                    u32 input, u32 output, u32 config)
1835 {
1836         struct cx25840_state *state = to_state(sd);
1837         struct i2c_client *client = v4l2_get_subdevdata(sd);
1838
1839         if (is_cx23888(state))
1840                 cx23888_std_setup(client);
1841
1842         return set_input(client, input, state->aud_input);
1843 }
1844
1845 static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
1846                                    u32 input, u32 output, u32 config)
1847 {
1848         struct cx25840_state *state = to_state(sd);
1849         struct i2c_client *client = v4l2_get_subdevdata(sd);
1850
1851         if (is_cx23888(state))
1852                 cx23888_std_setup(client);
1853         return set_input(client, state->vid_input, input);
1854 }
1855
1856 static int cx25840_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *freq)
1857 {
1858         struct i2c_client *client = v4l2_get_subdevdata(sd);
1859
1860         input_change(client);
1861         return 0;
1862 }
1863
1864 static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1865 {
1866         struct cx25840_state *state = to_state(sd);
1867         struct i2c_client *client = v4l2_get_subdevdata(sd);
1868         u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1869         u8 mode;
1870         int val = 0;
1871
1872         if (state->radio)
1873                 return 0;
1874
1875         vt->signal = vpres ? 0xffff : 0x0;
1876         if (is_cx2583x(state))
1877                 return 0;
1878
1879         vt->capability |=
1880                 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1881                 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1882
1883         mode = cx25840_read(client, 0x804);
1884
1885         /* get rxsubchans and audmode */
1886         if ((mode & 0xf) == 1)
1887                 val |= V4L2_TUNER_SUB_STEREO;
1888         else
1889                 val |= V4L2_TUNER_SUB_MONO;
1890
1891         if (mode == 2 || mode == 4)
1892                 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1893
1894         if (mode & 0x10)
1895                 val |= V4L2_TUNER_SUB_SAP;
1896
1897         vt->rxsubchans = val;
1898         vt->audmode = state->audmode;
1899         return 0;
1900 }
1901
1902 static int cx25840_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1903 {
1904         struct cx25840_state *state = to_state(sd);
1905         struct i2c_client *client = v4l2_get_subdevdata(sd);
1906
1907         if (state->radio || is_cx2583x(state))
1908                 return 0;
1909
1910         switch (vt->audmode) {
1911                 case V4L2_TUNER_MODE_MONO:
1912                         /* mono      -> mono
1913                            stereo    -> mono
1914                            bilingual -> lang1 */
1915                         cx25840_and_or(client, 0x809, ~0xf, 0x00);
1916                         break;
1917                 case V4L2_TUNER_MODE_STEREO:
1918                 case V4L2_TUNER_MODE_LANG1:
1919                         /* mono      -> mono
1920                            stereo    -> stereo
1921                            bilingual -> lang1 */
1922                         cx25840_and_or(client, 0x809, ~0xf, 0x04);
1923                         break;
1924                 case V4L2_TUNER_MODE_LANG1_LANG2:
1925                         /* mono      -> mono
1926                            stereo    -> stereo
1927                            bilingual -> lang1/lang2 */
1928                         cx25840_and_or(client, 0x809, ~0xf, 0x07);
1929                         break;
1930                 case V4L2_TUNER_MODE_LANG2:
1931                         /* mono      -> mono
1932                            stereo    -> stereo
1933                            bilingual -> lang2 */
1934                         cx25840_and_or(client, 0x809, ~0xf, 0x01);
1935                         break;
1936                 default:
1937                         return -EINVAL;
1938         }
1939         state->audmode = vt->audmode;
1940         return 0;
1941 }
1942
1943 static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1944 {
1945         struct cx25840_state *state = to_state(sd);
1946         struct i2c_client *client = v4l2_get_subdevdata(sd);
1947
1948         if (is_cx2583x(state))
1949                 cx25836_initialize(client);
1950         else if (is_cx2388x(state))
1951                 cx23885_initialize(client);
1952         else if (is_cx231xx(state))
1953                 cx231xx_initialize(client);
1954         else
1955                 cx25840_initialize(client);
1956         return 0;
1957 }
1958
1959 static int cx25840_log_status(struct v4l2_subdev *sd)
1960 {
1961         struct cx25840_state *state = to_state(sd);
1962         struct i2c_client *client = v4l2_get_subdevdata(sd);
1963
1964         log_video_status(client);
1965         if (!is_cx2583x(state))
1966                 log_audio_status(client);
1967         cx25840_ir_log_status(sd);
1968         v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
1969         return 0;
1970 }
1971
1972 static int cx23885_irq_handler(struct v4l2_subdev *sd, u32 status,
1973                                bool *handled)
1974 {
1975         struct cx25840_state *state = to_state(sd);
1976         struct i2c_client *c = v4l2_get_subdevdata(sd);
1977         u8 irq_stat, aud_stat, aud_en, ir_stat, ir_en;
1978         u32 vid_stat, aud_mc_stat;
1979         bool block_handled;
1980         int ret = 0;
1981
1982         irq_stat = cx25840_read(c, CX23885_PIN_CTRL_IRQ_REG);
1983         v4l_dbg(2, cx25840_debug, c, "AV Core IRQ status (entry): %s %s %s\n",
1984                 irq_stat & CX23885_PIN_CTRL_IRQ_IR_STAT ? "ir" : "  ",
1985                 irq_stat & CX23885_PIN_CTRL_IRQ_AUD_STAT ? "aud" : "   ",
1986                 irq_stat & CX23885_PIN_CTRL_IRQ_VID_STAT ? "vid" : "   ");
1987
1988         if ((is_cx23885(state) || is_cx23887(state))) {
1989                 ir_stat = cx25840_read(c, CX25840_IR_STATS_REG);
1990                 ir_en = cx25840_read(c, CX25840_IR_IRQEN_REG);
1991                 v4l_dbg(2, cx25840_debug, c,
1992                         "AV Core ir IRQ status: %#04x disables: %#04x\n",
1993                         ir_stat, ir_en);
1994                 if (irq_stat & CX23885_PIN_CTRL_IRQ_IR_STAT) {
1995                         block_handled = false;
1996                         ret = cx25840_ir_irq_handler(sd,
1997                                                      status, &block_handled);
1998                         if (block_handled)
1999                                 *handled = true;
2000                 }
2001         }
2002
2003         aud_stat = cx25840_read(c, CX25840_AUD_INT_STAT_REG);
2004         aud_en = cx25840_read(c, CX25840_AUD_INT_CTRL_REG);
2005         v4l_dbg(2, cx25840_debug, c,
2006                 "AV Core audio IRQ status: %#04x disables: %#04x\n",
2007                 aud_stat, aud_en);
2008         aud_mc_stat = cx25840_read4(c, CX23885_AUD_MC_INT_MASK_REG);
2009         v4l_dbg(2, cx25840_debug, c,
2010                 "AV Core audio MC IRQ status: %#06x enables: %#06x\n",
2011                 aud_mc_stat >> CX23885_AUD_MC_INT_STAT_SHFT,
2012                 aud_mc_stat & CX23885_AUD_MC_INT_CTRL_BITS);
2013         if (irq_stat & CX23885_PIN_CTRL_IRQ_AUD_STAT) {
2014                 if (aud_stat) {
2015                         cx25840_write(c, CX25840_AUD_INT_STAT_REG, aud_stat);
2016                         *handled = true;
2017                 }
2018         }
2019
2020         vid_stat = cx25840_read4(c, CX25840_VID_INT_STAT_REG);
2021         v4l_dbg(2, cx25840_debug, c,
2022                 "AV Core video IRQ status: %#06x disables: %#06x\n",
2023                 vid_stat & CX25840_VID_INT_STAT_BITS,
2024                 vid_stat >> CX25840_VID_INT_MASK_SHFT);
2025         if (irq_stat & CX23885_PIN_CTRL_IRQ_VID_STAT) {
2026                 if (vid_stat & CX25840_VID_INT_STAT_BITS) {
2027                         cx25840_write4(c, CX25840_VID_INT_STAT_REG, vid_stat);
2028                         *handled = true;
2029                 }
2030         }
2031
2032         irq_stat = cx25840_read(c, CX23885_PIN_CTRL_IRQ_REG);
2033         v4l_dbg(2, cx25840_debug, c, "AV Core IRQ status (exit): %s %s %s\n",
2034                 irq_stat & CX23885_PIN_CTRL_IRQ_IR_STAT ? "ir" : "  ",
2035                 irq_stat & CX23885_PIN_CTRL_IRQ_AUD_STAT ? "aud" : "   ",
2036                 irq_stat & CX23885_PIN_CTRL_IRQ_VID_STAT ? "vid" : "   ");
2037
2038         return ret;
2039 }
2040
2041 static int cx25840_irq_handler(struct v4l2_subdev *sd, u32 status,
2042                                bool *handled)
2043 {
2044         struct cx25840_state *state = to_state(sd);
2045
2046         *handled = false;
2047
2048         /* Only support the CX2388[578] AV Core for now */
2049         if (is_cx2388x(state))
2050                 return cx23885_irq_handler(sd, status, handled);
2051
2052         return -ENODEV;
2053 }
2054
2055 /* ----------------------------------------------------------------------- */
2056
2057 #define DIF_PLL_FREQ_WORD       (0x300)
2058 #define DIF_BPF_COEFF01         (0x348)
2059 #define DIF_BPF_COEFF23         (0x34c)
2060 #define DIF_BPF_COEFF45         (0x350)
2061 #define DIF_BPF_COEFF67         (0x354)
2062 #define DIF_BPF_COEFF89         (0x358)
2063 #define DIF_BPF_COEFF1011       (0x35c)
2064 #define DIF_BPF_COEFF1213       (0x360)
2065 #define DIF_BPF_COEFF1415       (0x364)
2066 #define DIF_BPF_COEFF1617       (0x368)
2067 #define DIF_BPF_COEFF1819       (0x36c)
2068 #define DIF_BPF_COEFF2021       (0x370)
2069 #define DIF_BPF_COEFF2223       (0x374)
2070 #define DIF_BPF_COEFF2425       (0x378)
2071 #define DIF_BPF_COEFF2627       (0x37c)
2072 #define DIF_BPF_COEFF2829       (0x380)
2073 #define DIF_BPF_COEFF3031       (0x384)
2074 #define DIF_BPF_COEFF3233       (0x388)
2075 #define DIF_BPF_COEFF3435       (0x38c)
2076 #define DIF_BPF_COEFF36         (0x390)
2077
2078 static void cx23885_dif_setup(struct i2c_client *client, u32 ifHz)
2079 {
2080         u64 pll_freq;
2081         u32 pll_freq_word;
2082
2083         v4l_dbg(1, cx25840_debug, client, "%s(%d)\n", __func__, ifHz);
2084
2085         /* Assuming TV */
2086         /* Calculate the PLL frequency word based on the adjusted ifHz */
2087         pll_freq = div_u64((u64)ifHz * 268435456, 50000000);
2088         pll_freq_word = (u32)pll_freq;
2089
2090         cx25840_write4(client, DIF_PLL_FREQ_WORD,  pll_freq_word);
2091
2092         /* Round down to the nearest 100KHz */
2093         ifHz = (ifHz / 100000) * 100000;
2094
2095         if (ifHz < 3000000)
2096                 ifHz = 3000000;
2097
2098         if (ifHz > 16000000)
2099                 ifHz = 16000000;
2100
2101         v4l_dbg(1, cx25840_debug, client, "%s(%d) again\n", __func__, ifHz);
2102
2103         switch (ifHz) {
2104         case 3000000:
2105                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
2106                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080012);
2107                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0024);
2108                 cx25840_write4(client, DIF_BPF_COEFF67, 0x001bfff8);
2109                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffb4ff50);
2110                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed8fe68);
2111                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe24fe34);
2112                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfebaffc7);
2113                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d031f);
2114                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04f0065d);
2115                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07010688);
2116                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x04c901d6);
2117                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe00f9d3);
2118                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f342);
2119                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf235f337);
2120                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf64efb22);
2121                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0105070f);
2122                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0c460fce);
2123                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2124                 break;
2125
2126         case 3100000:
2127                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
2128                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00070012);
2129                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00220032);
2130                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00370026);
2131                 cx25840_write4(client, DIF_BPF_COEFF89, 0xfff0ff91);
2132                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff0efe7c);
2133                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01fdcc);
2134                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe0afedb);
2135                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440224);
2136                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0434060c);
2137                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0738074e);
2138                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x06090361);
2139                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xff99fb39);
2140                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef3b6);
2141                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21af2a5);
2142                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf573fa33);
2143                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0034067d);
2144                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0bfb0fb9);
2145                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2146                 break;
2147
2148         case 3200000:
2149                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000000);
2150                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0004000e);
2151                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00200038);
2152                 cx25840_write4(client, DIF_BPF_COEFF67, 0x004c004f);
2153                 cx25840_write4(client, DIF_BPF_COEFF89, 0x002fffdf);
2154                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff5cfeb6);
2155                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0dfd92);
2156                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd7ffe03);
2157                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36010a);
2158                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x03410575);
2159                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x072607d2);
2160                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x071804d5);
2161                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0134fcb7);
2162                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff451);
2163                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf223f22e);
2164                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4a7f94b);
2165                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xff6405e8);
2166                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0bae0fa4);
2167                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2168                 break;
2169
2170         case 3300000:
2171                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
2172                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00000008);
2173                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001a0036);
2174                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0056006d);
2175                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00670030);
2176                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffbdff10);
2177                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe46fd8d);
2178                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd25fd4f);
2179                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35ffe0);
2180                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0224049f);
2181                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c9080e);
2182                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x07ef0627);
2183                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c9fe45);
2184                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f513);
2185                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf250f1d2);
2186                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3ecf869);
2187                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe930552);
2188                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0b5f0f8f);
2189                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2190                 break;
2191
2192         case 3400000:
2193                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
2194                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd0001);
2195                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000f002c);
2196                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0054007d);
2197                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0093007c);
2198                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0024ff82);
2199                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea6fdbb);
2200                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd03fcca);
2201                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51feb9);
2202                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x00eb0392);
2203                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06270802);
2204                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08880750);
2205                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x044dffdb);
2206                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf5f8);
2207                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a0f193);
2208                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf342f78f);
2209                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc404b9);
2210                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0b0e0f78);
2211                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2212                 break;
2213
2214         case 3500000:
2215                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2216                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff9);
2217                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0002001b);
2218                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0046007d);
2219                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00ad00ba);
2220                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00870000);
2221                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff26fe1a);
2222                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd1bfc7e);
2223                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fda4);
2224                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xffa5025c);
2225                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x054507ad);
2226                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08dd0847);
2227                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b80172);
2228                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef6ff);
2229                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf313f170);
2230                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2abf6bd);
2231                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6041f);
2232                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0abc0f61);
2233                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2234                 break;
2235
2236         case 3600000:
2237                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2238                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff3);
2239                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff50006);
2240                 cx25840_write4(client, DIF_BPF_COEFF67, 0x002f006c);
2241                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b200e3);
2242                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00dc007e);
2243                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffb9fea0);
2244                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd6bfc71);
2245                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fcb1);
2246                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe65010b);
2247                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x042d0713);
2248                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08ec0906);
2249                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x07020302);
2250                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff823);
2251                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3a7f16a);
2252                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf228f5f5);
2253                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfc2a0384);
2254                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0a670f4a);
2255                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2256                 break;
2257
2258         case 3700000:
2259                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
2260                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7ffef);
2261                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe9fff1);
2262                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0010004d);
2263                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a100f2);
2264                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x011a00f0);
2265                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0053ff44);
2266                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdedfca2);
2267                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fbef);
2268                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd39ffae);
2269                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x02ea0638);
2270                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08b50987);
2271                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x08230483);
2272                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f960);
2273                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf45bf180);
2274                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1b8f537);
2275                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfb6102e7);
2276                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x0a110f32);
2277                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2278                 break;
2279
2280         case 3800000:
2281                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
2282                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9ffee);
2283                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffdd);
2284                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfff00024);
2285                 cx25840_write4(client, DIF_BPF_COEFF89, 0x007c00e5);
2286                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013a014a);
2287                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00e6fff8);
2288                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe98fd0f);
2289                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fb67);
2290                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc32fe54);
2291                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x01880525);
2292                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x083909c7);
2293                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x091505ee);
2294                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7fab3);
2295                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf52df1b4);
2296                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf15df484);
2297                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfa9b0249);
2298                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x09ba0f19);
2299                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2300                 break;
2301
2302         case 3900000:
2303                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000000);
2304                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbfff0);
2305                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffcf);
2306                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1fff6);
2307                 cx25840_write4(client, DIF_BPF_COEFF89, 0x004800be);
2308                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01390184);
2309                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x016300ac);
2310                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff5efdb1);
2311                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fb23);
2312                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb5cfd0d);
2313                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x001703e4);
2314                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x077b09c4);
2315                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x09d2073c);
2316                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251fc18);
2317                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf61cf203);
2318                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf118f3dc);
2319                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf9d801aa);
2320                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x09600eff);
2321                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2322                 break;
2323
2324         case 4000000:
2325                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
2326                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffefff4);
2327                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffc8);
2328                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffca);
2329                 cx25840_write4(client, DIF_BPF_COEFF89, 0x000b0082);
2330                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01170198);
2331                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01c10152);
2332                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0030fe7b);
2333                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fb24);
2334                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfac3fbe9);
2335                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfea5027f);
2336                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0683097f);
2337                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a560867);
2338                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2fd89);
2339                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf723f26f);
2340                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0e8f341);
2341                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf919010a);
2342                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x09060ee5);
2343                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2344                 break;
2345
2346         case 4100000:
2347                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
2348                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0002fffb);
2349                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe8ffca);
2350                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffa4);
2351                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffcd0036);
2352                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d70184);
2353                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f601dc);
2354                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00ffff60);
2355                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb6d);
2356                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa6efaf5);
2357                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd410103);
2358                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x055708f9);
2359                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a9e0969);
2360                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543ff02);
2361                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf842f2f5);
2362                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0cef2b2);
2363                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf85e006b);
2364                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x08aa0ecb);
2365                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2366                 break;
2367
2368         case 4200000:
2369                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
2370                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00050003);
2371                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff3ffd3);
2372                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaff8b);
2373                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff95ffe5);
2374                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0080014a);
2375                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fe023f);
2376                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01ba0050);
2377                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fbf8);
2378                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa62fa3b);
2379                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbf9ff7e);
2380                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x04010836);
2381                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aa90a3d);
2382                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f007f);
2383                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf975f395);
2384                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0cbf231);
2385                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf7a9ffcb);
2386                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x084c0eaf);
2387                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2388                 break;
2389
2390         case 4300000:
2391                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
2392                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000a);
2393                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0000ffe4);
2394                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ff81);
2395                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff6aff96);
2396                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x001c00f0);
2397                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01d70271);
2398                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0254013b);
2399                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fcbd);
2400                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa9ff9c5);
2401                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfadbfdfe);
2402                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x028c073b);
2403                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a750adf);
2404                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e101fa);
2405                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfab8f44e);
2406                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0ddf1be);
2407                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf6f9ff2b);
2408                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x07ed0e94);
2409                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2410                 break;
2411
2412         case 4400000:
2413                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
2414                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0009000f);
2415                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000efff8);
2416                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ff87);
2417                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff52ff54);
2418                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffb5007e);
2419                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01860270);
2420                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c00210);
2421                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fdb2);
2422                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb22f997);
2423                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9f2fc90);
2424                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0102060f);
2425                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a050b4c);
2426                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902036e);
2427                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfc0af51e);
2428                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf106f15a);
2429                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf64efe8b);
2430                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x078d0e77);
2431                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2432                 break;
2433
2434         case 4500000:
2435                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
2436                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080012);
2437                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0019000e);
2438                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff9e);
2439                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4fff25);
2440                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff560000);
2441                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0112023b);
2442                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f702c0);
2443                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfec8);
2444                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbe5f9b3);
2445                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf947fb41);
2446                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xff7004b9);
2447                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x095a0b81);
2448                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a0004d8);
2449                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfd65f603);
2450                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf144f104);
2451                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf5aafdec);
2452                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x072b0e5a);
2453                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2454                 break;
2455
2456         case 4600000:
2457                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
2458                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00060012);
2459                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00200022);
2460                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ffc1);
2461                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff61ff10);
2462                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff09ff82);
2463                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x008601d7);
2464                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f50340);
2465                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fff0);
2466                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcddfa19);
2467                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8e2fa1e);
2468                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfde30343);
2469                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x08790b7f);
2470                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50631);
2471                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfec7f6fc);
2472                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf198f0bd);
2473                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf50dfd4e);
2474                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x06c90e3d);
2475                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2476                 break;
2477
2478         case 4700000:
2479                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
2480                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0003000f);
2481                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00220030);
2482                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ffed);
2483                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff87ff15);
2484                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed6ff10);
2485                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffed014c);
2486                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b90386);
2487                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110119);
2488                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfdfefac4);
2489                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8c6f92f);
2490                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc6701b7);
2491                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x07670b44);
2492                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0776);
2493                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x002df807);
2494                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf200f086);
2495                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf477fcb1);
2496                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x06650e1e);
2497                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2498                 break;
2499
2500         case 4800000:
2501                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
2502                 cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0009);
2503                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0038);
2504                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003f001b);
2505                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffbcff36);
2506                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec2feb6);
2507                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff5600a5);
2508                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0248038d);
2509                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00232);
2510                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xff39fbab);
2511                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8f4f87f);
2512                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb060020);
2513                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x062a0ad2);
2514                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf908a3);
2515                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0192f922);
2516                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf27df05e);
2517                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf3e8fc14);
2518                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x06000e00);
2519                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2520                 break;
2521
2522         case 4900000:
2523                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2524                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc0002);
2525                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00160037);
2526                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00510046);
2527                 cx25840_write4(client, DIF_BPF_COEFF89, 0xfff9ff6d);
2528                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed0fe7c);
2529                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfecefff0);
2530                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01aa0356);
2531                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413032b);
2532                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x007ffcc5);
2533                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf96cf812);
2534                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9cefe87);
2535                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x04c90a2c);
2536                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c4309b4);
2537                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x02f3fa4a);
2538                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf30ef046);
2539                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf361fb7a);
2540                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x059b0de0);
2541                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2542                 break;
2543
2544         case 5000000:
2545                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2546                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffa);
2547                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000a002d);
2548                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00570067);
2549                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0037ffb5);
2550                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfefffe68);
2551                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe62ff3d);
2552                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00ec02e3);
2553                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x043503f6);
2554                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x01befe05);
2555                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa27f7ee);
2556                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8c6fcf8);
2557                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x034c0954);
2558                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5c0aa4);
2559                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x044cfb7e);
2560                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3b1f03f);
2561                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf2e2fae1);
2562                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x05340dc0);
2563                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2564                 break;
2565
2566         case 5100000:
2567                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
2568                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff4);
2569                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffd001e);
2570                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0051007b);
2571                 cx25840_write4(client, DIF_BPF_COEFF89, 0x006e0006);
2572                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff48fe7c);
2573                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe1bfe9a);
2574                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x001d023e);
2575                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130488);
2576                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x02e6ff5b);
2577                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb1ef812);
2578                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7f7fb7f);
2579                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x01bc084e);
2580                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c430b72);
2581                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x059afcba);
2582                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf467f046);
2583                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf26cfa4a);
2584                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x04cd0da0);
2585                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2586                 break;
2587
2588         case 5200000:
2589                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
2590                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8ffef);
2591                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff00009);
2592                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003f007f);
2593                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00980056);
2594                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffa5feb6);
2595                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe00fe15);
2596                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff4b0170);
2597                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b004d7);
2598                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x03e800b9);
2599                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc48f87f);
2600                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf768fa23);
2601                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0022071f);
2602                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf90c1b);
2603                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x06dafdfd);
2604                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf52df05e);
2605                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf1fef9b5);
2606                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x04640d7f);
2607                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2608                 break;
2609
2610         case 5300000:
2611                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
2612                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9ffee);
2613                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe6fff3);
2614                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00250072);
2615                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00af009c);
2616                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x000cff10);
2617                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe13fdb8);
2618                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe870089);
2619                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x031104e1);
2620                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04b8020f);
2621                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd98f92f);
2622                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf71df8f0);
2623                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe8805ce);
2624                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0c9c);
2625                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0808ff44);
2626                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf603f086);
2627                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf19af922);
2628                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x03fb0d5e);
2629                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2630                 break;
2631
2632         case 5400000:
2633                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
2634                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcffef);
2635                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffe0);
2636                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00050056);
2637                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b000d1);
2638                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0071ff82);
2639                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe53fd8c);
2640                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfddfff99);
2641                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104a3);
2642                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x054a034d);
2643                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xff01fa1e);
2644                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf717f7ed);
2645                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfcf50461);
2646                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50cf4);
2647                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0921008d);
2648                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf6e7f0bd);
2649                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf13ff891);
2650                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x03920d3b);
2651                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2652                 break;
2653
2654         case 5500000:
2655                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
2656                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffffff3);
2657                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffd1);
2658                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5002f);
2659                 cx25840_write4(client, DIF_BPF_COEFF89, 0x009c00ed);
2660                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00cb0000);
2661                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfebafd94);
2662                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd61feb0);
2663                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d0422);
2664                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05970464);
2665                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0074fb41);
2666                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf759f721);
2667                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfb7502de);
2668                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000d21);
2669                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a2201d4);
2670                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf7d9f104);
2671                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0edf804);
2672                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x03280d19);
2673                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2674                 break;
2675
2676         case 5600000:
2677                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
2678                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0003fffa);
2679                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe3ffc9);
2680                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc90002);
2681                 cx25840_write4(client, DIF_BPF_COEFF89, 0x007500ef);
2682                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x010e007e);
2683                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff3dfdcf);
2684                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd16fddd);
2685                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440365);
2686                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x059b0548);
2687                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x01e3fc90);
2688                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7dff691);
2689                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa0f014d);
2690                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x09020d23);
2691                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b0a0318);
2692                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf8d7f15a);
2693                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0a5f779);
2694                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x02bd0cf6);
2695                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2696                 break;
2697
2698         case 5700000:
2699                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
2700                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00060001);
2701                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffecffc9);
2702                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ffd4);
2703                 cx25840_write4(client, DIF_BPF_COEFF89, 0x004000d5);
2704                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013600f0);
2705                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffd3fe39);
2706                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd04fd31);
2707                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff360277);
2708                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x055605ef);
2709                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x033efdfe);
2710                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8a5f642);
2711                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf8cbffb6);
2712                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e10cfb);
2713                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0bd50456);
2714                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf9dff1be);
2715                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf067f6f2);
2716                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x02520cd2);
2717                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2718                 break;
2719
2720         case 5800000:
2721                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
2722                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080009);
2723                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff8ffd2);
2724                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaffac);
2725                 cx25840_write4(client, DIF_BPF_COEFF89, 0x000200a3);
2726                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013c014a);
2727                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x006dfec9);
2728                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd2bfcb7);
2729                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe350165);
2730                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04cb0651);
2731                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0477ff7e);
2732                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9a5f635);
2733                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7b1fe20);
2734                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0ca8);
2735                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c81058b);
2736                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfaf0f231);
2737                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf033f66d);
2738                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x01e60cae);
2739                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2740                 break;
2741
2742         case 5900000:
2743                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
2744                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0009000e);
2745                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0005ffe1);
2746                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffacff90);
2747                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffc5005f);
2748                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01210184);
2749                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00fcff72);
2750                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd8afc77);
2751                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51003f);
2752                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04020669);
2753                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05830103);
2754                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfad7f66b);
2755                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6c8fc93);
2756                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430c2b);
2757                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d0d06b5);
2758                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfc08f2b2);
2759                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf00af5ec);
2760                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x017b0c89);
2761                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2762                 break;
2763
2764         case 6000000:
2765                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
2766                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00070012);
2767                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0012fff5);
2768                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaff82);
2769                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff8e000f);
2770                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e80198);
2771                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01750028);
2772                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe18fc75);
2773                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99ff15);
2774                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x03050636);
2775                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0656027f);
2776                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc32f6e2);
2777                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf614fb17);
2778                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20b87);
2779                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d7707d2);
2780                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfd26f341);
2781                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefeaf56f);
2782                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x010f0c64);
2783                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2784                 break;
2785
2786         case 6100000:
2787                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
2788                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00050012);
2789                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001c000b);
2790                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1ff84);
2791                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff66ffbe);
2792                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00960184);
2793                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01cd00da);
2794                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfeccfcb2);
2795                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fdf9);
2796                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x01e005bc);
2797                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06e703e4);
2798                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfdabf798);
2799                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf599f9b3);
2800                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x02510abd);
2801                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dbf08df);
2802                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfe48f3dc);
2803                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefd5f4f6);
2804                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x00a20c3e);
2805                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2806                 break;
2807
2808         case 6200000:
2809                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
2810                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0002000f);
2811                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0021001f);
2812                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0ff97);
2813                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff50ff74);
2814                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0034014a);
2815                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fa0179);
2816                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff97fd2a);
2817                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fcfa);
2818                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x00a304fe);
2819                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07310525);
2820                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xff37f886);
2821                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55cf86e);
2822                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c709d0);
2823                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de209db);
2824                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xff6df484);
2825                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefcbf481);
2826                 cx25840_write4(client, DIF_BPF_COEFF3435, 0x00360c18);
2827                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2828                 break;
2829
2830         case 6300000:
2831                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2832                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffe000a);
2833                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0021002f);
2834                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0010ffb8);
2835                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff50ff3b);
2836                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffcc00f0);
2837                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fa01fa);
2838                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0069fdd4);
2839                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fc26);
2840                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xff5d0407);
2841                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07310638);
2842                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x00c9f9a8);
2843                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55cf74e);
2844                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xff3908c3);
2845                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de20ac3);
2846                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0093f537);
2847                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefcbf410);
2848                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xffca0bf2);
2849                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2850                 break;
2851
2852         case 6400000:
2853                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
2854                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffb0003);
2855                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001c0037);
2856                 cx25840_write4(client, DIF_BPF_COEFF67, 0x002fffe2);
2857                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff66ff17);
2858                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff6a007e);
2859                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01cd0251);
2860                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0134fea5);
2861                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fb8b);
2862                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe2002e0);
2863                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06e70713);
2864                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0255faf5);
2865                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf599f658);
2866                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaf0799);
2867                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dbf0b96);
2868                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x01b8f5f5);
2869                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefd5f3a3);
2870                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xff5e0bca);
2871                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2872                 break;
2873
2874         case 6500000:
2875                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
2876                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffb);
2877                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00120037);
2878                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00460010);
2879                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff8eff0f);
2880                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff180000);
2881                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01750276);
2882                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01e8ff8d);
2883                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fb31);
2884                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcfb0198);
2885                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x065607ad);
2886                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x03cefc64);
2887                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf614f592);
2888                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2e0656);
2889                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d770c52);
2890                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x02daf6bd);
2891                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xefeaf33b);
2892                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfef10ba3);
2893                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2894                 break;
2895
2896         case 6600000:
2897                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
2898                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7fff5);
2899                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0005002f);
2900                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0054003c);
2901                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffc5ff22);
2902                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedfff82);
2903                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00fc0267);
2904                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0276007e);
2905                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb1c);
2906                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbfe003e);
2907                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05830802);
2908                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0529fdec);
2909                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6c8f4fe);
2910                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabd04ff);
2911                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d0d0cf6);
2912                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x03f8f78f);
2913                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf00af2d7);
2914                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfe850b7b);
2915                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2916                 break;
2917
2918         case 6700000:
2919                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
2920                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff0);
2921                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff80020);
2922                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00560060);
2923                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0002ff4e);
2924                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec4ff10);
2925                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x006d0225);
2926                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02d50166);
2927                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb4e);
2928                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb35fee1);
2929                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0477080e);
2930                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x065bff82);
2931                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7b1f4a0);
2932                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf9610397);
2933                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c810d80);
2934                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0510f869);
2935                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf033f278);
2936                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfe1a0b52);
2937                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2938                 break;
2939
2940         case 6800000:
2941                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
2942                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffaffee);
2943                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffec000c);
2944                 cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0078);
2945                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0040ff8e);
2946                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecafeb6);
2947                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffd301b6);
2948                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fc0235);
2949                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fbc5);
2950                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaaafd90);
2951                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x033e07d2);
2952                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x075b011b);
2953                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf8cbf47a);
2954                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81f0224);
2955                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0bd50def);
2956                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0621f94b);
2957                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf067f21e);
2958                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfdae0b29);
2959                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2960                 break;
2961
2962         case 6900000:
2963                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
2964                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffdffef);
2965                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe3fff6);
2966                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0037007f);
2967                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0075ffdc);
2968                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef2fe7c);
2969                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff3d0122);
2970                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02ea02dd);
2971                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fc79);
2972                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa65fc5d);
2973                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x01e3074e);
2974                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x082102ad);
2975                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa0ff48c);
2976                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fe00a9);
2977                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b0a0e43);
2978                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0729fa33);
2979                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0a5f1c9);
2980                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfd430b00);
2981                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
2982                 break;
2983
2984         case 7000000:
2985                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
2986                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0001fff3);
2987                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffe2);
2988                 cx25840_write4(client, DIF_BPF_COEFF67, 0x001b0076);
2989                 cx25840_write4(client, DIF_BPF_COEFF89, 0x009c002d);
2990                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff35fe68);
2991                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfeba0076);
2992                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x029f0352);
2993                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfd60);
2994                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa69fb53);
2995                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x00740688);
2996                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08a7042d);
2997                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfb75f4d6);
2998                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600ff2d);
2999                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a220e7a);
3000                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0827fb22);
3001                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0edf17a);
3002                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfcd80ad6);
3003                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3004                 break;
3005
3006         case 7100000:
3007                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3008                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0004fff9);
3009                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffd2);
3010                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfffb005e);
3011                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b0007a);
3012                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff8ffe7c);
3013                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe53ffc1);
3014                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0221038c);
3015                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fe6e);
3016                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfab6fa80);
3017                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xff010587);
3018                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08e90590);
3019                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfcf5f556);
3020                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bfdb3);
3021                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x09210e95);
3022                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0919fc15);
3023                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf13ff12f);
3024                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfc6e0aab);
3025                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3026                 break;
3027
3028         case 7200000:
3029                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3030                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00070000);
3031                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe6ffc9);
3032                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffdb0039);
3033                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00af00b8);
3034                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfff4feb6);
3035                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe13ff10);
3036                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01790388);
3037                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311ff92);
3038                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb48f9ed);
3039                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd980453);
3040                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08e306cd);
3041                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe88f60a);
3042                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482fc40);
3043                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x08080e93);
3044                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x09fdfd0c);
3045                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf19af0ea);
3046                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfc050a81);
3047                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3048                 break;
3049
3050         case 7300000:
3051                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
3052                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080008);
3053                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff0ffc9);
3054                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1000d);
3055                 cx25840_write4(client, DIF_BPF_COEFF89, 0x009800e2);
3056                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x005bff10);
3057                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe00fe74);
3058                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00b50345);
3059                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b000bc);
3060                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc18f9a1);
3061                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc4802f9);
3062                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x089807dc);
3063                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0022f6f0);
3064                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407fada);
3065                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x06da0e74);
3066                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ad3fe06);
3067                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf1fef0ab);
3068                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfb9c0a55);
3069                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3070                 break;
3071
3072         case 7400000:
3073                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
3074                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000e);
3075                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffdffd0);
3076                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffafffdf);
3077                 cx25840_write4(client, DIF_BPF_COEFF89, 0x006e00f2);
3078                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00b8ff82);
3079                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe1bfdf8);
3080                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xffe302c8);
3081                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x041301dc);
3082                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd1af99e);
3083                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb1e0183);
3084                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x080908b5);
3085                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x01bcf801);
3086                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdf985);
3087                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x059a0e38);
3088                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b99ff03);
3089                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf26cf071);
3090                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfb330a2a);
3091                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3092                 break;
3093
3094         case 7500000:
3095                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
3096                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00070011);
3097                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000affdf);
3098                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffa9ffb5);
3099                 cx25840_write4(client, DIF_BPF_COEFF89, 0x003700e6);
3100                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01010000);
3101                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe62fda8);
3102                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff140219);
3103                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x043502e1);
3104                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe42f9e6);
3105                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa270000);
3106                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x073a0953);
3107                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x034cf939);
3108                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3a4f845);
3109                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x044c0de1);
3110                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c4f0000);
3111                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf2e2f03c);
3112                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfacc09fe);
3113                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3114                 break;
3115
3116         case 7600000:
3117                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
3118                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00040012);
3119                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0016fff3);
3120                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffafff95);
3121                 cx25840_write4(client, DIF_BPF_COEFF89, 0xfff900c0);
3122                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0130007e);
3123                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfecefd89);
3124                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe560146);
3125                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x041303bc);
3126                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xff81fa76);
3127                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf96cfe7d);
3128                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x063209b1);
3129                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x04c9fa93);
3130                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdf71e);
3131                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x02f30d6e);
3132                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cf200fd);
3133                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf361f00e);
3134                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfa6509d1);
3135                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3136                 break;
3137
3138         case 7700000:
3139                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
3140                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00010010);
3141                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0008);
3142                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1ff84);
3143                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffbc0084);
3144                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013e00f0);
3145                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff56fd9f);
3146                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdb8005c);
3147                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00460);
3148                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x00c7fb45);
3149                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8f4fd07);
3150                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x04fa09ce);
3151                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x062afc07);
3152                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407f614);
3153                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x01920ce0);
3154                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d8301fa);
3155                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf3e8efe5);
3156                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xfa0009a4);
3157                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3158                 break;
3159
3160         case 7800000:
3161                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3162                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd000b);
3163                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0022001d);
3164                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffdbff82);
3165                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff870039);
3166                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x012a014a);
3167                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffedfde7);
3168                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd47ff6b);
3169                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x031104c6);
3170                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0202fc4c);
3171                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8c6fbad);
3172                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x039909a7);
3173                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0767fd8e);
3174                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482f52b);
3175                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x002d0c39);
3176                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e0002f4);
3177                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf477efc2);
3178                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf99b0977);
3179                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3180                 break;
3181
3182         case 7900000:
3183                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3184                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa0004);
3185                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0020002d);
3186                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfffbff91);
3187                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff61ffe8);
3188                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f70184);
3189                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0086fe5c);
3190                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd0bfe85);
3191                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104e5);
3192                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0323fd7d);
3193                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8e2fa79);
3194                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x021d093f);
3195                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0879ff22);
3196                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bf465);
3197                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfec70b79);
3198                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e6803eb);
3199                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf50defa5);
3200                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf937094a);
3201                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3202                 break;
3203
3204         case 8000000:
3205                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
3206                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fffd);
3207                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00190036);
3208                 cx25840_write4(client, DIF_BPF_COEFF67, 0x001bffaf);
3209                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4fff99);
3210                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00aa0198);
3211                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0112fef3);
3212                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd09fdb9);
3213                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d04be);
3214                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x041bfecc);
3215                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf947f978);
3216                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x00900897);
3217                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x095a00b9);
3218                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f3c5);
3219                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfd650aa3);
3220                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ebc04de);
3221                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf5aaef8e);
3222                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf8d5091c);
3223                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3224                 break;
3225
3226         case 8100000:
3227                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
3228                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7fff6);
3229                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000e0038);
3230                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0037ffd7);
3231                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff52ff56);
3232                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x004b0184);
3233                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0186ffa1);
3234                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd40fd16);
3235                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440452);
3236                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04de0029);
3237                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9f2f8b2);
3238                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfefe07b5);
3239                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a05024d);
3240                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef34d);
3241                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfc0a09b8);
3242                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0efa05cd);
3243                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf64eef7d);
3244                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf87308ed);
3245                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3246                 break;
3247
3248         case 8200000:
3249                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
3250                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff0);
3251                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00000031);
3252                 cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0005);
3253                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff6aff27);
3254                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffe4014a);
3255                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01d70057);
3256                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdacfca6);
3257                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3603a7);
3258                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05610184);
3259                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfadbf82e);
3260                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd74069f);
3261                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a7503d6);
3262                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff2ff);
3263                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfab808b9);
3264                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f2306b5);
3265                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf6f9ef72);
3266                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf81308bf);
3267                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3268                 break;
3269
3270         case 8300000:
3271                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
3272                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbffee);
3273                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff30022);
3274                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00560032);
3275                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff95ff10);
3276                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff8000f0);
3277                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fe0106);
3278                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe46fc71);
3279                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3502c7);
3280                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x059e02ce);
3281                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbf9f7f2);
3282                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfbff055b);
3283                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aa9054c);
3284                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f2db);
3285                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf97507aa);
3286                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f350797);
3287                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf7a9ef6d);
3288                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf7b40890);
3289                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3290                 break;
3291
3292         case 8400000:
3293                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
3294                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffeffee);
3295                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe8000f);
3296                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00540058);
3297                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffcdff14);
3298                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff29007e);
3299                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f6019e);
3300                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff01fc7c);
3301                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd5101bf);
3302                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x059203f6);
3303                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd41f7fe);
3304                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfaa903f3);
3305                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a9e06a9);
3306                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf2e2);
3307                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf842068b);
3308                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f320871);
3309                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf85eef6e);
3310                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf7560860);
3311                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3312                 break;
3313
3314         case 8500000:
3315                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3316                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0002fff2);
3317                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1fff9);
3318                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00460073);
3319                 cx25840_write4(client, DIF_BPF_COEFF89, 0x000bff34);
3320                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfee90000);
3321                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01c10215);
3322                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xffd0fcc5);
3323                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99009d);
3324                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x053d04f1);
3325                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfea5f853);
3326                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf97d0270);
3327                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a5607e4);
3328                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef314);
3329                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf723055f);
3330                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f180943);
3331                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf919ef75);
3332                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf6fa0830);
3333                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3334                 break;
3335
3336         case 8600000:
3337                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3338                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0005fff8);
3339                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffe4);
3340                 cx25840_write4(client, DIF_BPF_COEFF67, 0x002f007f);
3341                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0048ff6b);
3342                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec7ff82);
3343                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0163025f);
3344                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00a2fd47);
3345                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17ff73);
3346                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04a405b2);
3347                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0017f8ed);
3348                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf88500dc);
3349                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x09d208f9);
3350                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff370);
3351                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf61c0429);
3352                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ee80a0b);
3353                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xf9d8ef82);
3354                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf6a00800);
3355                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3356                 break;
3357
3358         case 8700000:
3359                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3360                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0007ffff);
3361                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffd4);
3362                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0010007a);
3363                 cx25840_write4(client, DIF_BPF_COEFF89, 0x007cffb2);
3364                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec6ff10);
3365                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00e60277);
3366                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0168fdf9);
3367                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fe50);
3368                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x03ce0631);
3369                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0188f9c8);
3370                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7c7ff43);
3371                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x091509e3);
3372                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f3f6);
3373                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf52d02ea);
3374                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ea30ac9);
3375                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfa9bef95);
3376                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf64607d0);
3377                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3378                 break;
3379
3380         case 8800000:
3381                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
3382                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00090007);
3383                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe9ffca);
3384                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfff00065);
3385                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a10003);
3386                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfee6feb6);
3387                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0053025b);
3388                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0213fed0);
3389                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fd46);
3390                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x02c70668);
3391                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x02eafadb);
3392                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf74bfdae);
3393                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x08230a9c);
3394                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7f4a3);
3395                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf45b01a6);
3396                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e480b7c);
3397                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfb61efae);
3398                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf5ef079f);
3399                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3400                 break;
3401
3402         case 8900000:
3403                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
3404                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000d);
3405                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff5ffc8);
3406                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffd10043);
3407                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b20053);
3408                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff24fe7c);
3409                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffb9020c);
3410                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0295ffbb);
3411                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fc64);
3412                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x019b0654);
3413                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x042dfc1c);
3414                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf714fc2a);
3415                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x07020b21);
3416                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251f575);
3417                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3a7005e);
3418                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0dd80c24);
3419                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfc2aefcd);
3420                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf599076e);
3421                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3422                 break;
3423
3424         case 9000000:
3425                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
3426                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00060011);
3427                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0002ffcf);
3428                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffba0018);
3429                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00ad009a);
3430                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff79fe68);
3431                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff260192);
3432                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02e500ab);
3433                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fbb6);
3434                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x005b05f7);
3435                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0545fd81);
3436                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf723fabf);
3437                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b80b70);
3438                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2f669);
3439                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf313ff15);
3440                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d550cbf);
3441                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6eff2);
3442                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf544073d);
3443                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3444                 break;
3445
3446         case 9100000:
3447                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
3448                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00030012);
3449                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000fffdd);
3450                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffea);
3451                 cx25840_write4(client, DIF_BPF_COEFF89, 0x009300cf);
3452                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffdcfe7c);
3453                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea600f7);
3454                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fd0190);
3455                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb46);
3456                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xff150554);
3457                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0627fefd);
3458                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf778f978);
3459                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x044d0b87);
3460                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543f77d);
3461                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a0fdcf);
3462                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cbe0d4e);
3463                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc4f01d);
3464                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4f2070b);
3465                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3466                 break;
3467
3468         case 9200000:
3469                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3470                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00000010);
3471                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001afff0);
3472                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaffbf);
3473                 cx25840_write4(client, DIF_BPF_COEFF89, 0x006700ed);
3474                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0043feb6);
3475                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe460047);
3476                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02db0258);
3477                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb1b);
3478                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfddc0473);
3479                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c90082);
3480                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf811f85e);
3481                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c90b66);
3482                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069ff8ad);
3483                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf250fc8d);
3484                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c140dcf);
3485                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe93f04d);
3486                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4a106d9);
3487                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3488                 break;
3489
3490         case 9300000:
3491                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3492                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc000c);
3493                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00200006);
3494                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ff9c);
3495                 cx25840_write4(client, DIF_BPF_COEFF89, 0x002f00ef);
3496                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00a4ff10);
3497                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0dff92);
3498                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x028102f7);
3499                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb37);
3500                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcbf035e);
3501                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07260202);
3502                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8e8f778);
3503                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x01340b0d);
3504                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1f9f4);
3505                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf223fb51);
3506                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b590e42);
3507                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xff64f083);
3508                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf45206a7);
3509                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3510                 break;
3511
3512         case 9400000:
3513                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3514                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff90005);
3515                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0022001a);
3516                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ff86);
3517                 cx25840_write4(client, DIF_BPF_COEFF89, 0xfff000d7);
3518                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f2ff82);
3519                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01fee5);
3520                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01f60362);
3521                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb99);
3522                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbcc0222);
3523                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07380370);
3524                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9f7f6cc);
3525                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xff990a7e);
3526                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902fb50);
3527                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21afa1f);
3528                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0a8d0ea6);
3529                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0034f0bf);
3530                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4050675);
3531                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3532                 break;
3533
3534         case 9500000:
3535                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
3536                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fffe);
3537                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001e002b);
3538                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff81);
3539                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffb400a5);
3540                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01280000);
3541                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe24fe50);
3542                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01460390);
3543                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfc3a);
3544                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb1000ce);
3545                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x070104bf);
3546                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb37f65f);
3547                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe0009bc);
3548                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a00fcbb);
3549                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf235f8f8);
3550                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x09b20efc);
3551                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0105f101);
3552                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf3ba0642);
3553                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3554                 break;
3555
3556         case 9600000:
3557                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
3558                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff7);
3559                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00150036);
3560                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ff8c);
3561                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff810061);
3562                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013d007e);
3563                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe71fddf);
3564                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x007c0380);
3565                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fd13);
3566                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa94ff70);
3567                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x068005e2);
3568                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc9bf633);
3569                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfc7308ca);
3570                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad5fe30);
3571                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf274f7e0);
3572                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x08c90f43);
3573                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x01d4f147);
3574                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf371060f);
3575                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3576                 break;
3577
3578         case 9700000:
3579                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
3580                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fff1);
3581                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00090038);
3582                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ffa7);
3583                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff5e0012);
3584                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013200f0);
3585                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfee3fd9b);
3586                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xffaa0331);
3587                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fe15);
3588                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa60fe18);
3589                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05bd06d1);
3590                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe1bf64a);
3591                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfafa07ae);
3592                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7effab);
3593                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2d5f6d7);
3594                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x07d30f7a);
3595                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x02a3f194);
3596                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf32905dc);
3597                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3598                 break;
3599
3600         case 9800000:
3601                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
3602                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcffee);
3603                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffb0032);
3604                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003fffcd);
3605                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4effc1);
3606                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0106014a);
3607                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff6efd8a);
3608                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfedd02aa);
3609                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0ff34);
3610                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa74fcd7);
3611                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x04bf0781);
3612                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xffaaf6a3);
3613                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf99e066b);
3614                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf90128);
3615                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf359f5e1);
3616                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x06d20fa2);
3617                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0370f1e5);
3618                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2e405a8);
3619                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3620                 break;
3621
3622         case 9900000:
3623                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3624                 cx25840_write4(client, DIF_BPF_COEFF23, 0xffffffee);
3625                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffef0024);
3626                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0051fffa);
3627                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff54ff77);
3628                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00be0184);
3629                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0006fdad);
3630                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe2701f3);
3631                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413005e);
3632                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfad1fbba);
3633                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x039007ee);
3634                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x013bf73d);
3635                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf868050a);
3636                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c4302a1);
3637                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3fdf4fe);
3638                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x05c70fba);
3639                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x043bf23c);
3640                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2a10575);
3641                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3642                 break;
3643
3644         case 10000000:
3645                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3646                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0003fff1);
3647                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe50011);
3648                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00570027);
3649                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff70ff3c);
3650                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00620198);
3651                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x009efe01);
3652                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd95011a);
3653                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x04350183);
3654                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb71fad0);
3655                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x023c0812);
3656                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x02c3f811);
3657                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf75e0390);
3658                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5c0411);
3659                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf4c1f432);
3660                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x04b30fc1);
3661                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0503f297);
3662                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2610541);
3663                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3664                 break;
3665
3666         case 10100000:
3667                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3668                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0006fff7);
3669                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdffffc);
3670                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00510050);
3671                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff9dff18);
3672                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfffc0184);
3673                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0128fe80);
3674                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd32002e);
3675                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130292);
3676                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc4dfa21);
3677                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x00d107ee);
3678                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0435f91c);
3679                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6850205);
3680                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c430573);
3681                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf5a1f37d);
3682                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x03990fba);
3683                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x05c7f2f8);
3684                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf222050d);
3685                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3686                 break;
3687
3688         case 10200000:
3689                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
3690                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffe);
3691                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdfffe7);
3692                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003f006e);
3693                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffd6ff0f);
3694                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff96014a);
3695                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0197ff1f);
3696                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd05ff3e);
3697                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0037c);
3698                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd59f9b7);
3699                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xff5d0781);
3700                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0585fa56);
3701                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5e4006f);
3702                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf906c4);
3703                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf69df2e0);
3704                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x02790fa2);
3705                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0688f35d);
3706                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1e604d8);
3707                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3708                 break;
3709
3710         case 10300000:
3711                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
3712                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00090005);
3713                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe4ffd6);
3714                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0025007e);
3715                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0014ff20);
3716                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff3c00f0);
3717                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e1ffd0);
3718                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd12fe5c);
3719                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110433);
3720                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe88f996);
3721                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfdf106d1);
3722                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x06aafbb7);
3723                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf57efed8);
3724                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e07ff);
3725                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf7b0f25e);
3726                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x01560f7a);
3727                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0745f3c7);
3728                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1ac04a4);
3729                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3730                 break;
3731
3732         case 10400000:
3733                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
3734                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000c);
3735                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffedffcb);
3736                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0005007d);
3737                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0050ff4c);
3738                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef6007e);
3739                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01ff0086);
3740                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd58fd97);
3741                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104ad);
3742                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xffcaf9c0);
3743                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc9905e2);
3744                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x079afd35);
3745                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf555fd46);
3746                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50920);
3747                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf8d9f1f6);
3748                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x00310f43);
3749                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x07fdf435);
3750                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf174046f);
3751                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3752                 break;
3753
3754         case 10500000:
3755                 cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
3756                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00050011);
3757                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffaffc8);
3758                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5006b);
3759                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0082ff8c);
3760                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecc0000);
3761                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f00130);
3762                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdd2fcfc);
3763                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d04e3);
3764                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x010efa32);
3765                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb6404bf);
3766                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x084efec5);
3767                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf569fbc2);
3768                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000a23);
3769                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfa15f1ab);
3770                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xff0b0efc);
3771                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x08b0f4a7);
3772                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf13f043a);
3773                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3774                 break;
3775
3776         case 10600000:
3777                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3778                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00020012);
3779                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0007ffcd);
3780                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9004c);
3781                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a4ffd9);
3782                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec3ff82);
3783                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01b401c1);
3784                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe76fc97);
3785                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x004404d2);
3786                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0245fae8);
3787                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa5f0370);
3788                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08c1005f);
3789                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5bcfa52);
3790                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x09020b04);
3791                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfb60f17b);
3792                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfde70ea6);
3793                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x095df51e);
3794                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf10c0405);
3795                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3796                 break;
3797
3798         case 10700000:
3799                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3800                 cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0011);
3801                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0014ffdb);
3802                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb40023);
3803                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b2002a);
3804                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedbff10);
3805                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0150022d);
3806                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff38fc6f);
3807                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36047b);
3808                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x035efbda);
3809                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9940202);
3810                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08ee01f5);
3811                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf649f8fe);
3812                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e10bc2);
3813                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfcb6f169);
3814                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfcc60e42);
3815                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0a04f599);
3816                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0db03d0);
3817                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3818                 break;
3819
3820         case 10800000:
3821                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
3822                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffb000d);
3823                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001dffed);
3824                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaafff5);
3825                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00aa0077);
3826                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff13feb6);
3827                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00ce026b);
3828                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x000afc85);
3829                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3503e3);
3830                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x044cfcfb);
3831                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf90c0082);
3832                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08d5037f);
3833                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf710f7cc);
3834                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0c59);
3835                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfe16f173);
3836                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfbaa0dcf);
3837                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0aa5f617);
3838                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0ad039b);
3839                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3840                 break;
3841
3842         case 10900000:
3843                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
3844                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff90006);
3845                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00210003);
3846                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffc8);
3847                 cx25840_write4(client, DIF_BPF_COEFF89, 0x008e00b6);
3848                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff63fe7c);
3849                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x003a0275);
3850                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00dafcda);
3851                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd510313);
3852                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0501fe40);
3853                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8cbfefd);
3854                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x087604f0);
3855                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf80af6c2);
3856                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430cc8);
3857                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xff7af19a);
3858                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfa940d4e);
3859                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0b3ff699);
3860                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0810365);
3861                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3862                 break;
3863
3864         case 11000000:
3865                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
3866                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8ffff);
3867                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00210018);
3868                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffa3);
3869                 cx25840_write4(client, DIF_BPF_COEFF89, 0x006000e1);
3870                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffc4fe68);
3871                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffa0024b);
3872                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x019afd66);
3873                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc990216);
3874                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0575ff99);
3875                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8d4fd81);
3876                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x07d40640);
3877                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf932f5e6);
3878                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20d0d);
3879                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x00dff1de);
3880                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf9860cbf);
3881                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0bd1f71e);
3882                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf058032f);
3883                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3884                 break;
3885
3886         case 11100000:
3887                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
3888                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff8);
3889                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001b0029);
3890                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1ff8a);
3891                 cx25840_write4(client, DIF_BPF_COEFF89, 0x002600f2);
3892                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x002cfe7c);
3893                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff0f01f0);
3894                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x023bfe20);
3895                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc1700fa);
3896                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05a200f7);
3897                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf927fc1c);
3898                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x06f40765);
3899                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa82f53b);
3900                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x02510d27);
3901                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0243f23d);
3902                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf8810c24);
3903                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0c5cf7a7);
3904                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf03102fa);
3905                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3906                 break;
3907
3908         case 11200000:
3909                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
3910                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff2);
3911                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00110035);
3912                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0ff81);
3913                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffe700e7);
3914                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x008ffeb6);
3915                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe94016d);
3916                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b0fefb);
3917                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3ffd1);
3918                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05850249);
3919                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9c1fadb);
3920                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x05de0858);
3921                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfbf2f4c4);
3922                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c70d17);
3923                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x03a0f2b8);
3924                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf7870b7c);
3925                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0cdff833);
3926                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf00d02c4);
3927                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3928                 break;
3929
3930         case 11300000:
3931                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3932                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffdffee);
3933                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00040038);
3934                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0010ff88);
3935                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffac00c2);
3936                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e2ff10);
3937                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe3900cb);
3938                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f1ffe9);
3939                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3feaa);
3940                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05210381);
3941                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa9cf9c8);
3942                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x04990912);
3943                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfd7af484);
3944                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xff390cdb);
3945                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x04f4f34d);
3946                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf69a0ac9);
3947                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0d5af8c1);
3948                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefec028e);
3949                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3950                 break;
3951
3952         case 11400000:
3953                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3954                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0000ffee);
3955                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff60033);
3956                 cx25840_write4(client, DIF_BPF_COEFF67, 0x002fff9f);
3957                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff7b0087);
3958                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x011eff82);
3959                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe080018);
3960                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f900d8);
3961                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fd96);
3962                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x04790490);
3963                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbadf8ed);
3964                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x032f098e);
3965                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xff10f47d);
3966                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaf0c75);
3967                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x063cf3fc);
3968                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf5ba0a0b);
3969                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0dccf952);
3970                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefcd0258);
3971                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3972                 break;
3973
3974         case 11500000:
3975                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
3976                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0004fff1);
3977                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffea0026);
3978                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0046ffc3);
3979                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff5a003c);
3980                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013b0000);
3981                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe04ff63);
3982                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c801b8);
3983                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fca6);
3984                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0397056a);
3985                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfcecf853);
3986                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x01ad09c9);
3987                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x00acf4ad);
3988                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2e0be7);
3989                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0773f4c2);
3990                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4e90943);
3991                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e35f9e6);
3992                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefb10221);
3993                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
3994                 break;
3995
3996         case 11600000:
3997                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
3998                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0007fff6);
3999                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe20014);
4000                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0054ffee);
4001                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4effeb);
4002                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0137007e);
4003                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2efebb);
4004                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0260027a);
4005                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fbe6);
4006                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x02870605);
4007                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfe4af7fe);
4008                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x001d09c1);
4009                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0243f515);
4010                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabd0b32);
4011                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0897f59e);
4012                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4280871);
4013                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e95fa7c);
4014                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef9701eb);
4015                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4016                 break;
4017
4018         case 11700000:
4019                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
4020                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffd);
4021                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffff);
4022                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0056001d);
4023                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff57ff9c);
4024                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x011300f0);
4025                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe82fe2e);
4026                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01ca0310);
4027                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb62);
4028                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0155065a);
4029                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xffbaf7f2);
4030                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe8c0977);
4031                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x03cef5b2);
4032                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf9610a58);
4033                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x09a5f68f);
4034                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3790797);
4035                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0eebfb14);
4036                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef8001b5);
4037                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4038                 break;
4039
4040         case 11800000:
4041                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
4042                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080004);
4043                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffe9);
4044                 cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0047);
4045                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff75ff58);
4046                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d1014a);
4047                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfef9fdc8);
4048                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0111036f);
4049                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb21);
4050                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x00120665);
4051                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x012df82e);
4052                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd0708ec);
4053                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0542f682);
4054                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81f095c);
4055                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a9af792);
4056                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2db06b5);
4057                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f38fbad);
4058                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef6c017e);
4059                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4060                 break;
4061
4062         case 11900000:
4063                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
4064                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0007000b);
4065                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe7ffd8);
4066                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00370068);
4067                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffa4ff28);
4068                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00790184);
4069                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff87fd91);
4070                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00430392);
4071                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb26);
4072                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfece0626);
4073                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0294f8b2);
4074                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb990825);
4075                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0698f77f);
4076                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fe0842);
4077                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b73f8a7);
4078                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf25105cd);
4079                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f7bfc48);
4080                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef5a0148);
4081                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4082                 break;
4083
4084         case 12000000:
4085                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
4086                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00050010);
4087                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff2ffcc);
4088                 cx25840_write4(client, DIF_BPF_COEFF67, 0x001b007b);
4089                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffdfff10);
4090                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00140198);
4091                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0020fd8e);
4092                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff710375);
4093                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfb73);
4094                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd9a059f);
4095                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x03e0f978);
4096                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfa4e0726);
4097                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x07c8f8a7);
4098                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600070c);
4099                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c2ff9c9);
4100                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1db04de);
4101                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fb4fce5);
4102                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef4b0111);
4103                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4104                 break;
4105
4106         case 12100000:
4107                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4108                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00010012);
4109                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffffffc8);
4110                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfffb007e);
4111                 cx25840_write4(client, DIF_BPF_COEFF89, 0x001dff14);
4112                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffad0184);
4113                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00b7fdbe);
4114                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfea9031b);
4115                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fc01);
4116                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc8504d6);
4117                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0504fa79);
4118                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf93005f6);
4119                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x08caf9f2);
4120                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52b05c0);
4121                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0ccbfaf9);
4122                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf17903eb);
4123                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fe3fd83);
4124                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3f00db);
4125                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4126                 break;
4127
4128         case 12200000:
4129                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4130                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffe0011);
4131                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000cffcc);
4132                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffdb0071);
4133                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0058ff32);
4134                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff4f014a);
4135                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x013cfe1f);
4136                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdfb028a);
4137                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fcc9);
4138                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb9d03d6);
4139                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05f4fbad);
4140                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf848049d);
4141                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0999fb5b);
4142                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf4820461);
4143                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d46fc32);
4144                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf12d02f4);
4145                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x1007fe21);
4146                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3600a4);
4147                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4148                 break;
4149
4150         case 12300000:
4151                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
4152                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa000e);
4153                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0017ffd9);
4154                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc10055);
4155                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0088ff68);
4156                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff0400f0);
4157                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01a6fea7);
4158                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd7501cc);
4159                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0fdc0);
4160                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaef02a8);
4161                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06a7fd07);
4162                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf79d0326);
4163                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a31fcda);
4164                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf40702f3);
4165                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d9ffd72);
4166                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0f601fa);
4167                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x1021fec0);
4168                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2f006d);
4169                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4170                 break;
4171
4172         case 12400000:
4173                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
4174                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80007);
4175                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001fffeb);
4176                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaf002d);
4177                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a8ffb0);
4178                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed3007e);
4179                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e9ff4c);
4180                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd2000ee);
4181                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413fed8);
4182                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa82015c);
4183                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0715fe7d);
4184                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7340198);
4185                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a8dfe69);
4186                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bd017c);
4187                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dd5feb8);
4188                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0d500fd);
4189                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x1031ff60);
4190                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2b0037);
4191                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4192                 break;
4193
4194         case 12500000:
4195                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
4196                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff70000);
4197                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00220000);
4198                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffa90000);
4199                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b30000);
4200                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec20000);
4201                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x02000000);
4202                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd030000);
4203                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x04350000);
4204                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa5e0000);
4205                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x073b0000);
4206                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7110000);
4207                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aac0000);
4208                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3a40000);
4209                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de70000);
4210                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0c90000);
4211                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x10360000);
4212                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef290000);
4213                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4214                 break;
4215
4216         case 12600000:
4217                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
4218                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff9);
4219                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001f0015);
4220                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffafffd3);
4221                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a80050);
4222                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed3ff82);
4223                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e900b4);
4224                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd20ff12);
4225                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130128);
4226                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa82fea4);
4227                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x07150183);
4228                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf734fe68);
4229                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a8d0197);
4230                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdfe84);
4231                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dd50148);
4232                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0d5ff03);
4233                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x103100a0);
4234                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2bffc9);
4235                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4236                 break;
4237
4238         case 12700000:
4239                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
4240                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff2);
4241                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00170027);
4242                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1ffab);
4243                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00880098);
4244                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff04ff10);
4245                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01a60159);
4246                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd75fe34);
4247                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00240);
4248                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaeffd58);
4249                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06a702f9);
4250                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf79dfcda);
4251                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a310326);
4252                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407fd0d);
4253                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d9f028e);
4254                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0f6fe06);
4255                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x10210140);
4256                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2fff93);
4257                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4258                 break;
4259
4260         case 12800000:
4261                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4262                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffeffef);
4263                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000c0034);
4264                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffdbff8f);
4265                 cx25840_write4(client, DIF_BPF_COEFF89, 0x005800ce);
4266                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff4ffeb6);
4267                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x013c01e1);
4268                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdfbfd76);
4269                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110337);
4270                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb9dfc2a);
4271                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05f40453);
4272                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf848fb63);
4273                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x099904a5);
4274                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482fb9f);
4275                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d4603ce);
4276                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf12dfd0c);
4277                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x100701df);
4278                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef36ff5c);
4279                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4280                 break;
4281
4282         case 12900000:
4283                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4284                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0001ffee);
4285                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffff0038);
4286                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfffbff82);
4287                 cx25840_write4(client, DIF_BPF_COEFF89, 0x001d00ec);
4288                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffadfe7c);
4289                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00b70242);
4290                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfea9fce5);
4291                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x024103ff);
4292                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc85fb2a);
4293                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05040587);
4294                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf930fa0a);
4295                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x08ca060e);
4296                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bfa40);
4297                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0ccb0507);
4298                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf179fc15);
4299                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fe3027d);
4300                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3fff25);
4301                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4302                 break;
4303
4304         case 13000000:
4305                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
4306                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0005fff0);
4307                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff20034);
4308                 cx25840_write4(client, DIF_BPF_COEFF67, 0x001bff85);
4309                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffdf00f0);
4310                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0014fe68);
4311                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00200272);
4312                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff71fc8b);
4313                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d048d);
4314                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd9afa61);
4315                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x03e00688);
4316                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfa4ef8da);
4317                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x07c80759);
4318                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f8f4);
4319                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c2f0637);
4320                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1dbfb22);
4321                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fb4031b);
4322                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef4bfeef);
4323                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4324                 break;
4325
4326         case 13100000:
4327                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
4328                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0007fff5);
4329                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe70028);
4330                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0037ff98);
4331                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffa400d8);
4332                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0079fe7c);
4333                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff87026f);
4334                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0043fc6e);
4335                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x004404da);
4336                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfecef9da);
4337                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0294074e);
4338                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb99f7db);
4339                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x06980881);
4340                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef7be);
4341                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b730759);
4342                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf251fa33);
4343                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f7b03b8);
4344                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef5afeb8);
4345                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4346                 break;
4347
4348         case 13200000:
4349                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
4350                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffc);
4351                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe00017);
4352                 cx25840_write4(client, DIF_BPF_COEFF67, 0x004cffb9);
4353                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff7500a8);
4354                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d1feb6);
4355                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfef90238);
4356                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0111fc91);
4357                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3604df);
4358                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0012f99b);
4359                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x012d07d2);
4360                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd07f714);
4361                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0542097e);
4362                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff6a4);
4363                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a9a086e);
4364                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2dbf94b);
4365                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f380453);
4366                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef6cfe82);
4367                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4368                 break;
4369
4370         case 13300000:
4371                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
4372                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080003);
4373                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffde0001);
4374                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0056ffe3);
4375                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff570064);
4376                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0113ff10);
4377                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe8201d2);
4378                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01cafcf0);
4379                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35049e);
4380                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0155f9a6);
4381                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xffba080e);
4382                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe8cf689);
4383                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x03ce0a4e);
4384                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f5a8);
4385                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x09a50971);
4386                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf379f869);
4387                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0eeb04ec);
4388                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef80fe4b);
4389                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4390                 break;
4391
4392         case 13400000:
4393                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
4394                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0007000a);
4395                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe2ffec);
4396                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00540012);
4397                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4e0015);
4398                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0137ff82);
4399                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2e0145);
4400                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0260fd86);
4401                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51041a);
4402                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0287f9fb);
4403                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfe4a0802);
4404                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x001df63f);
4405                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x02430aeb);
4406                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf4ce);
4407                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x08970a62);
4408                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf428f78f);
4409                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e950584);
4410                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xef97fe15);
4411                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4412                 break;
4413
4414         case 13500000:
4415                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4416                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0004000f);
4417                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffeaffda);
4418                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0046003d);
4419                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff5affc4);
4420                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013b0000);
4421                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe04009d);
4422                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c8fe48);
4423                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99035a);
4424                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0397fa96);
4425                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfcec07ad);
4426                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x01adf637);
4427                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x00ac0b53);
4428                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef419);
4429                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x07730b3e);
4430                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4e9f6bd);
4431                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e35061a);
4432                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefb1fddf);
4433                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4434                 break;
4435
4436         case 13600000:
4437                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4438                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00000012);
4439                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfff6ffcd);
4440                 cx25840_write4(client, DIF_BPF_COEFF67, 0x002f0061);
4441                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff7bff79);
4442                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x011e007e);
4443                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe08ffe8);
4444                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f9ff28);
4445                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17026a);
4446                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0479fb70);
4447                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbad0713);
4448                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x032ff672);
4449                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xff100b83);
4450                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff38b);
4451                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x063c0c04);
4452                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf5baf5f5);
4453                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0dcc06ae);
4454                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefcdfda8);
4455                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4456                 break;
4457
4458         case 13700000:
4459                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4460                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd0012);
4461                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0004ffc8);
4462                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00100078);
4463                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffacff3e);
4464                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e200f0);
4465                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe39ff35);
4466                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f10017);
4467                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd30156);
4468                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0521fc7f);
4469                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa9c0638);
4470                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0499f6ee);
4471                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfd7a0b7c);
4472                 cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f325);
4473                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x04f40cb3);
4474                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf69af537);
4475                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0d5a073f);
4476                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xefecfd72);
4477                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4478                 break;
4479
4480         case 13800000:
4481                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001fffe);
4482                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa000e);
4483                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0011ffcb);
4484                 cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0007f);
4485                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffe7ff19);
4486                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x008f014a);
4487                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe94fe93);
4488                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b00105);
4489                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3002f);
4490                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x0585fdb7);
4491                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9c10525);
4492                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x05def7a8);
4493                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfbf20b3c);
4494                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7f2e9);
4495                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x03a00d48);
4496                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf787f484);
4497                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0cdf07cd);
4498                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf00dfd3c);
4499                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4500                 break;
4501
4502         case 13900000:
4503                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
4504                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80008);
4505                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001bffd7);
4506                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffd10076);
4507                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0026ff0e);
4508                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x002c0184);
4509                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff0ffe10);
4510                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x023b01e0);
4511                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17ff06);
4512                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05a2ff09);
4513                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf92703e4);
4514                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x06f4f89b);
4515                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa820ac5);
4516                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251f2d9);
4517                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x02430dc3);
4518                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf881f3dc);
4519                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0c5c0859);
4520                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf031fd06);
4521                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4522                 break;
4523
4524         case 14000000:
4525                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
4526                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80001);
4527                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0021ffe8);
4528                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffba005d);
4529                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0060ff1f);
4530                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffc40198);
4531                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xffa0fdb5);
4532                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x019a029a);
4533                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fdea);
4534                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x05750067);
4535                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8d4027f);
4536                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x07d4f9c0);
4537                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf9320a1a);
4538                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2f2f3);
4539                 cx25840_write4(client, DIF_BPF_COEFF2829, 0x00df0e22);
4540                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xf986f341);
4541                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0bd108e2);
4542                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf058fcd1);
4543                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4544                 break;
4545
4546         case 14100000:
4547                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
4548                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffa);
4549                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0021fffd);
4550                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffac0038);
4551                 cx25840_write4(client, DIF_BPF_COEFF89, 0x008eff4a);
4552                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff630184);
4553                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x003afd8b);
4554                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x00da0326);
4555                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fced);
4556                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x050101c0);
4557                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8cb0103);
4558                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x0876fb10);
4559                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf80a093e);
4560                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543f338);
4561                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xff7a0e66);
4562                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfa94f2b2);
4563                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0b3f0967);
4564                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf081fc9b);
4565                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4566                 break;
4567
4568         case 14200000:
4569                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4570                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbfff3);
4571                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001d0013);
4572                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaa000b);
4573                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00aaff89);
4574                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff13014a);
4575                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00cefd95);
4576                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x000a037b);
4577                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fc1d);
4578                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x044c0305);
4579                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf90cff7e);
4580                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08d5fc81);
4581                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7100834);
4582                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069ff3a7);
4583                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfe160e8d);
4584                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfbaaf231);
4585                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0aa509e9);
4586                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0adfc65);
4587                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4588                 break;
4589
4590         case 14300000:
4591                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4592                 cx25840_write4(client, DIF_BPF_COEFF23, 0xffffffef);
4593                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00140025);
4594                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ffdd);
4595                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00b2ffd6);
4596                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedb00f0);
4597                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x0150fdd3);
4598                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xff380391);
4599                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb85);
4600                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x035e0426);
4601                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xf994fdfe);
4602                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08eefe0b);
4603                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6490702);
4604                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1f43e);
4605                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfcb60e97);
4606                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfcc6f1be);
4607                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x0a040a67);
4608                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0dbfc30);
4609                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4610                 break;
4611
4612         case 14400000:
4613                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4614                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0002ffee);
4615                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00070033);
4616                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ffb4);
4617                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00a40027);
4618                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec3007e);
4619                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01b4fe3f);
4620                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe760369);
4621                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb2e);
4622                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x02450518);
4623                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa5ffc90);
4624                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x08c1ffa1);
4625                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5bc05ae);
4626                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902f4fc);
4627                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfb600e85);
4628                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xfde7f15a);
4629                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x095d0ae2);
4630                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf10cfbfb);
4631                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4632                 break;
4633
4634         case 14500000:
4635                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0002);
4636                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0005ffef);
4637                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffa0038);
4638                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff95);
4639                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00820074);
4640                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecc0000);
4641                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f0fed0);
4642                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdd20304);
4643                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfb1d);
4644                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x010e05ce);
4645                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb64fb41);
4646                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x084e013b);
4647                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf569043e);
4648                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a00f5dd);
4649                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xfa150e55);
4650                 cx25840_write4(client, DIF_BPF_COEFF3031, 0xff0bf104);
4651                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x08b00b59);
4652                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf13ffbc6);
4653                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4654                 break;
4655
4656         case 14600000:
4657                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
4658                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fff4);
4659                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffed0035);
4660                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ff83);
4661                 cx25840_write4(client, DIF_BPF_COEFF89, 0x005000b4);
4662                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef6ff82);
4663                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01ffff7a);
4664                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd580269);
4665                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fb53);
4666                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xffca0640);
4667                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc99fa1e);
4668                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x079a02cb);
4669                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55502ba);
4670                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad5f6e0);
4671                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf8d90e0a);
4672                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0031f0bd);
4673                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x07fd0bcb);
4674                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf174fb91);
4675                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4676                 break;
4677
4678         case 14700000:
4679                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
4680                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0009fffb);
4681                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe4002a);
4682                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ff82);
4683                 cx25840_write4(client, DIF_BPF_COEFF89, 0x001400e0);
4684                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff3cff10);
4685                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e10030);
4686                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd1201a4);
4687                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fbcd);
4688                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe88066a);
4689                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xfdf1f92f);
4690                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x06aa0449);
4691                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf57e0128);
4692                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7ef801);
4693                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf7b00da2);
4694                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0156f086);
4695                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x07450c39);
4696                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1acfb5c);
4697                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4698                 break;
4699
4700         case 14800000:
4701                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
4702                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00080002);
4703                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdf0019);
4704                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003fff92);
4705                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffd600f1);
4706                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff96feb6);
4707                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x019700e1);
4708                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd0500c2);
4709                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0fc84);
4710                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd590649);
4711                 cx25840_write4(client, DIF_BPF_COEFF2021, 0xff5df87f);
4712                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x058505aa);
4713                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5e4ff91);
4714                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf9f93c);
4715                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf69d0d20);
4716                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0279f05e);
4717                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x06880ca3);
4718                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1e6fb28);
4719                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4720                 break;
4721
4722         case 14900000:
4723                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4724                 cx25840_write4(client, DIF_BPF_COEFF23, 0x00060009);
4725                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffdf0004);
4726                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0051ffb0);
4727                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff9d00e8);
4728                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xfffcfe7c);
4729                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x01280180);
4730                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd32ffd2);
4731                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413fd6e);
4732                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc4d05df);
4733                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x00d1f812);
4734                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x043506e4);
4735                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf685fdfb);
4736                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c43fa8d);
4737                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf5a10c83);
4738                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0399f046);
4739                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x05c70d08);
4740                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf222faf3);
4741                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4742                 break;
4743
4744         case 15000000:
4745                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4746                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0003000f);
4747                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffe5ffef);
4748                 cx25840_write4(client, DIF_BPF_COEFF67, 0x0057ffd9);
4749                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff7000c4);
4750                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0062fe68);
4751                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x009e01ff);
4752                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd95fee6);
4753                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0435fe7d);
4754                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb710530);
4755                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x023cf7ee);
4756                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x02c307ef);
4757                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf75efc70);
4758                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5cfbef);
4759                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf4c10bce);
4760                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x04b3f03f);
4761                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x05030d69);
4762                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf261fabf);
4763                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4764                 break;
4765
4766         case 15100000:
4767                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
4768                 cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0012);
4769                 cx25840_write4(client, DIF_BPF_COEFF45, 0xffefffdc);
4770                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00510006);
4771                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff540089);
4772                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00befe7c);
4773                 cx25840_write4(client, DIF_BPF_COEFF1213, 0x00060253);
4774                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe27fe0d);
4775                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413ffa2);
4776                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfad10446);
4777                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0390f812);
4778                 cx25840_write4(client, DIF_BPF_COEFF2223, 0x013b08c3);
4779                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf868faf6);
4780                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c43fd5f);
4781                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3fd0b02);
4782                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x05c7f046);
4783                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x043b0dc4);
4784                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2a1fa8b);
4785                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4786                 break;
4787
4788         case 15200000:
4789                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001fffe);
4790                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc0012);
4791                 cx25840_write4(client, DIF_BPF_COEFF45, 0xfffbffce);
4792                 cx25840_write4(client, DIF_BPF_COEFF67, 0x003f0033);
4793                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff4e003f);
4794                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0106feb6);
4795                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff6e0276);
4796                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xfeddfd56);
4797                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b000cc);
4798                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa740329);
4799                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x04bff87f);
4800                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xffaa095d);
4801                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xf99ef995);
4802                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf9fed8);
4803                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3590a1f);
4804                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x06d2f05e);
4805                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x03700e1b);
4806                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2e4fa58);
4807                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4808                 break;
4809
4810         case 15300000:
4811                 cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
4812                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9000f);
4813                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0009ffc8);
4814                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00250059);
4815                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff5effee);
4816                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0132ff10);
4817                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfee30265);
4818                 cx25840_write4(client, DIF_BPF_COEFF1415, 0xffaafccf);
4819                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x031101eb);
4820                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa6001e8);
4821                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x05bdf92f);
4822                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe1b09b6);
4823                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfafaf852);
4824                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0055);
4825                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2d50929);
4826                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x07d3f086);
4827                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x02a30e6c);
4828                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf329fa24);
4829                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4830                 break;
4831
4832         case 15400000:
4833                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
4834                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80009);
4835                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0015ffca);
4836                 cx25840_write4(client, DIF_BPF_COEFF67, 0x00050074);
4837                 cx25840_write4(client, DIF_BPF_COEFF89, 0xff81ff9f);
4838                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x013dff82);
4839                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe710221);
4840                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x007cfc80);
4841                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x024102ed);
4842                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa940090);
4843                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0680fa1e);
4844                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc9b09cd);
4845                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfc73f736);
4846                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad501d0);
4847                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2740820);
4848                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x08c9f0bd);
4849                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x01d40eb9);
4850                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf371f9f1);
4851                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4852                 break;
4853
4854         case 15500000:
4855                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
4856                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80002);
4857                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001effd5);
4858                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5007f);
4859                 cx25840_write4(client, DIF_BPF_COEFF89, 0xffb4ff5b);
4860                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x01280000);
4861                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2401b0);
4862                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0146fc70);
4863                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d03c6);
4864                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb10ff32);
4865                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0701fb41);
4866                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb3709a1);
4867                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe00f644);
4868                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000345);
4869                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2350708);
4870                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x09b2f104);
4871                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x01050eff);
4872                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf3baf9be);
4873                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4874                 break;
4875
4876         case 15600000:
4877                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4878                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffb);
4879                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0022ffe6);
4880                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9007a);
4881                 cx25840_write4(client, DIF_BPF_COEFF89, 0xfff0ff29);
4882                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f2007e);
4883                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01011b);
4884                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x01f6fc9e);
4885                 cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440467);
4886                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbccfdde);
4887                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0738fc90);
4888                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9f70934);
4889                 cx25840_write4(client, DIF_BPF_COEFF2425, 0xff99f582);
4890                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x090204b0);
4891                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21a05e1);
4892                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0a8df15a);
4893                 cx25840_write4(client, DIF_BPF_COEFF3233, 0x00340f41);
4894                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf405f98b);
4895                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4896                 break;
4897
4898         case 15700000:
4899                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4900                 cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcfff4);
4901                 cx25840_write4(client, DIF_BPF_COEFF45, 0x0020fffa);
4902                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffb40064);
4903                 cx25840_write4(client, DIF_BPF_COEFF89, 0x002fff11);
4904                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x00a400f0);
4905                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0d006e);
4906                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x0281fd09);
4907                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3604c9);
4908                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcbffca2);
4909                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0726fdfe);
4910                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8e80888);
4911                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x0134f4f3);
4912                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1060c);
4913                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf22304af);
4914                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b59f1be);
4915                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xff640f7d);
4916                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf452f959);
4917                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4918                 break;
4919
4920         case 15800000:
4921                 cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
4922                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0000fff0);
4923                 cx25840_write4(client, DIF_BPF_COEFF45, 0x001a0010);
4924                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffaa0041);
4925                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0067ff13);
4926                 cx25840_write4(client, DIF_BPF_COEFF1011, 0x0043014a);
4927                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe46ffb9);
4928                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02dbfda8);
4929                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3504e5);
4930                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xfddcfb8d);
4931                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c9ff7e);
4932                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf81107a2);
4933                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c9f49a);
4934                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0753);
4935                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2500373);
4936                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c14f231);
4937                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe930fb3);
4938                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4a1f927);
4939                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4940                 break;
4941
4942         case 15900000:
4943                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0002);
4944                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0003ffee);
4945                 cx25840_write4(client, DIF_BPF_COEFF45, 0x000f0023);
4946                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffac0016);
4947                 cx25840_write4(client, DIF_BPF_COEFF89, 0x0093ff31);
4948                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xffdc0184);
4949                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea6ff09);
4950                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fdfe70);
4951                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd5104ba);
4952                 cx25840_write4(client, DIF_BPF_COEFF1819, 0xff15faac);
4953                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x06270103);
4954                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7780688);
4955                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x044df479);
4956                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430883);
4957                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a00231);
4958                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cbef2b2);
4959                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc40fe3);
4960                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4f2f8f5);
4961                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4962                 break;
4963
4964         case 16000000:
4965                 cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
4966                 cx25840_write4(client, DIF_BPF_COEFF23, 0x0006ffef);
4967                 cx25840_write4(client, DIF_BPF_COEFF45, 0x00020031);
4968                 cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffe8);
4969                 cx25840_write4(client, DIF_BPF_COEFF89, 0x00adff66);
4970                 cx25840_write4(client, DIF_BPF_COEFF1011, 0xff790198);
4971                 cx25840_write4(client, DIF_BPF_COEFF1213, 0xff26fe6e);
4972                 cx25840_write4(client, DIF_BPF_COEFF1415, 0x02e5ff55);
4973                 cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99044a);
4974                 cx25840_write4(client, DIF_BPF_COEFF1819, 0x005bfa09);
4975                 cx25840_write4(client, DIF_BPF_COEFF2021, 0x0545027f);
4976                 cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7230541);
4977                 cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b8f490);
4978                 cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20997);
4979                 cx25840_write4(client, DIF_BPF_COEFF2829, 0xf31300eb);
4980                 cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d55f341);
4981                 cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6100e);
4982                 cx25840_write4(client, DIF_BPF_COEFF3435, 0xf544f8c3);
4983                 cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
4984                 break;
4985         }
4986 }
4987
4988 static void cx23888_std_setup(struct i2c_client *client)
4989 {
4990         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
4991         v4l2_std_id std = state->std;
4992         u32 ifHz;
4993
4994         cx25840_write4(client, 0x478, 0x6628021F);
4995         cx25840_write4(client, 0x400, 0x0);
4996         cx25840_write4(client, 0x4b4, 0x20524030);
4997         cx25840_write4(client, 0x47c, 0x010a8263);
4998
4999         if (std & V4L2_STD_NTSC) {
5000                 v4l_dbg(1, cx25840_debug, client, "%s() Selecting NTSC",
5001                         __func__);
5002
5003                 /* Horiz / vert timing */
5004                 cx25840_write4(client, 0x428, 0x1e1e601a);
5005                 cx25840_write4(client, 0x424, 0x5b2d007a);
5006
5007                 /* DIF NTSC */
5008                 cx25840_write4(client, 0x304, 0x6503bc0c);
5009                 cx25840_write4(client, 0x308, 0xbd038c85);
5010                 cx25840_write4(client, 0x30c, 0x1db4640a);
5011                 cx25840_write4(client, 0x310, 0x00008800);
5012                 cx25840_write4(client, 0x314, 0x44400400);
5013                 cx25840_write4(client, 0x32c, 0x0c800800);
5014                 cx25840_write4(client, 0x330, 0x27000100);
5015                 cx25840_write4(client, 0x334, 0x1f296e1f);
5016                 cx25840_write4(client, 0x338, 0x009f50c1);
5017                 cx25840_write4(client, 0x340, 0x1befbf06);
5018                 cx25840_write4(client, 0x344, 0x000035e8);
5019
5020                 /* DIF I/F */
5021                 ifHz = 5400000;
5022
5023         } else {
5024                 v4l_dbg(1, cx25840_debug, client, "%s() Selecting PAL-BG",
5025                         __func__);
5026
5027                 /* Horiz / vert timing */
5028                 cx25840_write4(client, 0x428, 0x28244024);
5029                 cx25840_write4(client, 0x424, 0x5d2d0084);
5030
5031                 /* DIF */
5032                 cx25840_write4(client, 0x304, 0x6503bc0c);
5033                 cx25840_write4(client, 0x308, 0xbd038c85);
5034                 cx25840_write4(client, 0x30c, 0x1db4640a);
5035                 cx25840_write4(client, 0x310, 0x00008800);
5036                 cx25840_write4(client, 0x314, 0x44400600);
5037                 cx25840_write4(client, 0x32c, 0x0c800800);
5038                 cx25840_write4(client, 0x330, 0x27000100);
5039                 cx25840_write4(client, 0x334, 0x213530ec);
5040                 cx25840_write4(client, 0x338, 0x00a65ba8);
5041                 cx25840_write4(client, 0x340, 0x1befbf06);
5042                 cx25840_write4(client, 0x344, 0x000035e8);
5043
5044                 /* DIF I/F */
5045                 ifHz = 6000000;
5046         }
5047
5048         cx23885_dif_setup(client, ifHz);
5049
5050         /* Explicitly ensure the inputs are reconfigured after
5051          * a standard change.
5052          */
5053         set_input(client, state->vid_input, state->aud_input);
5054 }
5055
5056 /* ----------------------------------------------------------------------- */
5057
5058 static const struct v4l2_ctrl_ops cx25840_ctrl_ops = {
5059         .s_ctrl = cx25840_s_ctrl,
5060 };
5061
5062 static const struct v4l2_subdev_core_ops cx25840_core_ops = {
5063         .log_status = cx25840_log_status,
5064         .g_ctrl = v4l2_subdev_g_ctrl,
5065         .s_ctrl = v4l2_subdev_s_ctrl,
5066         .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
5067         .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
5068         .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
5069         .queryctrl = v4l2_subdev_queryctrl,
5070         .querymenu = v4l2_subdev_querymenu,
5071         .reset = cx25840_reset,
5072         .load_fw = cx25840_load_fw,
5073         .s_io_pin_config = common_s_io_pin_config,
5074 #ifdef CONFIG_VIDEO_ADV_DEBUG
5075         .g_register = cx25840_g_register,
5076         .s_register = cx25840_s_register,
5077 #endif
5078         .interrupt_service_routine = cx25840_irq_handler,
5079 };
5080
5081 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
5082         .s_frequency = cx25840_s_frequency,
5083         .s_radio = cx25840_s_radio,
5084         .g_tuner = cx25840_g_tuner,
5085         .s_tuner = cx25840_s_tuner,
5086 };
5087
5088 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
5089         .s_clock_freq = cx25840_s_clock_freq,
5090         .s_routing = cx25840_s_audio_routing,
5091         .s_stream = cx25840_s_audio_stream,
5092 };
5093
5094 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
5095         .s_std = cx25840_s_std,
5096         .g_std = cx25840_g_std,
5097         .s_routing = cx25840_s_video_routing,
5098         .s_stream = cx25840_s_stream,
5099         .g_input_status = cx25840_g_input_status,
5100 };
5101
5102 static const struct v4l2_subdev_vbi_ops cx25840_vbi_ops = {
5103         .decode_vbi_line = cx25840_decode_vbi_line,
5104         .s_raw_fmt = cx25840_s_raw_fmt,
5105         .s_sliced_fmt = cx25840_s_sliced_fmt,
5106         .g_sliced_fmt = cx25840_g_sliced_fmt,
5107 };
5108
5109 static const struct v4l2_subdev_pad_ops cx25840_pad_ops = {
5110         .set_fmt = cx25840_set_fmt,
5111 };
5112
5113 static const struct v4l2_subdev_ops cx25840_ops = {
5114         .core = &cx25840_core_ops,
5115         .tuner = &cx25840_tuner_ops,
5116         .audio = &cx25840_audio_ops,
5117         .video = &cx25840_video_ops,
5118         .vbi = &cx25840_vbi_ops,
5119         .pad = &cx25840_pad_ops,
5120         .ir = &cx25840_ir_ops,
5121 };
5122
5123 /* ----------------------------------------------------------------------- */
5124
5125 static u32 get_cx2388x_ident(struct i2c_client *client)
5126 {
5127         u32 ret;
5128
5129         /* Come out of digital power down */
5130         cx25840_write(client, 0x000, 0);
5131
5132         /* Detecting whether the part is cx23885/7/8 is more
5133          * difficult than it needs to be. No ID register. Instead we
5134          * probe certain registers indicated in the datasheets to look
5135          * for specific defaults that differ between the silicon designs. */
5136
5137         /* It's either 885/7 if the IR Tx Clk Divider register exists */
5138         if (cx25840_read4(client, 0x204) & 0xffff) {
5139                 /* CX23885 returns bogus repetitive byte values for the DIF,
5140                  * which doesn't exist for it. (Ex. 8a8a8a8a or 31313131) */
5141                 ret = cx25840_read4(client, 0x300);
5142                 if (((ret & 0xffff0000) >> 16) == (ret & 0xffff)) {
5143                         /* No DIF */
5144                         ret = CX23885_AV;
5145                 } else {
5146                         /* CX23887 has a broken DIF, but the registers
5147                          * appear valid (but unused), good enough to detect. */
5148                         ret = CX23887_AV;
5149                 }
5150         } else if (cx25840_read4(client, 0x300) & 0x0fffffff) {
5151                 /* DIF PLL Freq Word reg exists; chip must be a CX23888 */
5152                 ret = CX23888_AV;
5153         } else {
5154                 v4l_err(client, "Unable to detect h/w, assuming cx23887\n");
5155                 ret = CX23887_AV;
5156         }
5157
5158         /* Back into digital power down */
5159         cx25840_write(client, 0x000, 2);
5160         return ret;
5161 }
5162
5163 static int cx25840_probe(struct i2c_client *client,
5164                          const struct i2c_device_id *did)
5165 {
5166         struct cx25840_state *state;
5167         struct v4l2_subdev *sd;
5168         int default_volume;
5169         u32 id;
5170         u16 device_id;
5171 #if defined(CONFIG_MEDIA_CONTROLLER)
5172         int ret;
5173 #endif
5174
5175         /* Check if the adapter supports the needed features */
5176         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
5177                 return -EIO;
5178
5179         v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
5180
5181         device_id = cx25840_read(client, 0x101) << 8;
5182         device_id |= cx25840_read(client, 0x100);
5183         v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
5184
5185         /* The high byte of the device ID should be
5186          * 0x83 for the cx2583x and 0x84 for the cx2584x */
5187         if ((device_id & 0xff00) == 0x8300) {
5188                 id = CX25836 + ((device_id >> 4) & 0xf) - 6;
5189         } else if ((device_id & 0xff00) == 0x8400) {
5190                 id = CX25840 + ((device_id >> 4) & 0xf);
5191         } else if (device_id == 0x0000) {
5192                 id = get_cx2388x_ident(client);
5193         } else if ((device_id & 0xfff0) == 0x5A30) {
5194                 /* The CX23100 (0x5A3C = 23100) doesn't have an A/V decoder */
5195                 id = CX2310X_AV;
5196         } else if ((device_id & 0xff) == (device_id >> 8)) {
5197                 v4l_err(client,
5198                         "likely a confused/unresponsive cx2388[578] A/V decoder"
5199                         " found @ 0x%x (%s)\n",
5200                         client->addr << 1, client->adapter->name);
5201                 v4l_err(client, "A method to reset it from the cx25840 driver"
5202                         " software is not known at this time\n");
5203                 return -ENODEV;
5204         } else {
5205                 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
5206                 return -ENODEV;
5207         }
5208
5209         state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL);
5210         if (state == NULL)
5211                 return -ENOMEM;
5212
5213         sd = &state->sd;
5214         v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
5215 #if defined(CONFIG_MEDIA_CONTROLLER)
5216         /*
5217          * TODO: add media controller support for analog video inputs like
5218          * composite, svideo, etc.
5219          * A real input pad for this analog demod would be like:
5220          *                 ___________
5221          * TUNER --------> |         |
5222          *                 |         |
5223          * SVIDEO .......> | cx25840 |
5224          *                 |         |
5225          * COMPOSITE1 ...> |_________|
5226          *
5227          * However, at least for now, there's no much gain on modelling
5228          * those extra inputs. So, let's add it only when needed.
5229          */
5230         state->pads[CX25840_PAD_INPUT].flags = MEDIA_PAD_FL_SINK;
5231         state->pads[CX25840_PAD_VID_OUT].flags = MEDIA_PAD_FL_SOURCE;
5232         state->pads[CX25840_PAD_VBI_OUT].flags = MEDIA_PAD_FL_SOURCE;
5233         sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_DECODER;
5234
5235         ret = media_entity_init(&sd->entity, ARRAY_SIZE(state->pads),
5236                                 state->pads, 0);
5237         if (ret < 0) {
5238                 v4l_info(client, "failed to initialize media entity!\n");
5239                 return ret;
5240         }
5241 #endif
5242
5243         switch (id) {
5244         case CX23885_AV:
5245                 v4l_info(client, "cx23885 A/V decoder found @ 0x%x (%s)\n",
5246                          client->addr << 1, client->adapter->name);
5247                 break;
5248         case CX23887_AV:
5249                 v4l_info(client, "cx23887 A/V decoder found @ 0x%x (%s)\n",
5250                          client->addr << 1, client->adapter->name);
5251                 break;
5252         case CX23888_AV:
5253                 v4l_info(client, "cx23888 A/V decoder found @ 0x%x (%s)\n",
5254                          client->addr << 1, client->adapter->name);
5255                 break;
5256         case CX2310X_AV:
5257                 v4l_info(client, "cx%d A/V decoder found @ 0x%x (%s)\n",
5258                          device_id, client->addr << 1, client->adapter->name);
5259                 break;
5260         case CX25840:
5261         case CX25841:
5262         case CX25842:
5263         case CX25843:
5264                 /* Note: revision '(device_id & 0x0f) == 2' was never built. The
5265                    marking skips from 0x1 == 22 to 0x3 == 23. */
5266                 v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
5267                          (device_id & 0xfff0) >> 4,
5268                          (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1
5269                                                 : (device_id & 0x0f),
5270                          client->addr << 1, client->adapter->name);
5271                 break;
5272         case CX25836:
5273         case CX25837:
5274         default:
5275                 v4l_info(client, "cx25%3x-%x found @ 0x%x (%s)\n",
5276                          (device_id & 0xfff0) >> 4, device_id & 0x0f,
5277                          client->addr << 1, client->adapter->name);
5278                 break;
5279         }
5280
5281         state->c = client;
5282         state->vid_input = CX25840_COMPOSITE7;
5283         state->aud_input = CX25840_AUDIO8;
5284         state->audclk_freq = 48000;
5285         state->audmode = V4L2_TUNER_MODE_LANG1;
5286         state->vbi_line_offset = 8;
5287         state->id = id;
5288         state->rev = device_id;
5289         v4l2_ctrl_handler_init(&state->hdl, 9);
5290         v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops,
5291                         V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
5292         v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops,
5293                         V4L2_CID_CONTRAST, 0, 127, 1, 64);
5294         v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops,
5295                         V4L2_CID_SATURATION, 0, 127, 1, 64);
5296         v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops,
5297                         V4L2_CID_HUE, -128, 127, 1, 0);
5298         if (!is_cx2583x(state)) {
5299                 default_volume = cx25840_read(client, 0x8d4);
5300                 /*
5301                  * Enforce the legacy PVR-350/MSP3400 to PVR-150/CX25843 volume
5302                  * scale mapping limits to avoid -ERANGE errors when
5303                  * initializing the volume control
5304                  */
5305                 if (default_volume > 228) {
5306                         /* Bottom out at -96 dB, v4l2 vol range 0x2e00-0x2fff */
5307                         default_volume = 228;
5308                         cx25840_write(client, 0x8d4, 228);
5309                 }
5310                 else if (default_volume < 20) {
5311                         /* Top out at + 8 dB, v4l2 vol range 0xfe00-0xffff */
5312                         default_volume = 20;
5313                         cx25840_write(client, 0x8d4, 20);
5314                 }
5315                 default_volume = (((228 - default_volume) >> 1) + 23) << 9;
5316
5317                 state->volume = v4l2_ctrl_new_std(&state->hdl,
5318                         &cx25840_audio_ctrl_ops, V4L2_CID_AUDIO_VOLUME,
5319                         0, 65535, 65535 / 100, default_volume);
5320                 state->mute = v4l2_ctrl_new_std(&state->hdl,
5321                         &cx25840_audio_ctrl_ops, V4L2_CID_AUDIO_MUTE,
5322                         0, 1, 1, 0);
5323                 v4l2_ctrl_new_std(&state->hdl, &cx25840_audio_ctrl_ops,
5324                         V4L2_CID_AUDIO_BALANCE,
5325                         0, 65535, 65535 / 100, 32768);
5326                 v4l2_ctrl_new_std(&state->hdl, &cx25840_audio_ctrl_ops,
5327                         V4L2_CID_AUDIO_BASS,
5328                         0, 65535, 65535 / 100, 32768);
5329                 v4l2_ctrl_new_std(&state->hdl, &cx25840_audio_ctrl_ops,
5330                         V4L2_CID_AUDIO_TREBLE,
5331                         0, 65535, 65535 / 100, 32768);
5332         }
5333         sd->ctrl_handler = &state->hdl;
5334         if (state->hdl.error) {
5335                 int err = state->hdl.error;
5336
5337                 v4l2_ctrl_handler_free(&state->hdl);
5338                 return err;
5339         }
5340         if (!is_cx2583x(state))
5341                 v4l2_ctrl_cluster(2, &state->volume);
5342         v4l2_ctrl_handler_setup(&state->hdl);
5343
5344         if (client->dev.platform_data) {
5345                 struct cx25840_platform_data *pdata = client->dev.platform_data;
5346
5347                 state->pvr150_workaround = pdata->pvr150_workaround;
5348         }
5349
5350         cx25840_ir_probe(sd);
5351         return 0;
5352 }
5353
5354 static int cx25840_remove(struct i2c_client *client)
5355 {
5356         struct v4l2_subdev *sd = i2c_get_clientdata(client);
5357         struct cx25840_state *state = to_state(sd);
5358
5359         cx25840_ir_remove(sd);
5360         v4l2_device_unregister_subdev(sd);
5361         v4l2_ctrl_handler_free(&state->hdl);
5362         return 0;
5363 }
5364
5365 static const struct i2c_device_id cx25840_id[] = {
5366         { "cx25840", 0 },
5367         { }
5368 };
5369 MODULE_DEVICE_TABLE(i2c, cx25840_id);
5370
5371 static struct i2c_driver cx25840_driver = {
5372         .driver = {
5373                 .name   = "cx25840",
5374         },
5375         .probe          = cx25840_probe,
5376         .remove         = cx25840_remove,
5377         .id_table       = cx25840_id,
5378 };
5379
5380 module_i2c_driver(cx25840_driver);