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