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