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