1
2
3
4
5
6
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <linux/i2c.h>
13#include <linux/mutex.h>
14#include <asm/div64.h>
15
16#include <media/dvb_math.h>
17#include <media/dvb_frontend.h>
18
19#include "dib7000p.h"
20
21static int debug;
22module_param(debug, int, 0644);
23MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
24
25static int buggy_sfn_workaround;
26module_param(buggy_sfn_workaround, int, 0644);
27MODULE_PARM_DESC(buggy_sfn_workaround, "Enable work-around for buggy SFNs (default: 0)");
28
29#define dprintk(fmt, arg...) do { \
30 if (debug) \
31 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
32 __func__, ##arg); \
33} while (0)
34
35struct i2c_device {
36 struct i2c_adapter *i2c_adap;
37 u8 i2c_addr;
38};
39
40struct dib7000p_state {
41 struct dvb_frontend demod;
42 struct dib7000p_config cfg;
43
44 u8 i2c_addr;
45 struct i2c_adapter *i2c_adap;
46
47 struct dibx000_i2c_master i2c_master;
48
49 u16 wbd_ref;
50
51 u8 current_band;
52 u32 current_bandwidth;
53 struct dibx000_agc_config *current_agc;
54 u32 timf;
55
56 u8 div_force_off:1;
57 u8 div_state:1;
58 u16 div_sync_wait;
59
60 u8 agc_state;
61
62 u16 gpio_dir;
63 u16 gpio_val;
64
65 u8 sfn_workaround_active:1;
66
67#define SOC7090 0x7090
68 u16 version;
69
70 u16 tuner_enable;
71 struct i2c_adapter dib7090_tuner_adap;
72
73
74 struct i2c_msg msg[2];
75 u8 i2c_write_buffer[4];
76 u8 i2c_read_buffer[2];
77 struct mutex i2c_buffer_lock;
78
79 u8 input_mode_mpeg;
80
81
82 s64 old_ucb;
83 unsigned long per_jiffies_stats;
84 unsigned long ber_jiffies_stats;
85 unsigned long get_stats_time;
86};
87
88enum dib7000p_power_mode {
89 DIB7000P_POWER_ALL = 0,
90 DIB7000P_POWER_ANALOG_ADC,
91 DIB7000P_POWER_INTERFACE_ONLY,
92};
93
94
95static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode);
96static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff);
97static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode);
98static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode);
99
100static u16 dib7000p_read_word(struct dib7000p_state *state, u16 reg)
101{
102 u16 ret;
103
104 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
105 dprintk("could not acquire lock\n");
106 return 0;
107 }
108
109 state->i2c_write_buffer[0] = reg >> 8;
110 state->i2c_write_buffer[1] = reg & 0xff;
111
112 memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
113 state->msg[0].addr = state->i2c_addr >> 1;
114 state->msg[0].flags = 0;
115 state->msg[0].buf = state->i2c_write_buffer;
116 state->msg[0].len = 2;
117 state->msg[1].addr = state->i2c_addr >> 1;
118 state->msg[1].flags = I2C_M_RD;
119 state->msg[1].buf = state->i2c_read_buffer;
120 state->msg[1].len = 2;
121
122 if (i2c_transfer(state->i2c_adap, state->msg, 2) != 2)
123 dprintk("i2c read error on %d\n", reg);
124
125 ret = (state->i2c_read_buffer[0] << 8) | state->i2c_read_buffer[1];
126 mutex_unlock(&state->i2c_buffer_lock);
127 return ret;
128}
129
130static int dib7000p_write_word(struct dib7000p_state *state, u16 reg, u16 val)
131{
132 int ret;
133
134 if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
135 dprintk("could not acquire lock\n");
136 return -EINVAL;
137 }
138
139 state->i2c_write_buffer[0] = (reg >> 8) & 0xff;
140 state->i2c_write_buffer[1] = reg & 0xff;
141 state->i2c_write_buffer[2] = (val >> 8) & 0xff;
142 state->i2c_write_buffer[3] = val & 0xff;
143
144 memset(&state->msg[0], 0, sizeof(struct i2c_msg));
145 state->msg[0].addr = state->i2c_addr >> 1;
146 state->msg[0].flags = 0;
147 state->msg[0].buf = state->i2c_write_buffer;
148 state->msg[0].len = 4;
149
150 ret = (i2c_transfer(state->i2c_adap, state->msg, 1) != 1 ?
151 -EREMOTEIO : 0);
152 mutex_unlock(&state->i2c_buffer_lock);
153 return ret;
154}
155
156static void dib7000p_write_tab(struct dib7000p_state *state, u16 * buf)
157{
158 u16 l = 0, r, *n;
159 n = buf;
160 l = *n++;
161 while (l) {
162 r = *n++;
163
164 do {
165 dib7000p_write_word(state, r, *n++);
166 r++;
167 } while (--l);
168 l = *n++;
169 }
170}
171
172static int dib7000p_set_output_mode(struct dib7000p_state *state, int mode)
173{
174 int ret = 0;
175 u16 outreg, fifo_threshold, smo_mode;
176
177 outreg = 0;
178 fifo_threshold = 1792;
179 smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
180
181 dprintk("setting output mode for demod %p to %d\n", &state->demod, mode);
182
183 switch (mode) {
184 case OUTMODE_MPEG2_PAR_GATED_CLK:
185 outreg = (1 << 10);
186 break;
187 case OUTMODE_MPEG2_PAR_CONT_CLK:
188 outreg = (1 << 10) | (1 << 6);
189 break;
190 case OUTMODE_MPEG2_SERIAL:
191 outreg = (1 << 10) | (2 << 6) | (0 << 1);
192 break;
193 case OUTMODE_DIVERSITY:
194 if (state->cfg.hostbus_diversity)
195 outreg = (1 << 10) | (4 << 6);
196 else
197 outreg = (1 << 11);
198 break;
199 case OUTMODE_MPEG2_FIFO:
200 smo_mode |= (3 << 1);
201 fifo_threshold = 512;
202 outreg = (1 << 10) | (5 << 6);
203 break;
204 case OUTMODE_ANALOG_ADC:
205 outreg = (1 << 10) | (3 << 6);
206 break;
207 case OUTMODE_HIGH_Z:
208 outreg = 0;
209 break;
210 default:
211 dprintk("Unhandled output_mode passed to be set for demod %p\n", &state->demod);
212 break;
213 }
214
215 if (state->cfg.output_mpeg2_in_188_bytes)
216 smo_mode |= (1 << 5);
217
218 ret |= dib7000p_write_word(state, 235, smo_mode);
219 ret |= dib7000p_write_word(state, 236, fifo_threshold);
220 if (state->version != SOC7090)
221 ret |= dib7000p_write_word(state, 1286, outreg);
222
223 return ret;
224}
225
226static int dib7000p_set_diversity_in(struct dvb_frontend *demod, int onoff)
227{
228 struct dib7000p_state *state = demod->demodulator_priv;
229
230 if (state->div_force_off) {
231 dprintk("diversity combination deactivated - forced by COFDM parameters\n");
232 onoff = 0;
233 dib7000p_write_word(state, 207, 0);
234 } else
235 dib7000p_write_word(state, 207, (state->div_sync_wait << 4) | (1 << 2) | (2 << 0));
236
237 state->div_state = (u8) onoff;
238
239 if (onoff) {
240 dib7000p_write_word(state, 204, 6);
241 dib7000p_write_word(state, 205, 16);
242
243 } else {
244 dib7000p_write_word(state, 204, 1);
245 dib7000p_write_word(state, 205, 0);
246 }
247
248 return 0;
249}
250
251static int dib7000p_set_power_mode(struct dib7000p_state *state, enum dib7000p_power_mode mode)
252{
253
254 u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0x0007, reg_899 = 0x0003, reg_1280 = (0xfe00) | (dib7000p_read_word(state, 1280) & 0x01ff);
255
256
257 switch (mode) {
258
259 case DIB7000P_POWER_ALL:
260 reg_774 = 0x0000;
261 reg_775 = 0x0000;
262 reg_776 = 0x0;
263 reg_899 = 0x0;
264 if (state->version == SOC7090)
265 reg_1280 &= 0x001f;
266 else
267 reg_1280 &= 0x01ff;
268 break;
269
270 case DIB7000P_POWER_ANALOG_ADC:
271
272 reg_774 &= ~((1 << 15) | (1 << 14) | (1 << 11) | (1 << 10) | (1 << 9));
273
274 reg_776 &= ~((1 << 0));
275
276 if (state->version != SOC7090)
277 reg_1280 &= ~((1 << 11));
278 reg_1280 &= ~(1 << 6);
279
280 case DIB7000P_POWER_INTERFACE_ONLY:
281
282
283 if (state->version == SOC7090)
284 reg_1280 &= ~((1 << 7) | (1 << 5));
285 else
286 reg_1280 &= ~((1 << 14) | (1 << 13) | (1 << 12) | (1 << 10));
287 break;
288
289
290 }
291
292 dib7000p_write_word(state, 774, reg_774);
293 dib7000p_write_word(state, 775, reg_775);
294 dib7000p_write_word(state, 776, reg_776);
295 dib7000p_write_word(state, 1280, reg_1280);
296 if (state->version != SOC7090)
297 dib7000p_write_word(state, 899, reg_899);
298
299 return 0;
300}
301
302static void dib7000p_set_adc_state(struct dib7000p_state *state, enum dibx000_adc_states no)
303{
304 u16 reg_908 = 0, reg_909 = 0;
305 u16 reg;
306
307 if (state->version != SOC7090) {
308 reg_908 = dib7000p_read_word(state, 908);
309 reg_909 = dib7000p_read_word(state, 909);
310 }
311
312 switch (no) {
313 case DIBX000_SLOW_ADC_ON:
314 if (state->version == SOC7090) {
315 reg = dib7000p_read_word(state, 1925);
316
317 dib7000p_write_word(state, 1925, reg | (1 << 4) | (1 << 2));
318
319 reg = dib7000p_read_word(state, 1925);
320 msleep(200);
321 dib7000p_write_word(state, 1925, reg & ~(1 << 4));
322
323 reg = dib7000p_read_word(state, 72) & ~((0x3 << 14) | (0x3 << 12));
324 dib7000p_write_word(state, 72, reg | (1 << 14) | (3 << 12) | 524);
325 } else {
326 reg_909 |= (1 << 1) | (1 << 0);
327 dib7000p_write_word(state, 909, reg_909);
328 reg_909 &= ~(1 << 1);
329 }
330 break;
331
332 case DIBX000_SLOW_ADC_OFF:
333 if (state->version == SOC7090) {
334 reg = dib7000p_read_word(state, 1925);
335 dib7000p_write_word(state, 1925, (reg & ~(1 << 2)) | (1 << 4));
336 } else
337 reg_909 |= (1 << 1) | (1 << 0);
338 break;
339
340 case DIBX000_ADC_ON:
341 reg_908 &= 0x0fff;
342 reg_909 &= 0x0003;
343 break;
344
345 case DIBX000_ADC_OFF:
346 reg_908 |= (1 << 14) | (1 << 13) | (1 << 12);
347 reg_909 |= (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2);
348 break;
349
350 case DIBX000_VBG_ENABLE:
351 reg_908 &= ~(1 << 15);
352 break;
353
354 case DIBX000_VBG_DISABLE:
355 reg_908 |= (1 << 15);
356 break;
357
358 default:
359 break;
360 }
361
362
363
364 reg_909 |= (state->cfg.disable_sample_and_hold & 1) << 4;
365 reg_908 |= (state->cfg.enable_current_mirror & 1) << 7;
366
367 if (state->version != SOC7090) {
368 dib7000p_write_word(state, 908, reg_908);
369 dib7000p_write_word(state, 909, reg_909);
370 }
371}
372
373static int dib7000p_set_bandwidth(struct dib7000p_state *state, u32 bw)
374{
375 u32 timf;
376
377
378 state->current_bandwidth = bw;
379
380 if (state->timf == 0) {
381 dprintk("using default timf\n");
382 timf = state->cfg.bw->timf;
383 } else {
384 dprintk("using updated timf\n");
385 timf = state->timf;
386 }
387
388 timf = timf * (bw / 50) / 160;
389
390 dib7000p_write_word(state, 23, (u16) ((timf >> 16) & 0xffff));
391 dib7000p_write_word(state, 24, (u16) ((timf) & 0xffff));
392
393 return 0;
394}
395
396static int dib7000p_sad_calib(struct dib7000p_state *state)
397{
398
399 dib7000p_write_word(state, 73, (0 << 1) | (0 << 0));
400
401 if (state->version == SOC7090)
402 dib7000p_write_word(state, 74, 2048);
403 else
404 dib7000p_write_word(state, 74, 776);
405
406
407 dib7000p_write_word(state, 73, (1 << 0));
408 dib7000p_write_word(state, 73, (0 << 0));
409
410 msleep(1);
411
412 return 0;
413}
414
415static int dib7000p_set_wbd_ref(struct dvb_frontend *demod, u16 value)
416{
417 struct dib7000p_state *state = demod->demodulator_priv;
418 if (value > 4095)
419 value = 4095;
420 state->wbd_ref = value;
421 return dib7000p_write_word(state, 105, (dib7000p_read_word(state, 105) & 0xf000) | value);
422}
423
424static int dib7000p_get_agc_values(struct dvb_frontend *fe,
425 u16 *agc_global, u16 *agc1, u16 *agc2, u16 *wbd)
426{
427 struct dib7000p_state *state = fe->demodulator_priv;
428
429 if (agc_global != NULL)
430 *agc_global = dib7000p_read_word(state, 394);
431 if (agc1 != NULL)
432 *agc1 = dib7000p_read_word(state, 392);
433 if (agc2 != NULL)
434 *agc2 = dib7000p_read_word(state, 393);
435 if (wbd != NULL)
436 *wbd = dib7000p_read_word(state, 397);
437
438 return 0;
439}
440
441static int dib7000p_set_agc1_min(struct dvb_frontend *fe, u16 v)
442{
443 struct dib7000p_state *state = fe->demodulator_priv;
444 return dib7000p_write_word(state, 108, v);
445}
446
447static void dib7000p_reset_pll(struct dib7000p_state *state)
448{
449 struct dibx000_bandwidth_config *bw = &state->cfg.bw[0];
450 u16 clk_cfg0;
451
452 if (state->version == SOC7090) {
453 dib7000p_write_word(state, 1856, (!bw->pll_reset << 13) | (bw->pll_range << 12) | (bw->pll_ratio << 6) | (bw->pll_prediv));
454
455 while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
456 ;
457
458 dib7000p_write_word(state, 1857, dib7000p_read_word(state, 1857) | (!bw->pll_bypass << 15));
459 } else {
460
461 clk_cfg0 = (1 << 15) | ((bw->pll_ratio & 0x3f) << 9) |
462 (bw->modulo << 7) | (bw->ADClkSrc << 6) | (bw->IO_CLK_en_core << 5) | (bw->bypclk_div << 2) | (bw->enable_refdiv << 1) | (0 << 0);
463
464 dib7000p_write_word(state, 900, clk_cfg0);
465
466
467 dib7000p_write_word(state, 903, (bw->pll_prediv << 5) | (((bw->pll_ratio >> 6) & 0x3) << 3) | (bw->pll_range << 1) | bw->pll_reset);
468 clk_cfg0 = (bw->pll_bypass << 15) | (clk_cfg0 & 0x7fff);
469 dib7000p_write_word(state, 900, clk_cfg0);
470 }
471
472 dib7000p_write_word(state, 18, (u16) (((bw->internal * 1000) >> 16) & 0xffff));
473 dib7000p_write_word(state, 19, (u16) ((bw->internal * 1000) & 0xffff));
474 dib7000p_write_word(state, 21, (u16) ((bw->ifreq >> 16) & 0xffff));
475 dib7000p_write_word(state, 22, (u16) ((bw->ifreq) & 0xffff));
476
477 dib7000p_write_word(state, 72, bw->sad_cfg);
478}
479
480static u32 dib7000p_get_internal_freq(struct dib7000p_state *state)
481{
482 u32 internal = (u32) dib7000p_read_word(state, 18) << 16;
483 internal |= (u32) dib7000p_read_word(state, 19);
484 internal /= 1000;
485
486 return internal;
487}
488
489static int dib7000p_update_pll(struct dvb_frontend *fe, struct dibx000_bandwidth_config *bw)
490{
491 struct dib7000p_state *state = fe->demodulator_priv;
492 u16 reg_1857, reg_1856 = dib7000p_read_word(state, 1856);
493 u8 loopdiv, prediv;
494 u32 internal, xtal;
495
496
497 prediv = reg_1856 & 0x3f;
498 loopdiv = (reg_1856 >> 6) & 0x3f;
499
500 if ((bw != NULL) && (bw->pll_prediv != prediv || bw->pll_ratio != loopdiv)) {
501 dprintk("Updating pll (prediv: old = %d new = %d ; loopdiv : old = %d new = %d)\n", prediv, bw->pll_prediv, loopdiv, bw->pll_ratio);
502 reg_1856 &= 0xf000;
503 reg_1857 = dib7000p_read_word(state, 1857);
504 dib7000p_write_word(state, 1857, reg_1857 & ~(1 << 15));
505
506 dib7000p_write_word(state, 1856, reg_1856 | ((bw->pll_ratio & 0x3f) << 6) | (bw->pll_prediv & 0x3f));
507
508
509 internal = dib7000p_get_internal_freq(state);
510 xtal = (internal / loopdiv) * prediv;
511 internal = 1000 * (xtal / bw->pll_prediv) * bw->pll_ratio;
512 dib7000p_write_word(state, 18, (u16) ((internal >> 16) & 0xffff));
513 dib7000p_write_word(state, 19, (u16) (internal & 0xffff));
514
515 dib7000p_write_word(state, 1857, reg_1857 | (1 << 15));
516
517 while (((dib7000p_read_word(state, 1856) >> 15) & 0x1) != 1)
518 dprintk("Waiting for PLL to lock\n");
519
520 return 0;
521 }
522 return -EIO;
523}
524
525static int dib7000p_reset_gpio(struct dib7000p_state *st)
526{
527
528 dprintk("gpio dir: %x: val: %x, pwm_pos: %x\n", st->gpio_dir, st->gpio_val, st->cfg.gpio_pwm_pos);
529
530 dib7000p_write_word(st, 1029, st->gpio_dir);
531 dib7000p_write_word(st, 1030, st->gpio_val);
532
533
534
535 dib7000p_write_word(st, 1032, st->cfg.gpio_pwm_pos);
536
537 dib7000p_write_word(st, 1037, st->cfg.pwm_freq_div);
538 return 0;
539}
540
541static int dib7000p_cfg_gpio(struct dib7000p_state *st, u8 num, u8 dir, u8 val)
542{
543 st->gpio_dir = dib7000p_read_word(st, 1029);
544 st->gpio_dir &= ~(1 << num);
545 st->gpio_dir |= (dir & 0x1) << num;
546 dib7000p_write_word(st, 1029, st->gpio_dir);
547
548 st->gpio_val = dib7000p_read_word(st, 1030);
549 st->gpio_val &= ~(1 << num);
550 st->gpio_val |= (val & 0x01) << num;
551 dib7000p_write_word(st, 1030, st->gpio_val);
552
553 return 0;
554}
555
556static int dib7000p_set_gpio(struct dvb_frontend *demod, u8 num, u8 dir, u8 val)
557{
558 struct dib7000p_state *state = demod->demodulator_priv;
559 return dib7000p_cfg_gpio(state, num, dir, val);
560}
561
562static u16 dib7000p_defaults[] = {
563
564 3, 2,
565 0x0004,
566 (1<<3)|(1<<11)|(1<<12)|(1<<13),
567 0x0814,
568
569 12, 6,
570 0x001b,
571 0x7740,
572 0x005b,
573 0x8d80,
574 0x01c9,
575 0xc380,
576 0x0000,
577 0x0080,
578 0x0000,
579 0x0090,
580 0x0001,
581 0xd4c0,
582
583 1, 26,
584 0x6680,
585
586
587 11, 79,
588 (1 << 13) - 825 - 117,
589 (1 << 13) - 837 - 117,
590 (1 << 13) - 811 - 117,
591 (1 << 13) - 766 - 117,
592 (1 << 13) - 737 - 117,
593 (1 << 13) - 693 - 117,
594 (1 << 13) - 648 - 117,
595 (1 << 13) - 619 - 117,
596 (1 << 13) - 575 - 117,
597 (1 << 13) - 531 - 117,
598 (1 << 13) - 501 - 117,
599
600 1, 142,
601 0x0410,
602
603
604 8, 145,
605 0,
606 0,
607 0,
608 0,
609 0,
610 0,
611 0,
612 0,
613
614 1, 154,
615 1 << 13,
616
617 1, 168,
618 0x0ccd,
619
620 1, 183,
621 0x200f,
622
623 1, 212,
624 0x169,
625
626 5, 187,
627 0x023d,
628 0x00a4,
629 0x00a4,
630 0x7ff0,
631 0x3ccc,
632
633 1, 198,
634 0x800,
635
636 1, 222,
637 0x0010,
638
639 1, 235,
640 0x0062,
641
642 0,
643};
644
645static void dib7000p_reset_stats(struct dvb_frontend *fe);
646
647static int dib7000p_demod_reset(struct dib7000p_state *state)
648{
649 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
650
651 if (state->version == SOC7090)
652 dibx000_reset_i2c_master(&state->i2c_master);
653
654 dib7000p_set_adc_state(state, DIBX000_VBG_ENABLE);
655
656
657 dib7000p_write_word(state, 770, 0xffff);
658 dib7000p_write_word(state, 771, 0xffff);
659 dib7000p_write_word(state, 772, 0x001f);
660 dib7000p_write_word(state, 1280, 0x001f - ((1 << 4) | (1 << 3)));
661
662 dib7000p_write_word(state, 770, 0);
663 dib7000p_write_word(state, 771, 0);
664 dib7000p_write_word(state, 772, 0);
665 dib7000p_write_word(state, 1280, 0);
666
667 if (state->version != SOC7090) {
668 dib7000p_write_word(state, 898, 0x0003);
669 dib7000p_write_word(state, 898, 0);
670 }
671
672
673 dib7000p_reset_pll(state);
674
675 if (dib7000p_reset_gpio(state) != 0)
676 dprintk("GPIO reset was not successful.\n");
677
678 if (state->version == SOC7090) {
679 dib7000p_write_word(state, 899, 0);
680
681
682 dib7000p_write_word(state, 42, (1<<5) | 3);
683 dib7000p_write_word(state, 43, 0x2d4);
684 dib7000p_write_word(state, 44, 300);
685 dib7000p_write_word(state, 273, (0<<6) | 30);
686 }
687 if (dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) != 0)
688 dprintk("OUTPUT_MODE could not be reset.\n");
689
690 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
691 dib7000p_sad_calib(state);
692 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
693
694
695 dib7000p_write_word(state, 1285, dib7000p_read_word(state, 1285) & ~(1 << 1));
696
697 dib7000p_set_bandwidth(state, 8000);
698
699 if (state->version == SOC7090) {
700 dib7000p_write_word(state, 36, 0x0755);
701 } else {
702 if (state->cfg.tuner_is_baseband)
703 dib7000p_write_word(state, 36, 0x0755);
704 else
705 dib7000p_write_word(state, 36, 0x1f55);
706 }
707
708 dib7000p_write_tab(state, dib7000p_defaults);
709 if (state->version != SOC7090) {
710 dib7000p_write_word(state, 901, 0x0006);
711 dib7000p_write_word(state, 902, (3 << 10) | (1 << 6));
712 dib7000p_write_word(state, 905, 0x2c8e);
713 }
714
715 dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
716
717 return 0;
718}
719
720static void dib7000p_pll_clk_cfg(struct dib7000p_state *state)
721{
722 u16 tmp = 0;
723 tmp = dib7000p_read_word(state, 903);
724 dib7000p_write_word(state, 903, (tmp | 0x1));
725 tmp = dib7000p_read_word(state, 900);
726 dib7000p_write_word(state, 900, (tmp & 0x7fff) | (1 << 6));
727}
728
729static void dib7000p_restart_agc(struct dib7000p_state *state)
730{
731
732 dib7000p_write_word(state, 770, (1 << 11) | (1 << 9));
733 dib7000p_write_word(state, 770, 0x0000);
734}
735
736static int dib7000p_update_lna(struct dib7000p_state *state)
737{
738 u16 dyn_gain;
739
740 if (state->cfg.update_lna) {
741 dyn_gain = dib7000p_read_word(state, 394);
742 if (state->cfg.update_lna(&state->demod, dyn_gain)) {
743 dib7000p_restart_agc(state);
744 return 1;
745 }
746 }
747
748 return 0;
749}
750
751static int dib7000p_set_agc_config(struct dib7000p_state *state, u8 band)
752{
753 struct dibx000_agc_config *agc = NULL;
754 int i;
755 if (state->current_band == band && state->current_agc != NULL)
756 return 0;
757 state->current_band = band;
758
759 for (i = 0; i < state->cfg.agc_config_count; i++)
760 if (state->cfg.agc[i].band_caps & band) {
761 agc = &state->cfg.agc[i];
762 break;
763 }
764
765 if (agc == NULL) {
766 dprintk("no valid AGC configuration found for band 0x%02x\n", band);
767 return -EINVAL;
768 }
769
770 state->current_agc = agc;
771
772
773 dib7000p_write_word(state, 75, agc->setup);
774 dib7000p_write_word(state, 76, agc->inv_gain);
775 dib7000p_write_word(state, 77, agc->time_stabiliz);
776 dib7000p_write_word(state, 100, (agc->alpha_level << 12) | agc->thlock);
777
778
779 dib7000p_write_word(state, 101, (agc->alpha_mant << 5) | agc->alpha_exp);
780 dib7000p_write_word(state, 102, (agc->beta_mant << 6) | agc->beta_exp);
781
782
783 dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d\n",
784 state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
785
786 if (state->wbd_ref != 0)
787 dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | state->wbd_ref);
788 else
789 dib7000p_write_word(state, 105, (agc->wbd_inv << 12) | agc->wbd_ref);
790
791 dib7000p_write_word(state, 106, (agc->wbd_sel << 13) | (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
792
793 dib7000p_write_word(state, 107, agc->agc1_max);
794 dib7000p_write_word(state, 108, agc->agc1_min);
795 dib7000p_write_word(state, 109, agc->agc2_max);
796 dib7000p_write_word(state, 110, agc->agc2_min);
797 dib7000p_write_word(state, 111, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
798 dib7000p_write_word(state, 112, agc->agc1_pt3);
799 dib7000p_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
800 dib7000p_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
801 dib7000p_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
802 return 0;
803}
804
805static int dib7000p_set_dds(struct dib7000p_state *state, s32 offset_khz)
806{
807 u32 internal = dib7000p_get_internal_freq(state);
808 s32 unit_khz_dds_val;
809 u32 abs_offset_khz = abs(offset_khz);
810 u32 dds = state->cfg.bw->ifreq & 0x1ffffff;
811 u8 invert = !!(state->cfg.bw->ifreq & (1 << 25));
812 if (internal == 0) {
813 pr_warn("DIB7000P: dib7000p_get_internal_freq returned 0\n");
814 return -1;
815 }
816
817 unit_khz_dds_val = 67108864 / (internal);
818
819 dprintk("setting a frequency offset of %dkHz internal freq = %d invert = %d\n", offset_khz, internal, invert);
820
821 if (offset_khz < 0)
822 unit_khz_dds_val *= -1;
823
824
825 if (invert)
826 dds -= (abs_offset_khz * unit_khz_dds_val);
827 else
828 dds += (abs_offset_khz * unit_khz_dds_val);
829
830 if (abs_offset_khz <= (internal / 2)) {
831 dib7000p_write_word(state, 21, (u16) (((dds >> 16) & 0x1ff) | (0 << 10) | (invert << 9)));
832 dib7000p_write_word(state, 22, (u16) (dds & 0xffff));
833 }
834 return 0;
835}
836
837static int dib7000p_agc_startup(struct dvb_frontend *demod)
838{
839 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
840 struct dib7000p_state *state = demod->demodulator_priv;
841 int ret = -1;
842 u8 *agc_state = &state->agc_state;
843 u8 agc_split;
844 u16 reg;
845 u32 upd_demod_gain_period = 0x1000;
846 s32 frequency_offset = 0;
847
848 switch (state->agc_state) {
849 case 0:
850 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
851 if (state->version == SOC7090) {
852 reg = dib7000p_read_word(state, 0x79b) & 0xff00;
853 dib7000p_write_word(state, 0x79a, upd_demod_gain_period & 0xFFFF);
854 dib7000p_write_word(state, 0x79b, reg | (1 << 14) | ((upd_demod_gain_period >> 16) & 0xFF));
855
856
857 reg = dib7000p_read_word(state, 0x780);
858 dib7000p_write_word(state, 0x780, (reg | (0x3)) & (~(1 << 7)));
859 } else {
860 dib7000p_set_adc_state(state, DIBX000_ADC_ON);
861 dib7000p_pll_clk_cfg(state);
862 }
863
864 if (dib7000p_set_agc_config(state, BAND_OF_FREQUENCY(ch->frequency / 1000)) != 0)
865 return -1;
866
867 if (demod->ops.tuner_ops.get_frequency) {
868 u32 frequency_tuner;
869
870 demod->ops.tuner_ops.get_frequency(demod, &frequency_tuner);
871 frequency_offset = (s32)frequency_tuner / 1000 - ch->frequency / 1000;
872 }
873
874 if (dib7000p_set_dds(state, frequency_offset) < 0)
875 return -1;
876
877 ret = 7;
878 (*agc_state)++;
879 break;
880
881 case 1:
882 if (state->cfg.agc_control)
883 state->cfg.agc_control(&state->demod, 1);
884
885 dib7000p_write_word(state, 78, 32768);
886 if (!state->current_agc->perform_agc_softsplit) {
887
888
889 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | (1 << 8));
890 (*agc_state)++;
891 ret = 5;
892 } else {
893
894 (*agc_state) = 4;
895
896 ret = 7;
897 }
898
899 dib7000p_restart_agc(state);
900 break;
901
902 case 2:
903 dib7000p_write_word(state, 75, state->current_agc->setup | (1 << 4));
904 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (2 << 9) | (0 << 8));
905 (*agc_state)++;
906 ret = 14;
907 break;
908
909 case 3:
910 agc_split = (u8) dib7000p_read_word(state, 396);
911 dib7000p_write_word(state, 78, dib7000p_read_word(state, 394));
912
913 dib7000p_write_word(state, 75, state->current_agc->setup);
914 dib7000p_write_word(state, 106, (state->current_agc->wbd_sel << 13) | (state->current_agc->wbd_alpha << 9) | agc_split);
915
916 dib7000p_restart_agc(state);
917
918 dprintk("SPLIT %p: %hd\n", demod, agc_split);
919
920 (*agc_state)++;
921 ret = 5;
922 break;
923
924 case 4:
925 ret = 7;
926
927 if (dib7000p_update_lna(state))
928 ret = 5;
929 else
930 (*agc_state)++;
931 break;
932
933 case 5:
934 if (state->cfg.agc_control)
935 state->cfg.agc_control(&state->demod, 0);
936 (*agc_state)++;
937 break;
938 default:
939 break;
940 }
941 return ret;
942}
943
944static void dib7000p_update_timf(struct dib7000p_state *state)
945{
946 u32 timf = (dib7000p_read_word(state, 427) << 16) | dib7000p_read_word(state, 428);
947 state->timf = timf * 160 / (state->current_bandwidth / 50);
948 dib7000p_write_word(state, 23, (u16) (timf >> 16));
949 dib7000p_write_word(state, 24, (u16) (timf & 0xffff));
950 dprintk("updated timf_frequency: %d (default: %d)\n", state->timf, state->cfg.bw->timf);
951
952}
953
954static u32 dib7000p_ctrl_timf(struct dvb_frontend *fe, u8 op, u32 timf)
955{
956 struct dib7000p_state *state = fe->demodulator_priv;
957 switch (op) {
958 case DEMOD_TIMF_SET:
959 state->timf = timf;
960 break;
961 case DEMOD_TIMF_UPDATE:
962 dib7000p_update_timf(state);
963 break;
964 case DEMOD_TIMF_GET:
965 break;
966 }
967 dib7000p_set_bandwidth(state, state->current_bandwidth);
968 return state->timf;
969}
970
971static void dib7000p_set_channel(struct dib7000p_state *state,
972 struct dtv_frontend_properties *ch, u8 seq)
973{
974 u16 value, est[4];
975
976 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
977
978
979 value = 0;
980 switch (ch->transmission_mode) {
981 case TRANSMISSION_MODE_2K:
982 value |= (0 << 7);
983 break;
984 case TRANSMISSION_MODE_4K:
985 value |= (2 << 7);
986 break;
987 default:
988 case TRANSMISSION_MODE_8K:
989 value |= (1 << 7);
990 break;
991 }
992 switch (ch->guard_interval) {
993 case GUARD_INTERVAL_1_32:
994 value |= (0 << 5);
995 break;
996 case GUARD_INTERVAL_1_16:
997 value |= (1 << 5);
998 break;
999 case GUARD_INTERVAL_1_4:
1000 value |= (3 << 5);
1001 break;
1002 default:
1003 case GUARD_INTERVAL_1_8:
1004 value |= (2 << 5);
1005 break;
1006 }
1007 switch (ch->modulation) {
1008 case QPSK:
1009 value |= (0 << 3);
1010 break;
1011 case QAM_16:
1012 value |= (1 << 3);
1013 break;
1014 default:
1015 case QAM_64:
1016 value |= (2 << 3);
1017 break;
1018 }
1019 switch (HIERARCHY_1) {
1020 case HIERARCHY_2:
1021 value |= 2;
1022 break;
1023 case HIERARCHY_4:
1024 value |= 4;
1025 break;
1026 default:
1027 case HIERARCHY_1:
1028 value |= 1;
1029 break;
1030 }
1031 dib7000p_write_word(state, 0, value);
1032 dib7000p_write_word(state, 5, (seq << 4) | 1);
1033
1034
1035 value = 0;
1036 if (1 != 0)
1037 value |= (1 << 6);
1038 if (ch->hierarchy == 1)
1039 value |= (1 << 4);
1040 if (1 == 1)
1041 value |= 1;
1042 switch ((ch->hierarchy == 0 || 1 == 1) ? ch->code_rate_HP : ch->code_rate_LP) {
1043 case FEC_2_3:
1044 value |= (2 << 1);
1045 break;
1046 case FEC_3_4:
1047 value |= (3 << 1);
1048 break;
1049 case FEC_5_6:
1050 value |= (5 << 1);
1051 break;
1052 case FEC_7_8:
1053 value |= (7 << 1);
1054 break;
1055 default:
1056 case FEC_1_2:
1057 value |= (1 << 1);
1058 break;
1059 }
1060 dib7000p_write_word(state, 208, value);
1061
1062
1063 dib7000p_write_word(state, 26, 0x6680);
1064 dib7000p_write_word(state, 32, 0x0003);
1065 dib7000p_write_word(state, 29, 0x1273);
1066 dib7000p_write_word(state, 33, 0x0005);
1067
1068
1069 switch (ch->transmission_mode) {
1070 case TRANSMISSION_MODE_8K:
1071 value = 256;
1072 break;
1073 case TRANSMISSION_MODE_4K:
1074 value = 128;
1075 break;
1076 case TRANSMISSION_MODE_2K:
1077 default:
1078 value = 64;
1079 break;
1080 }
1081 switch (ch->guard_interval) {
1082 case GUARD_INTERVAL_1_16:
1083 value *= 2;
1084 break;
1085 case GUARD_INTERVAL_1_8:
1086 value *= 4;
1087 break;
1088 case GUARD_INTERVAL_1_4:
1089 value *= 8;
1090 break;
1091 default:
1092 case GUARD_INTERVAL_1_32:
1093 value *= 1;
1094 break;
1095 }
1096 if (state->cfg.diversity_delay == 0)
1097 state->div_sync_wait = (value * 3) / 2 + 48;
1098 else
1099 state->div_sync_wait = (value * 3) / 2 + state->cfg.diversity_delay;
1100
1101
1102 state->div_force_off = !1 && ch->transmission_mode != TRANSMISSION_MODE_8K;
1103 dib7000p_set_diversity_in(&state->demod, state->div_state);
1104
1105
1106 switch (ch->modulation) {
1107 case QAM_64:
1108 est[0] = 0x0148;
1109 est[1] = 0xfff0;
1110 est[2] = 0x00a4;
1111 est[3] = 0xfff8;
1112 break;
1113 case QAM_16:
1114 est[0] = 0x023d;
1115 est[1] = 0xffdf;
1116 est[2] = 0x00a4;
1117 est[3] = 0xfff0;
1118 break;
1119 default:
1120 est[0] = 0x099a;
1121 est[1] = 0xffae;
1122 est[2] = 0x0333;
1123 est[3] = 0xfff8;
1124 break;
1125 }
1126 for (value = 0; value < 4; value++)
1127 dib7000p_write_word(state, 187 + value, est[value]);
1128}
1129
1130static int dib7000p_autosearch_start(struct dvb_frontend *demod)
1131{
1132 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
1133 struct dib7000p_state *state = demod->demodulator_priv;
1134 struct dtv_frontend_properties schan;
1135 u32 value, factor;
1136 u32 internal = dib7000p_get_internal_freq(state);
1137
1138 schan = *ch;
1139 schan.modulation = QAM_64;
1140 schan.guard_interval = GUARD_INTERVAL_1_32;
1141 schan.transmission_mode = TRANSMISSION_MODE_8K;
1142 schan.code_rate_HP = FEC_2_3;
1143 schan.code_rate_LP = FEC_3_4;
1144 schan.hierarchy = 0;
1145
1146 dib7000p_set_channel(state, &schan, 7);
1147
1148 factor = BANDWIDTH_TO_KHZ(ch->bandwidth_hz);
1149 if (factor >= 5000) {
1150 if (state->version == SOC7090)
1151 factor = 2;
1152 else
1153 factor = 1;
1154 } else
1155 factor = 6;
1156
1157 value = 30 * internal * factor;
1158 dib7000p_write_word(state, 6, (u16) ((value >> 16) & 0xffff));
1159 dib7000p_write_word(state, 7, (u16) (value & 0xffff));
1160 value = 100 * internal * factor;
1161 dib7000p_write_word(state, 8, (u16) ((value >> 16) & 0xffff));
1162 dib7000p_write_word(state, 9, (u16) (value & 0xffff));
1163 value = 500 * internal * factor;
1164 dib7000p_write_word(state, 10, (u16) ((value >> 16) & 0xffff));
1165 dib7000p_write_word(state, 11, (u16) (value & 0xffff));
1166
1167 value = dib7000p_read_word(state, 0);
1168 dib7000p_write_word(state, 0, (u16) ((1 << 9) | value));
1169 dib7000p_read_word(state, 1284);
1170 dib7000p_write_word(state, 0, (u16) value);
1171
1172 return 0;
1173}
1174
1175static int dib7000p_autosearch_is_irq(struct dvb_frontend *demod)
1176{
1177 struct dib7000p_state *state = demod->demodulator_priv;
1178 u16 irq_pending = dib7000p_read_word(state, 1284);
1179
1180 if (irq_pending & 0x1)
1181 return 1;
1182
1183 if (irq_pending & 0x2)
1184 return 2;
1185
1186 return 0;
1187}
1188
1189static void dib7000p_spur_protect(struct dib7000p_state *state, u32 rf_khz, u32 bw)
1190{
1191 static s16 notch[] = { 16143, 14402, 12238, 9713, 6902, 3888, 759, -2392 };
1192 static u8 sine[] = { 0, 2, 3, 5, 6, 8, 9, 11, 13, 14, 16, 17, 19, 20, 22,
1193 24, 25, 27, 28, 30, 31, 33, 34, 36, 38, 39, 41, 42, 44, 45, 47, 48, 50, 51,
1194 53, 55, 56, 58, 59, 61, 62, 64, 65, 67, 68, 70, 71, 73, 74, 76, 77, 79, 80,
1195 82, 83, 85, 86, 88, 89, 91, 92, 94, 95, 97, 98, 99, 101, 102, 104, 105,
1196 107, 108, 109, 111, 112, 114, 115, 117, 118, 119, 121, 122, 123, 125, 126,
1197 128, 129, 130, 132, 133, 134, 136, 137, 138, 140, 141, 142, 144, 145, 146,
1198 147, 149, 150, 151, 152, 154, 155, 156, 157, 159, 160, 161, 162, 164, 165,
1199 166, 167, 168, 170, 171, 172, 173, 174, 175, 177, 178, 179, 180, 181, 182,
1200 183, 184, 185, 186, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
1201 199, 200, 201, 202, 203, 204, 205, 206, 207, 207, 208, 209, 210, 211, 212,
1202 213, 214, 215, 215, 216, 217, 218, 219, 220, 220, 221, 222, 223, 224, 224,
1203 225, 226, 227, 227, 228, 229, 229, 230, 231, 231, 232, 233, 233, 234, 235,
1204 235, 236, 237, 237, 238, 238, 239, 239, 240, 241, 241, 242, 242, 243, 243,
1205 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 248, 249, 249, 249,
1206 250, 250, 250, 251, 251, 251, 252, 252, 252, 252, 253, 253, 253, 253, 254,
1207 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1208 255, 255, 255, 255, 255, 255
1209 };
1210
1211 u32 xtal = state->cfg.bw->xtal_hz / 1000;
1212 int f_rel = DIV_ROUND_CLOSEST(rf_khz, xtal) * xtal - rf_khz;
1213 int k;
1214 int coef_re[8], coef_im[8];
1215 int bw_khz = bw;
1216 u32 pha;
1217
1218 dprintk("relative position of the Spur: %dk (RF: %dk, XTAL: %dk)\n", f_rel, rf_khz, xtal);
1219
1220 if (f_rel < -bw_khz / 2 || f_rel > bw_khz / 2)
1221 return;
1222
1223 bw_khz /= 100;
1224
1225 dib7000p_write_word(state, 142, 0x0610);
1226
1227 for (k = 0; k < 8; k++) {
1228 pha = ((f_rel * (k + 1) * 112 * 80 / bw_khz) / 1000) & 0x3ff;
1229
1230 if (pha == 0) {
1231 coef_re[k] = 256;
1232 coef_im[k] = 0;
1233 } else if (pha < 256) {
1234 coef_re[k] = sine[256 - (pha & 0xff)];
1235 coef_im[k] = sine[pha & 0xff];
1236 } else if (pha == 256) {
1237 coef_re[k] = 0;
1238 coef_im[k] = 256;
1239 } else if (pha < 512) {
1240 coef_re[k] = -sine[pha & 0xff];
1241 coef_im[k] = sine[256 - (pha & 0xff)];
1242 } else if (pha == 512) {
1243 coef_re[k] = -256;
1244 coef_im[k] = 0;
1245 } else if (pha < 768) {
1246 coef_re[k] = -sine[256 - (pha & 0xff)];
1247 coef_im[k] = -sine[pha & 0xff];
1248 } else if (pha == 768) {
1249 coef_re[k] = 0;
1250 coef_im[k] = -256;
1251 } else {
1252 coef_re[k] = sine[pha & 0xff];
1253 coef_im[k] = -sine[256 - (pha & 0xff)];
1254 }
1255
1256 coef_re[k] *= notch[k];
1257 coef_re[k] += (1 << 14);
1258 if (coef_re[k] >= (1 << 24))
1259 coef_re[k] = (1 << 24) - 1;
1260 coef_re[k] /= (1 << 15);
1261
1262 coef_im[k] *= notch[k];
1263 coef_im[k] += (1 << 14);
1264 if (coef_im[k] >= (1 << 24))
1265 coef_im[k] = (1 << 24) - 1;
1266 coef_im[k] /= (1 << 15);
1267
1268 dprintk("PALF COEF: %d re: %d im: %d\n", k, coef_re[k], coef_im[k]);
1269
1270 dib7000p_write_word(state, 143, (0 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
1271 dib7000p_write_word(state, 144, coef_im[k] & 0x3ff);
1272 dib7000p_write_word(state, 143, (1 << 14) | (k << 10) | (coef_re[k] & 0x3ff));
1273 }
1274 dib7000p_write_word(state, 143, 0);
1275}
1276
1277static int dib7000p_tune(struct dvb_frontend *demod)
1278{
1279 struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
1280 struct dib7000p_state *state = demod->demodulator_priv;
1281 u16 tmp = 0;
1282
1283 if (ch != NULL)
1284 dib7000p_set_channel(state, ch, 0);
1285 else
1286 return -EINVAL;
1287
1288
1289 dib7000p_write_word(state, 770, 0x4000);
1290 dib7000p_write_word(state, 770, 0x0000);
1291 msleep(45);
1292
1293
1294 tmp = (0 << 14) | (4 << 10) | (0 << 9) | (3 << 5) | (1 << 4) | (0x3);
1295 if (state->sfn_workaround_active) {
1296 dprintk("SFN workaround is active\n");
1297 tmp |= (1 << 9);
1298 dib7000p_write_word(state, 166, 0x4000);
1299 } else {
1300 dib7000p_write_word(state, 166, 0x0000);
1301 }
1302 dib7000p_write_word(state, 29, tmp);
1303
1304
1305 if (state->timf == 0)
1306 msleep(200);
1307
1308
1309
1310
1311 tmp = (6 << 8) | 0x80;
1312 switch (ch->transmission_mode) {
1313 case TRANSMISSION_MODE_2K:
1314 tmp |= (2 << 12);
1315 break;
1316 case TRANSMISSION_MODE_4K:
1317 tmp |= (3 << 12);
1318 break;
1319 default:
1320 case TRANSMISSION_MODE_8K:
1321 tmp |= (4 << 12);
1322 break;
1323 }
1324 dib7000p_write_word(state, 26, tmp);
1325
1326
1327 tmp = (0 << 4);
1328 switch (ch->transmission_mode) {
1329 case TRANSMISSION_MODE_2K:
1330 tmp |= 0x6;
1331 break;
1332 case TRANSMISSION_MODE_4K:
1333 tmp |= 0x7;
1334 break;
1335 default:
1336 case TRANSMISSION_MODE_8K:
1337 tmp |= 0x8;
1338 break;
1339 }
1340 dib7000p_write_word(state, 32, tmp);
1341
1342
1343 tmp = (0 << 4);
1344 switch (ch->transmission_mode) {
1345 case TRANSMISSION_MODE_2K:
1346 tmp |= 0x6;
1347 break;
1348 case TRANSMISSION_MODE_4K:
1349 tmp |= 0x7;
1350 break;
1351 default:
1352 case TRANSMISSION_MODE_8K:
1353 tmp |= 0x8;
1354 break;
1355 }
1356 dib7000p_write_word(state, 33, tmp);
1357
1358 tmp = dib7000p_read_word(state, 509);
1359 if (!((tmp >> 6) & 0x1)) {
1360
1361 tmp = dib7000p_read_word(state, 771);
1362 dib7000p_write_word(state, 771, tmp | (1 << 1));
1363 dib7000p_write_word(state, 771, tmp);
1364 msleep(40);
1365 tmp = dib7000p_read_word(state, 509);
1366 }
1367
1368 if ((tmp >> 6) & 0x1) {
1369 dib7000p_update_timf(state);
1370
1371 tmp = dib7000p_read_word(state, 26);
1372 dib7000p_write_word(state, 26, (tmp & ~(0xf << 12)) | ((((tmp >> 12) & 0xf) + 5) << 12));
1373 }
1374
1375 if (state->cfg.spur_protect)
1376 dib7000p_spur_protect(state, ch->frequency / 1000, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1377
1378 dib7000p_set_bandwidth(state, BANDWIDTH_TO_KHZ(ch->bandwidth_hz));
1379
1380 dib7000p_reset_stats(demod);
1381
1382 return 0;
1383}
1384
1385static int dib7000p_wakeup(struct dvb_frontend *demod)
1386{
1387 struct dib7000p_state *state = demod->demodulator_priv;
1388 dib7000p_set_power_mode(state, DIB7000P_POWER_ALL);
1389 dib7000p_set_adc_state(state, DIBX000_SLOW_ADC_ON);
1390 if (state->version == SOC7090)
1391 dib7000p_sad_calib(state);
1392 return 0;
1393}
1394
1395static int dib7000p_sleep(struct dvb_frontend *demod)
1396{
1397 struct dib7000p_state *state = demod->demodulator_priv;
1398 if (state->version == SOC7090)
1399 return dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
1400 return dib7000p_set_output_mode(state, OUTMODE_HIGH_Z) | dib7000p_set_power_mode(state, DIB7000P_POWER_INTERFACE_ONLY);
1401}
1402
1403static int dib7000p_identify(struct dib7000p_state *st)
1404{
1405 u16 value;
1406 dprintk("checking demod on I2C address: %d (%x)\n", st->i2c_addr, st->i2c_addr);
1407
1408 if ((value = dib7000p_read_word(st, 768)) != 0x01b3) {
1409 dprintk("wrong Vendor ID (read=0x%x)\n", value);
1410 return -EREMOTEIO;
1411 }
1412
1413 if ((value = dib7000p_read_word(st, 769)) != 0x4000) {
1414 dprintk("wrong Device ID (%x)\n", value);
1415 return -EREMOTEIO;
1416 }
1417
1418 return 0;
1419}
1420
1421static int dib7000p_get_frontend(struct dvb_frontend *fe,
1422 struct dtv_frontend_properties *fep)
1423{
1424 struct dib7000p_state *state = fe->demodulator_priv;
1425 u16 tps = dib7000p_read_word(state, 463);
1426
1427 fep->inversion = INVERSION_AUTO;
1428
1429 fep->bandwidth_hz = BANDWIDTH_TO_HZ(state->current_bandwidth);
1430
1431 switch ((tps >> 8) & 0x3) {
1432 case 0:
1433 fep->transmission_mode = TRANSMISSION_MODE_2K;
1434 break;
1435 case 1:
1436 fep->transmission_mode = TRANSMISSION_MODE_8K;
1437 break;
1438
1439 }
1440
1441 switch (tps & 0x3) {
1442 case 0:
1443 fep->guard_interval = GUARD_INTERVAL_1_32;
1444 break;
1445 case 1:
1446 fep->guard_interval = GUARD_INTERVAL_1_16;
1447 break;
1448 case 2:
1449 fep->guard_interval = GUARD_INTERVAL_1_8;
1450 break;
1451 case 3:
1452 fep->guard_interval = GUARD_INTERVAL_1_4;
1453 break;
1454 }
1455
1456 switch ((tps >> 14) & 0x3) {
1457 case 0:
1458 fep->modulation = QPSK;
1459 break;
1460 case 1:
1461 fep->modulation = QAM_16;
1462 break;
1463 case 2:
1464 default:
1465 fep->modulation = QAM_64;
1466 break;
1467 }
1468
1469
1470
1471
1472 fep->hierarchy = HIERARCHY_NONE;
1473 switch ((tps >> 5) & 0x7) {
1474 case 1:
1475 fep->code_rate_HP = FEC_1_2;
1476 break;
1477 case 2:
1478 fep->code_rate_HP = FEC_2_3;
1479 break;
1480 case 3:
1481 fep->code_rate_HP = FEC_3_4;
1482 break;
1483 case 5:
1484 fep->code_rate_HP = FEC_5_6;
1485 break;
1486 case 7:
1487 default:
1488 fep->code_rate_HP = FEC_7_8;
1489 break;
1490
1491 }
1492
1493 switch ((tps >> 2) & 0x7) {
1494 case 1:
1495 fep->code_rate_LP = FEC_1_2;
1496 break;
1497 case 2:
1498 fep->code_rate_LP = FEC_2_3;
1499 break;
1500 case 3:
1501 fep->code_rate_LP = FEC_3_4;
1502 break;
1503 case 5:
1504 fep->code_rate_LP = FEC_5_6;
1505 break;
1506 case 7:
1507 default:
1508 fep->code_rate_LP = FEC_7_8;
1509 break;
1510 }
1511
1512
1513
1514 return 0;
1515}
1516
1517static int dib7000p_set_frontend(struct dvb_frontend *fe)
1518{
1519 struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
1520 struct dib7000p_state *state = fe->demodulator_priv;
1521 int time, ret;
1522
1523 if (state->version == SOC7090)
1524 dib7090_set_diversity_in(fe, 0);
1525 else
1526 dib7000p_set_output_mode(state, OUTMODE_HIGH_Z);
1527
1528
1529 state->sfn_workaround_active = buggy_sfn_workaround;
1530
1531 if (fe->ops.tuner_ops.set_params)
1532 fe->ops.tuner_ops.set_params(fe);
1533
1534
1535 state->agc_state = 0;
1536 do {
1537 time = dib7000p_agc_startup(fe);
1538 if (time != -1)
1539 msleep(time);
1540 } while (time != -1);
1541
1542 if (fep->transmission_mode == TRANSMISSION_MODE_AUTO ||
1543 fep->guard_interval == GUARD_INTERVAL_AUTO || fep->modulation == QAM_AUTO || fep->code_rate_HP == FEC_AUTO) {
1544 int i = 800, found;
1545
1546 dib7000p_autosearch_start(fe);
1547 do {
1548 msleep(1);
1549 found = dib7000p_autosearch_is_irq(fe);
1550 } while (found == 0 && i--);
1551
1552 dprintk("autosearch returns: %d\n", found);
1553 if (found == 0 || found == 1)
1554 return 0;
1555
1556 dib7000p_get_frontend(fe, fep);
1557 }
1558
1559 ret = dib7000p_tune(fe);
1560
1561
1562 if (state->version == SOC7090) {
1563 dib7090_set_output_mode(fe, state->cfg.output_mode);
1564 if (state->cfg.enMpegOutput == 0) {
1565 dib7090_setDibTxMux(state, MPEG_ON_DIBTX);
1566 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
1567 }
1568 } else
1569 dib7000p_set_output_mode(state, state->cfg.output_mode);
1570
1571 return ret;
1572}
1573
1574static int dib7000p_get_stats(struct dvb_frontend *fe, enum fe_status stat);
1575
1576static int dib7000p_read_status(struct dvb_frontend *fe, enum fe_status *stat)
1577{
1578 struct dib7000p_state *state = fe->demodulator_priv;
1579 u16 lock = dib7000p_read_word(state, 509);
1580
1581 *stat = 0;
1582
1583 if (lock & 0x8000)
1584 *stat |= FE_HAS_SIGNAL;
1585 if (lock & 0x3000)
1586 *stat |= FE_HAS_CARRIER;
1587 if (lock & 0x0100)
1588 *stat |= FE_HAS_VITERBI;
1589 if (lock & 0x0010)
1590 *stat |= FE_HAS_SYNC;
1591 if ((lock & 0x0038) == 0x38)
1592 *stat |= FE_HAS_LOCK;
1593
1594 dib7000p_get_stats(fe, *stat);
1595
1596 return 0;
1597}
1598
1599static int dib7000p_read_ber(struct dvb_frontend *fe, u32 * ber)
1600{
1601 struct dib7000p_state *state = fe->demodulator_priv;
1602 *ber = (dib7000p_read_word(state, 500) << 16) | dib7000p_read_word(state, 501);
1603 return 0;
1604}
1605
1606static int dib7000p_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
1607{
1608 struct dib7000p_state *state = fe->demodulator_priv;
1609 *unc = dib7000p_read_word(state, 506);
1610 return 0;
1611}
1612
1613static int dib7000p_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
1614{
1615 struct dib7000p_state *state = fe->demodulator_priv;
1616 u16 val = dib7000p_read_word(state, 394);
1617 *strength = 65535 - val;
1618 return 0;
1619}
1620
1621static u32 dib7000p_get_snr(struct dvb_frontend *fe)
1622{
1623 struct dib7000p_state *state = fe->demodulator_priv;
1624 u16 val;
1625 s32 signal_mant, signal_exp, noise_mant, noise_exp;
1626 u32 result = 0;
1627
1628 val = dib7000p_read_word(state, 479);
1629 noise_mant = (val >> 4) & 0xff;
1630 noise_exp = ((val & 0xf) << 2);
1631 val = dib7000p_read_word(state, 480);
1632 noise_exp += ((val >> 14) & 0x3);
1633 if ((noise_exp & 0x20) != 0)
1634 noise_exp -= 0x40;
1635
1636 signal_mant = (val >> 6) & 0xFF;
1637 signal_exp = (val & 0x3F);
1638 if ((signal_exp & 0x20) != 0)
1639 signal_exp -= 0x40;
1640
1641 if (signal_mant != 0)
1642 result = intlog10(2) * 10 * signal_exp + 10 * intlog10(signal_mant);
1643 else
1644 result = intlog10(2) * 10 * signal_exp - 100;
1645
1646 if (noise_mant != 0)
1647 result -= intlog10(2) * 10 * noise_exp + 10 * intlog10(noise_mant);
1648 else
1649 result -= intlog10(2) * 10 * noise_exp - 100;
1650
1651 return result;
1652}
1653
1654static int dib7000p_read_snr(struct dvb_frontend *fe, u16 *snr)
1655{
1656 u32 result;
1657
1658 result = dib7000p_get_snr(fe);
1659
1660 *snr = result / ((1 << 24) / 10);
1661 return 0;
1662}
1663
1664static void dib7000p_reset_stats(struct dvb_frontend *demod)
1665{
1666 struct dib7000p_state *state = demod->demodulator_priv;
1667 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1668 u32 ucb;
1669
1670 memset(&c->strength, 0, sizeof(c->strength));
1671 memset(&c->cnr, 0, sizeof(c->cnr));
1672 memset(&c->post_bit_error, 0, sizeof(c->post_bit_error));
1673 memset(&c->post_bit_count, 0, sizeof(c->post_bit_count));
1674 memset(&c->block_error, 0, sizeof(c->block_error));
1675
1676 c->strength.len = 1;
1677 c->cnr.len = 1;
1678 c->block_error.len = 1;
1679 c->block_count.len = 1;
1680 c->post_bit_error.len = 1;
1681 c->post_bit_count.len = 1;
1682
1683 c->strength.stat[0].scale = FE_SCALE_DECIBEL;
1684 c->strength.stat[0].uvalue = 0;
1685
1686 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1687 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1688 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1689 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1690 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1691
1692 dib7000p_read_unc_blocks(demod, &ucb);
1693
1694 state->old_ucb = ucb;
1695 state->ber_jiffies_stats = 0;
1696 state->per_jiffies_stats = 0;
1697}
1698
1699struct linear_segments {
1700 unsigned x;
1701 signed y;
1702};
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723#define DB_OFFSET 131000
1724
1725static struct linear_segments strength_to_db_table[] = {
1726 { 63630, DB_OFFSET - 20500},
1727 { 62273, DB_OFFSET - 21000},
1728 { 60162, DB_OFFSET - 22000},
1729 { 58730, DB_OFFSET - 23000},
1730 { 58294, DB_OFFSET - 24000},
1731 { 57778, DB_OFFSET - 25000},
1732 { 57320, DB_OFFSET - 26000},
1733 { 56779, DB_OFFSET - 27000},
1734 { 56293, DB_OFFSET - 28000},
1735 { 55724, DB_OFFSET - 29000},
1736 { 55145, DB_OFFSET - 30000},
1737 { 54680, DB_OFFSET - 31000},
1738 { 54293, DB_OFFSET - 32000},
1739 { 53813, DB_OFFSET - 33000},
1740 { 53427, DB_OFFSET - 34000},
1741 { 52981, DB_OFFSET - 35000},
1742
1743 { 52636, DB_OFFSET - 36000},
1744 { 52014, DB_OFFSET - 37000},
1745 { 51674, DB_OFFSET - 38000},
1746 { 50692, DB_OFFSET - 39000},
1747 { 49824, DB_OFFSET - 40000},
1748 { 49052, DB_OFFSET - 41000},
1749 { 48436, DB_OFFSET - 42000},
1750 { 47836, DB_OFFSET - 43000},
1751 { 47368, DB_OFFSET - 44000},
1752 { 46468, DB_OFFSET - 45000},
1753 { 45597, DB_OFFSET - 46000},
1754 { 44586, DB_OFFSET - 47000},
1755 { 43667, DB_OFFSET - 48000},
1756 { 42673, DB_OFFSET - 49000},
1757 { 41816, DB_OFFSET - 50000},
1758 { 40876, DB_OFFSET - 51000},
1759 { 0, 0},
1760};
1761
1762static u32 interpolate_value(u32 value, struct linear_segments *segments,
1763 unsigned len)
1764{
1765 u64 tmp64;
1766 u32 dx;
1767 s32 dy;
1768 int i, ret;
1769
1770 if (value >= segments[0].x)
1771 return segments[0].y;
1772 if (value < segments[len-1].x)
1773 return segments[len-1].y;
1774
1775 for (i = 1; i < len - 1; i++) {
1776
1777 if (value == segments[i].x)
1778 return segments[i].y;
1779 if (value > segments[i].x)
1780 break;
1781 }
1782
1783
1784 dy = segments[i - 1].y - segments[i].y;
1785 dx = segments[i - 1].x - segments[i].x;
1786
1787 tmp64 = value - segments[i].x;
1788 tmp64 *= dy;
1789 do_div(tmp64, dx);
1790 ret = segments[i].y + tmp64;
1791
1792 return ret;
1793}
1794
1795
1796static u32 dib7000p_get_time_us(struct dvb_frontend *demod)
1797{
1798 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1799 u64 time_us, tmp64;
1800 u32 tmp, denom;
1801 int guard, rate_num, rate_denum = 1, bits_per_symbol;
1802 int interleaving = 0, fft_div;
1803
1804 switch (c->guard_interval) {
1805 case GUARD_INTERVAL_1_4:
1806 guard = 4;
1807 break;
1808 case GUARD_INTERVAL_1_8:
1809 guard = 8;
1810 break;
1811 case GUARD_INTERVAL_1_16:
1812 guard = 16;
1813 break;
1814 default:
1815 case GUARD_INTERVAL_1_32:
1816 guard = 32;
1817 break;
1818 }
1819
1820 switch (c->transmission_mode) {
1821 case TRANSMISSION_MODE_2K:
1822 fft_div = 4;
1823 break;
1824 case TRANSMISSION_MODE_4K:
1825 fft_div = 2;
1826 break;
1827 default:
1828 case TRANSMISSION_MODE_8K:
1829 fft_div = 1;
1830 break;
1831 }
1832
1833 switch (c->modulation) {
1834 case DQPSK:
1835 case QPSK:
1836 bits_per_symbol = 2;
1837 break;
1838 case QAM_16:
1839 bits_per_symbol = 4;
1840 break;
1841 default:
1842 case QAM_64:
1843 bits_per_symbol = 6;
1844 break;
1845 }
1846
1847 switch ((c->hierarchy == 0 || 1 == 1) ? c->code_rate_HP : c->code_rate_LP) {
1848 case FEC_1_2:
1849 rate_num = 1;
1850 rate_denum = 2;
1851 break;
1852 case FEC_2_3:
1853 rate_num = 2;
1854 rate_denum = 3;
1855 break;
1856 case FEC_3_4:
1857 rate_num = 3;
1858 rate_denum = 4;
1859 break;
1860 case FEC_5_6:
1861 rate_num = 5;
1862 rate_denum = 6;
1863 break;
1864 default:
1865 case FEC_7_8:
1866 rate_num = 7;
1867 rate_denum = 8;
1868 break;
1869 }
1870
1871 denom = bits_per_symbol * rate_num * fft_div * 384;
1872
1873
1874
1875
1876
1877
1878
1879 if (!denom)
1880 return 0;
1881
1882
1883 time_us = rate_denum * (1008 * 1562500L);
1884 tmp64 = time_us;
1885 do_div(tmp64, guard);
1886 time_us = time_us + tmp64;
1887 time_us += denom / 2;
1888 do_div(time_us, denom);
1889
1890 tmp = 1008 * 96 * interleaving;
1891 time_us += tmp + tmp / guard;
1892
1893 return time_us;
1894}
1895
1896static int dib7000p_get_stats(struct dvb_frontend *demod, enum fe_status stat)
1897{
1898 struct dib7000p_state *state = demod->demodulator_priv;
1899 struct dtv_frontend_properties *c = &demod->dtv_property_cache;
1900 int show_per_stats = 0;
1901 u32 time_us = 0, val, snr;
1902 u64 blocks, ucb;
1903 s32 db;
1904 u16 strength;
1905
1906
1907 dib7000p_read_signal_strength(demod, &strength);
1908 val = strength;
1909 db = interpolate_value(val,
1910 strength_to_db_table,
1911 ARRAY_SIZE(strength_to_db_table)) - DB_OFFSET;
1912 c->strength.stat[0].svalue = db;
1913
1914
1915 if (!(stat & FE_HAS_LOCK)) {
1916 c->cnr.len = 1;
1917 c->block_count.len = 1;
1918 c->block_error.len = 1;
1919 c->post_bit_error.len = 1;
1920 c->post_bit_count.len = 1;
1921 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1922 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1923 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1924 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1925 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1926 return 0;
1927 }
1928
1929
1930 if (time_after(jiffies, state->per_jiffies_stats)) {
1931 state->per_jiffies_stats = jiffies + msecs_to_jiffies(1000);
1932
1933
1934 snr = dib7000p_get_snr(demod);
1935 if (snr)
1936 snr = (1000L * snr) >> 24;
1937 else
1938 snr = 0;
1939 c->cnr.stat[0].svalue = snr;
1940 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
1941
1942
1943 dib7000p_read_unc_blocks(demod, &val);
1944 ucb = val - state->old_ucb;
1945 if (val < state->old_ucb)
1946 ucb += 0x100000000LL;
1947
1948 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1949 c->block_error.stat[0].uvalue = ucb;
1950
1951
1952 if (!time_us)
1953 time_us = dib7000p_get_time_us(demod);
1954
1955 if (time_us) {
1956 blocks = 1250000ULL * 1000000ULL;
1957 do_div(blocks, time_us * 8 * 204);
1958 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1959 c->block_count.stat[0].uvalue += blocks;
1960 }
1961
1962 show_per_stats = 1;
1963 }
1964
1965
1966 if (time_after(jiffies, state->ber_jiffies_stats)) {
1967 time_us = dib7000p_get_time_us(demod);
1968 state->ber_jiffies_stats = jiffies + msecs_to_jiffies((time_us + 500) / 1000);
1969
1970 dprintk("Next all layers stats available in %u us.\n", time_us);
1971
1972 dib7000p_read_ber(demod, &val);
1973 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
1974 c->post_bit_error.stat[0].uvalue += val;
1975
1976 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
1977 c->post_bit_count.stat[0].uvalue += 100000000;
1978 }
1979
1980
1981 if (show_per_stats) {
1982 dib7000p_read_unc_blocks(demod, &val);
1983
1984 c->block_error.stat[0].scale = FE_SCALE_COUNTER;
1985 c->block_error.stat[0].uvalue += val;
1986
1987 time_us = dib7000p_get_time_us(demod);
1988 if (time_us) {
1989 blocks = 1250000ULL * 1000000ULL;
1990 do_div(blocks, time_us * 8 * 204);
1991 c->block_count.stat[0].scale = FE_SCALE_COUNTER;
1992 c->block_count.stat[0].uvalue += blocks;
1993 }
1994 }
1995 return 0;
1996}
1997
1998static int dib7000p_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
1999{
2000 tune->min_delay_ms = 1000;
2001 return 0;
2002}
2003
2004static void dib7000p_release(struct dvb_frontend *demod)
2005{
2006 struct dib7000p_state *st = demod->demodulator_priv;
2007 dibx000_exit_i2c_master(&st->i2c_master);
2008 i2c_del_adapter(&st->dib7090_tuner_adap);
2009 kfree(st);
2010}
2011
2012static int dib7000pc_detection(struct i2c_adapter *i2c_adap)
2013{
2014 u8 *tx, *rx;
2015 struct i2c_msg msg[2] = {
2016 {.addr = 18 >> 1, .flags = 0, .len = 2},
2017 {.addr = 18 >> 1, .flags = I2C_M_RD, .len = 2},
2018 };
2019 int ret = 0;
2020
2021 tx = kzalloc(2, GFP_KERNEL);
2022 if (!tx)
2023 return -ENOMEM;
2024 rx = kzalloc(2, GFP_KERNEL);
2025 if (!rx) {
2026 ret = -ENOMEM;
2027 goto rx_memory_error;
2028 }
2029
2030 msg[0].buf = tx;
2031 msg[1].buf = rx;
2032
2033 tx[0] = 0x03;
2034 tx[1] = 0x00;
2035
2036 if (i2c_transfer(i2c_adap, msg, 2) == 2)
2037 if (rx[0] == 0x01 && rx[1] == 0xb3) {
2038 dprintk("-D- DiB7000PC detected\n");
2039 return 1;
2040 }
2041
2042 msg[0].addr = msg[1].addr = 0x40;
2043
2044 if (i2c_transfer(i2c_adap, msg, 2) == 2)
2045 if (rx[0] == 0x01 && rx[1] == 0xb3) {
2046 dprintk("-D- DiB7000PC detected\n");
2047 return 1;
2048 }
2049
2050 dprintk("-D- DiB7000PC not detected\n");
2051
2052 kfree(rx);
2053rx_memory_error:
2054 kfree(tx);
2055 return ret;
2056}
2057
2058static struct i2c_adapter *dib7000p_get_i2c_master(struct dvb_frontend *demod, enum dibx000_i2c_interface intf, int gating)
2059{
2060 struct dib7000p_state *st = demod->demodulator_priv;
2061 return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
2062}
2063
2064static int dib7000p_pid_filter_ctrl(struct dvb_frontend *fe, u8 onoff)
2065{
2066 struct dib7000p_state *state = fe->demodulator_priv;
2067 u16 val = dib7000p_read_word(state, 235) & 0xffef;
2068 val |= (onoff & 0x1) << 4;
2069 dprintk("PID filter enabled %d\n", onoff);
2070 return dib7000p_write_word(state, 235, val);
2071}
2072
2073static int dib7000p_pid_filter(struct dvb_frontend *fe, u8 id, u16 pid, u8 onoff)
2074{
2075 struct dib7000p_state *state = fe->demodulator_priv;
2076 dprintk("PID filter: index %x, PID %d, OnOff %d\n", id, pid, onoff);
2077 return dib7000p_write_word(state, 241 + id, onoff ? (1 << 13) | pid : 0);
2078}
2079
2080static int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[])
2081{
2082 struct dib7000p_state *dpst;
2083 int k = 0;
2084 u8 new_addr = 0;
2085
2086 dpst = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
2087 if (!dpst)
2088 return -ENOMEM;
2089
2090 dpst->i2c_adap = i2c;
2091 mutex_init(&dpst->i2c_buffer_lock);
2092
2093 for (k = no_of_demods - 1; k >= 0; k--) {
2094 dpst->cfg = cfg[k];
2095
2096
2097 if (cfg[k].default_i2c_addr != 0)
2098 new_addr = cfg[k].default_i2c_addr + (k << 1);
2099 else
2100 new_addr = (0x40 + k) << 1;
2101 dpst->i2c_addr = new_addr;
2102 dib7000p_write_word(dpst, 1287, 0x0003);
2103 if (dib7000p_identify(dpst) != 0) {
2104 dpst->i2c_addr = default_addr;
2105 dib7000p_write_word(dpst, 1287, 0x0003);
2106 if (dib7000p_identify(dpst) != 0) {
2107 dprintk("DiB7000P #%d: not identified\n", k);
2108 kfree(dpst);
2109 return -EIO;
2110 }
2111 }
2112
2113
2114 dib7000p_set_output_mode(dpst, OUTMODE_DIVERSITY);
2115
2116
2117 dib7000p_write_word(dpst, 1285, (new_addr << 2) | 0x2);
2118
2119 dprintk("IC %d initialized (to i2c_address 0x%x)\n", k, new_addr);
2120 }
2121
2122 for (k = 0; k < no_of_demods; k++) {
2123 dpst->cfg = cfg[k];
2124 if (cfg[k].default_i2c_addr != 0)
2125 dpst->i2c_addr = (cfg[k].default_i2c_addr + k) << 1;
2126 else
2127 dpst->i2c_addr = (0x40 + k) << 1;
2128
2129
2130 dib7000p_write_word(dpst, 1285, dpst->i2c_addr << 2);
2131
2132
2133 dib7000p_set_output_mode(dpst, OUTMODE_HIGH_Z);
2134 }
2135
2136 kfree(dpst);
2137 return 0;
2138}
2139
2140static const s32 lut_1000ln_mant[] = {
2141 6908, 6956, 7003, 7047, 7090, 7131, 7170, 7208, 7244, 7279, 7313, 7346, 7377, 7408, 7438, 7467, 7495, 7523, 7549, 7575, 7600
2142};
2143
2144static s32 dib7000p_get_adc_power(struct dvb_frontend *fe)
2145{
2146 struct dib7000p_state *state = fe->demodulator_priv;
2147 u32 tmp_val = 0, exp = 0, mant = 0;
2148 s32 pow_i;
2149 u16 buf[2];
2150 u8 ix = 0;
2151
2152 buf[0] = dib7000p_read_word(state, 0x184);
2153 buf[1] = dib7000p_read_word(state, 0x185);
2154 pow_i = (buf[0] << 16) | buf[1];
2155 dprintk("raw pow_i = %d\n", pow_i);
2156
2157 tmp_val = pow_i;
2158 while (tmp_val >>= 1)
2159 exp++;
2160
2161 mant = (pow_i * 1000 / (1 << exp));
2162 dprintk(" mant = %d exp = %d\n", mant / 1000, exp);
2163
2164 ix = (u8) ((mant - 1000) / 100);
2165 dprintk(" ix = %d\n", ix);
2166
2167 pow_i = (lut_1000ln_mant[ix] + 693 * (exp - 20) - 6908);
2168 pow_i = (pow_i << 8) / 1000;
2169 dprintk(" pow_i = %d\n", pow_i);
2170
2171 return pow_i;
2172}
2173
2174static int map_addr_to_serpar_number(struct i2c_msg *msg)
2175{
2176 if ((msg->buf[0] <= 15))
2177 msg->buf[0] -= 1;
2178 else if (msg->buf[0] == 17)
2179 msg->buf[0] = 15;
2180 else if (msg->buf[0] == 16)
2181 msg->buf[0] = 17;
2182 else if (msg->buf[0] == 19)
2183 msg->buf[0] = 16;
2184 else if (msg->buf[0] >= 21 && msg->buf[0] <= 25)
2185 msg->buf[0] -= 3;
2186 else if (msg->buf[0] == 28)
2187 msg->buf[0] = 23;
2188 else
2189 return -EINVAL;
2190 return 0;
2191}
2192
2193static int w7090p_tuner_write_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2194{
2195 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2196 u8 n_overflow = 1;
2197 u16 i = 1000;
2198 u16 serpar_num = msg[0].buf[0];
2199
2200 while (n_overflow == 1 && i) {
2201 n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
2202 i--;
2203 if (i == 0)
2204 dprintk("Tuner ITF: write busy (overflow)\n");
2205 }
2206 dib7000p_write_word(state, 1985, (1 << 6) | (serpar_num & 0x3f));
2207 dib7000p_write_word(state, 1986, (msg[0].buf[1] << 8) | msg[0].buf[2]);
2208
2209 return num;
2210}
2211
2212static int w7090p_tuner_read_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2213{
2214 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2215 u8 n_overflow = 1, n_empty = 1;
2216 u16 i = 1000;
2217 u16 serpar_num = msg[0].buf[0];
2218 u16 read_word;
2219
2220 while (n_overflow == 1 && i) {
2221 n_overflow = (dib7000p_read_word(state, 1984) >> 1) & 0x1;
2222 i--;
2223 if (i == 0)
2224 dprintk("TunerITF: read busy (overflow)\n");
2225 }
2226 dib7000p_write_word(state, 1985, (0 << 6) | (serpar_num & 0x3f));
2227
2228 i = 1000;
2229 while (n_empty == 1 && i) {
2230 n_empty = dib7000p_read_word(state, 1984) & 0x1;
2231 i--;
2232 if (i == 0)
2233 dprintk("TunerITF: read busy (empty)\n");
2234 }
2235 read_word = dib7000p_read_word(state, 1987);
2236 msg[1].buf[0] = (read_word >> 8) & 0xff;
2237 msg[1].buf[1] = (read_word) & 0xff;
2238
2239 return num;
2240}
2241
2242static int w7090p_tuner_rw_serpar(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2243{
2244 if (map_addr_to_serpar_number(&msg[0]) == 0) {
2245 if (num == 1) {
2246 return w7090p_tuner_write_serpar(i2c_adap, msg, 1);
2247 } else {
2248 return w7090p_tuner_read_serpar(i2c_adap, msg, 2);
2249 }
2250 }
2251 return num;
2252}
2253
2254static int dib7090p_rw_on_apb(struct i2c_adapter *i2c_adap,
2255 struct i2c_msg msg[], int num, u16 apb_address)
2256{
2257 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2258 u16 word;
2259
2260 if (num == 1) {
2261 dib7000p_write_word(state, apb_address, ((msg[0].buf[1] << 8) | (msg[0].buf[2])));
2262 } else {
2263 word = dib7000p_read_word(state, apb_address);
2264 msg[1].buf[0] = (word >> 8) & 0xff;
2265 msg[1].buf[1] = (word) & 0xff;
2266 }
2267
2268 return num;
2269}
2270
2271static int dib7090_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
2272{
2273 struct dib7000p_state *state = i2c_get_adapdata(i2c_adap);
2274
2275 u16 apb_address = 0, word;
2276 int i = 0;
2277 switch (msg[0].buf[0]) {
2278 case 0x12:
2279 apb_address = 1920;
2280 break;
2281 case 0x14:
2282 apb_address = 1921;
2283 break;
2284 case 0x24:
2285 apb_address = 1922;
2286 break;
2287 case 0x1a:
2288 apb_address = 1923;
2289 break;
2290 case 0x22:
2291 apb_address = 1924;
2292 break;
2293 case 0x33:
2294 apb_address = 1926;
2295 break;
2296 case 0x34:
2297 apb_address = 1927;
2298 break;
2299 case 0x35:
2300 apb_address = 1928;
2301 break;
2302 case 0x36:
2303 apb_address = 1929;
2304 break;
2305 case 0x37:
2306 apb_address = 1930;
2307 break;
2308 case 0x38:
2309 apb_address = 1931;
2310 break;
2311 case 0x39:
2312 apb_address = 1932;
2313 break;
2314 case 0x2a:
2315 apb_address = 1935;
2316 break;
2317 case 0x2b:
2318 apb_address = 1936;
2319 break;
2320 case 0x2c:
2321 apb_address = 1937;
2322 break;
2323 case 0x2d:
2324 apb_address = 1938;
2325 break;
2326 case 0x2e:
2327 apb_address = 1939;
2328 break;
2329 case 0x2f:
2330 apb_address = 1940;
2331 break;
2332 case 0x30:
2333 apb_address = 1941;
2334 break;
2335 case 0x31:
2336 apb_address = 1942;
2337 break;
2338 case 0x32:
2339 apb_address = 1943;
2340 break;
2341 case 0x3e:
2342 apb_address = 1944;
2343 break;
2344 case 0x3f:
2345 apb_address = 1945;
2346 break;
2347 case 0x40:
2348 apb_address = 1948;
2349 break;
2350 case 0x25:
2351 apb_address = 914;
2352 break;
2353 case 0x26:
2354 apb_address = 915;
2355 break;
2356 case 0x27:
2357 apb_address = 917;
2358 break;
2359 case 0x28:
2360 apb_address = 916;
2361 break;
2362 case 0x1d:
2363 i = ((dib7000p_read_word(state, 72) >> 12) & 0x3);
2364 word = dib7000p_read_word(state, 384 + i);
2365 msg[1].buf[0] = (word >> 8) & 0xff;
2366 msg[1].buf[1] = (word) & 0xff;
2367 return num;
2368 case 0x1f:
2369 if (num == 1) {
2370 word = (u16) ((msg[0].buf[1] << 8) | msg[0].buf[2]);
2371 word &= 0x3;
2372 word = (dib7000p_read_word(state, 72) & ~(3 << 12)) | (word << 12);
2373 dib7000p_write_word(state, 72, word);
2374 return num;
2375 }
2376 }
2377
2378 if (apb_address != 0)
2379 return dib7090p_rw_on_apb(i2c_adap, msg, num, apb_address);
2380 else
2381 return w7090p_tuner_rw_serpar(i2c_adap, msg, num);
2382
2383 return 0;
2384}
2385
2386static u32 dib7000p_i2c_func(struct i2c_adapter *adapter)
2387{
2388 return I2C_FUNC_I2C;
2389}
2390
2391static const struct i2c_algorithm dib7090_tuner_xfer_algo = {
2392 .master_xfer = dib7090_tuner_xfer,
2393 .functionality = dib7000p_i2c_func,
2394};
2395
2396static struct i2c_adapter *dib7090_get_i2c_tuner(struct dvb_frontend *fe)
2397{
2398 struct dib7000p_state *st = fe->demodulator_priv;
2399 return &st->dib7090_tuner_adap;
2400}
2401
2402static int dib7090_host_bus_drive(struct dib7000p_state *state, u8 drive)
2403{
2404 u16 reg;
2405
2406
2407 reg = dib7000p_read_word(state, 1798) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2408 reg |= (drive << 12) | (drive << 6) | drive;
2409 dib7000p_write_word(state, 1798, reg);
2410
2411
2412 reg = dib7000p_read_word(state, 1799) & ~((0x7 << 2) | (0x7 << 8));
2413 reg |= (drive << 8) | (drive << 2);
2414 dib7000p_write_word(state, 1799, reg);
2415
2416
2417 reg = dib7000p_read_word(state, 1800) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2418 reg |= (drive << 12) | (drive << 6) | drive;
2419 dib7000p_write_word(state, 1800, reg);
2420
2421
2422 reg = dib7000p_read_word(state, 1801) & ~((0x7 << 2) | (0x7 << 8));
2423 reg |= (drive << 8) | (drive << 2);
2424 dib7000p_write_word(state, 1801, reg);
2425
2426
2427 reg = dib7000p_read_word(state, 1802) & ~((0x7) | (0x7 << 6) | (0x7 << 12));
2428 reg |= (drive << 12) | (drive << 6) | drive;
2429 dib7000p_write_word(state, 1802, reg);
2430
2431 return 0;
2432}
2433
2434static u32 dib7090_calcSyncFreq(u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 syncSize)
2435{
2436 u32 quantif = 3;
2437 u32 nom = (insertExtSynchro * P_Kin + syncSize);
2438 u32 denom = P_Kout;
2439 u32 syncFreq = ((nom << quantif) / denom);
2440
2441 if ((syncFreq & ((1 << quantif) - 1)) != 0)
2442 syncFreq = (syncFreq >> quantif) + 1;
2443 else
2444 syncFreq = (syncFreq >> quantif);
2445
2446 if (syncFreq != 0)
2447 syncFreq = syncFreq - 1;
2448
2449 return syncFreq;
2450}
2451
2452static int dib7090_cfg_DibTx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 insertExtSynchro, u32 synchroMode, u32 syncWord, u32 syncSize)
2453{
2454 dprintk("Configure DibStream Tx\n");
2455
2456 dib7000p_write_word(state, 1615, 1);
2457 dib7000p_write_word(state, 1603, P_Kin);
2458 dib7000p_write_word(state, 1605, P_Kout);
2459 dib7000p_write_word(state, 1606, insertExtSynchro);
2460 dib7000p_write_word(state, 1608, synchroMode);
2461 dib7000p_write_word(state, 1609, (syncWord >> 16) & 0xffff);
2462 dib7000p_write_word(state, 1610, syncWord & 0xffff);
2463 dib7000p_write_word(state, 1612, syncSize);
2464 dib7000p_write_word(state, 1615, 0);
2465
2466 return 0;
2467}
2468
2469static int dib7090_cfg_DibRx(struct dib7000p_state *state, u32 P_Kin, u32 P_Kout, u32 synchroMode, u32 insertExtSynchro, u32 syncWord, u32 syncSize,
2470 u32 dataOutRate)
2471{
2472 u32 syncFreq;
2473
2474 dprintk("Configure DibStream Rx\n");
2475 if ((P_Kin != 0) && (P_Kout != 0)) {
2476 syncFreq = dib7090_calcSyncFreq(P_Kin, P_Kout, insertExtSynchro, syncSize);
2477 dib7000p_write_word(state, 1542, syncFreq);
2478 }
2479 dib7000p_write_word(state, 1554, 1);
2480 dib7000p_write_word(state, 1536, P_Kin);
2481 dib7000p_write_word(state, 1537, P_Kout);
2482 dib7000p_write_word(state, 1539, synchroMode);
2483 dib7000p_write_word(state, 1540, (syncWord >> 16) & 0xffff);
2484 dib7000p_write_word(state, 1541, syncWord & 0xffff);
2485 dib7000p_write_word(state, 1543, syncSize);
2486 dib7000p_write_word(state, 1544, dataOutRate);
2487 dib7000p_write_word(state, 1554, 0);
2488
2489 return 0;
2490}
2491
2492static void dib7090_enMpegMux(struct dib7000p_state *state, int onoff)
2493{
2494 u16 reg_1287 = dib7000p_read_word(state, 1287);
2495
2496 switch (onoff) {
2497 case 1:
2498 reg_1287 &= ~(1<<7);
2499 break;
2500 case 0:
2501 reg_1287 |= (1<<7);
2502 break;
2503 }
2504
2505 dib7000p_write_word(state, 1287, reg_1287);
2506}
2507
2508static void dib7090_configMpegMux(struct dib7000p_state *state,
2509 u16 pulseWidth, u16 enSerialMode, u16 enSerialClkDiv2)
2510{
2511 dprintk("Enable Mpeg mux\n");
2512
2513 dib7090_enMpegMux(state, 0);
2514
2515
2516 if ((enSerialMode == 1) && (state->input_mode_mpeg == 1))
2517 enSerialClkDiv2 = 0;
2518
2519 dib7000p_write_word(state, 1287, ((pulseWidth & 0x1f) << 2)
2520 | ((enSerialMode & 0x1) << 1)
2521 | (enSerialClkDiv2 & 0x1));
2522
2523 dib7090_enMpegMux(state, 1);
2524}
2525
2526static void dib7090_setDibTxMux(struct dib7000p_state *state, int mode)
2527{
2528 u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 7);
2529
2530 switch (mode) {
2531 case MPEG_ON_DIBTX:
2532 dprintk("SET MPEG ON DIBSTREAM TX\n");
2533 dib7090_cfg_DibTx(state, 8, 5, 0, 0, 0, 0);
2534 reg_1288 |= (1<<9);
2535 break;
2536 case DIV_ON_DIBTX:
2537 dprintk("SET DIV_OUT ON DIBSTREAM TX\n");
2538 dib7090_cfg_DibTx(state, 5, 5, 0, 0, 0, 0);
2539 reg_1288 |= (1<<8);
2540 break;
2541 case ADC_ON_DIBTX:
2542 dprintk("SET ADC_OUT ON DIBSTREAM TX\n");
2543 dib7090_cfg_DibTx(state, 20, 5, 10, 0, 0, 0);
2544 reg_1288 |= (1<<7);
2545 break;
2546 default:
2547 break;
2548 }
2549 dib7000p_write_word(state, 1288, reg_1288);
2550}
2551
2552static void dib7090_setHostBusMux(struct dib7000p_state *state, int mode)
2553{
2554 u16 reg_1288 = dib7000p_read_word(state, 1288) & ~(0x7 << 4);
2555
2556 switch (mode) {
2557 case DEMOUT_ON_HOSTBUS:
2558 dprintk("SET DEM OUT OLD INTERF ON HOST BUS\n");
2559 dib7090_enMpegMux(state, 0);
2560 reg_1288 |= (1<<6);
2561 break;
2562 case DIBTX_ON_HOSTBUS:
2563 dprintk("SET DIBSTREAM TX ON HOST BUS\n");
2564 dib7090_enMpegMux(state, 0);
2565 reg_1288 |= (1<<5);
2566 break;
2567 case MPEG_ON_HOSTBUS:
2568 dprintk("SET MPEG MUX ON HOST BUS\n");
2569 reg_1288 |= (1<<4);
2570 break;
2571 default:
2572 break;
2573 }
2574 dib7000p_write_word(state, 1288, reg_1288);
2575}
2576
2577static int dib7090_set_diversity_in(struct dvb_frontend *fe, int onoff)
2578{
2579 struct dib7000p_state *state = fe->demodulator_priv;
2580 u16 reg_1287;
2581
2582 switch (onoff) {
2583 case 0:
2584 dprintk("%s mode OFF : by default Enable Mpeg INPUT\n", __func__);
2585 dib7090_cfg_DibRx(state, 8, 5, 0, 0, 0, 8, 0);
2586
2587
2588
2589 reg_1287 = dib7000p_read_word(state, 1287);
2590
2591 if ((reg_1287 & 0x1) == 1) {
2592
2593 reg_1287 &= ~0x1;
2594 dib7000p_write_word(state, 1287, reg_1287);
2595 }
2596 state->input_mode_mpeg = 1;
2597 break;
2598 case 1:
2599 case 2:
2600 dprintk("%s ON : Enable diversity INPUT\n", __func__);
2601 dib7090_cfg_DibRx(state, 5, 5, 0, 0, 0, 0, 0);
2602 state->input_mode_mpeg = 0;
2603 break;
2604 }
2605
2606 dib7000p_set_diversity_in(&state->demod, onoff);
2607 return 0;
2608}
2609
2610static int dib7090_set_output_mode(struct dvb_frontend *fe, int mode)
2611{
2612 struct dib7000p_state *state = fe->demodulator_priv;
2613
2614 u16 outreg, smo_mode, fifo_threshold;
2615 u8 prefer_mpeg_mux_use = 1;
2616 int ret = 0;
2617
2618 dib7090_host_bus_drive(state, 1);
2619
2620 fifo_threshold = 1792;
2621 smo_mode = (dib7000p_read_word(state, 235) & 0x0050) | (1 << 1);
2622 outreg = dib7000p_read_word(state, 1286) & ~((1 << 10) | (0x7 << 6) | (1 << 1));
2623
2624 switch (mode) {
2625 case OUTMODE_HIGH_Z:
2626 outreg = 0;
2627 break;
2628
2629 case OUTMODE_MPEG2_SERIAL:
2630 if (prefer_mpeg_mux_use) {
2631 dprintk("setting output mode TS_SERIAL using Mpeg Mux\n");
2632 dib7090_configMpegMux(state, 3, 1, 1);
2633 dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
2634 } else {
2635 dprintk("setting output mode TS_SERIAL using Smooth bloc\n");
2636 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2637 outreg |= (2<<6) | (0 << 1);
2638 }
2639 break;
2640
2641 case OUTMODE_MPEG2_PAR_GATED_CLK:
2642 if (prefer_mpeg_mux_use) {
2643 dprintk("setting output mode TS_PARALLEL_GATED using Mpeg Mux\n");
2644 dib7090_configMpegMux(state, 2, 0, 0);
2645 dib7090_setHostBusMux(state, MPEG_ON_HOSTBUS);
2646 } else {
2647 dprintk("setting output mode TS_PARALLEL_GATED using Smooth block\n");
2648 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2649 outreg |= (0<<6);
2650 }
2651 break;
2652
2653 case OUTMODE_MPEG2_PAR_CONT_CLK:
2654 dprintk("setting output mode TS_PARALLEL_CONT using Smooth block\n");
2655 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2656 outreg |= (1<<6);
2657 break;
2658
2659 case OUTMODE_MPEG2_FIFO:
2660 dprintk("setting output mode TS_FIFO using Smooth block\n");
2661 dib7090_setHostBusMux(state, DEMOUT_ON_HOSTBUS);
2662 outreg |= (5<<6);
2663 smo_mode |= (3 << 1);
2664 fifo_threshold = 512;
2665 break;
2666
2667 case OUTMODE_DIVERSITY:
2668 dprintk("setting output mode MODE_DIVERSITY\n");
2669 dib7090_setDibTxMux(state, DIV_ON_DIBTX);
2670 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
2671 break;
2672
2673 case OUTMODE_ANALOG_ADC:
2674 dprintk("setting output mode MODE_ANALOG_ADC\n");
2675 dib7090_setDibTxMux(state, ADC_ON_DIBTX);
2676 dib7090_setHostBusMux(state, DIBTX_ON_HOSTBUS);
2677 break;
2678 }
2679 if (mode != OUTMODE_HIGH_Z)
2680 outreg |= (1 << 10);
2681
2682 if (state->cfg.output_mpeg2_in_188_bytes)
2683 smo_mode |= (1 << 5);
2684
2685 ret |= dib7000p_write_word(state, 235, smo_mode);
2686 ret |= dib7000p_write_word(state, 236, fifo_threshold);
2687 ret |= dib7000p_write_word(state, 1286, outreg);
2688
2689 return ret;
2690}
2691
2692static int dib7090_tuner_sleep(struct dvb_frontend *fe, int onoff)
2693{
2694 struct dib7000p_state *state = fe->demodulator_priv;
2695 u16 en_cur_state;
2696
2697 dprintk("sleep dib7090: %d\n", onoff);
2698
2699 en_cur_state = dib7000p_read_word(state, 1922);
2700
2701 if (en_cur_state > 0xff)
2702 state->tuner_enable = en_cur_state;
2703
2704 if (onoff)
2705 en_cur_state &= 0x00ff;
2706 else {
2707 if (state->tuner_enable != 0)
2708 en_cur_state = state->tuner_enable;
2709 }
2710
2711 dib7000p_write_word(state, 1922, en_cur_state);
2712
2713 return 0;
2714}
2715
2716static int dib7090_get_adc_power(struct dvb_frontend *fe)
2717{
2718 return dib7000p_get_adc_power(fe);
2719}
2720
2721static int dib7090_slave_reset(struct dvb_frontend *fe)
2722{
2723 struct dib7000p_state *state = fe->demodulator_priv;
2724 u16 reg;
2725
2726 reg = dib7000p_read_word(state, 1794);
2727 dib7000p_write_word(state, 1794, reg | (4 << 12));
2728
2729 dib7000p_write_word(state, 1032, 0xffff);
2730 return 0;
2731}
2732
2733static const struct dvb_frontend_ops dib7000p_ops;
2734static struct dvb_frontend *dib7000p_init(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg)
2735{
2736 struct dvb_frontend *demod;
2737 struct dib7000p_state *st;
2738 st = kzalloc(sizeof(struct dib7000p_state), GFP_KERNEL);
2739 if (st == NULL)
2740 return NULL;
2741
2742 memcpy(&st->cfg, cfg, sizeof(struct dib7000p_config));
2743 st->i2c_adap = i2c_adap;
2744 st->i2c_addr = i2c_addr;
2745 st->gpio_val = cfg->gpio_val;
2746 st->gpio_dir = cfg->gpio_dir;
2747
2748
2749
2750
2751 if ((st->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (st->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
2752 st->cfg.output_mode = OUTMODE_MPEG2_FIFO;
2753
2754 demod = &st->demod;
2755 demod->demodulator_priv = st;
2756 memcpy(&st->demod.ops, &dib7000p_ops, sizeof(struct dvb_frontend_ops));
2757 mutex_init(&st->i2c_buffer_lock);
2758
2759 dib7000p_write_word(st, 1287, 0x0003);
2760
2761 if (dib7000p_identify(st) != 0)
2762 goto error;
2763
2764 st->version = dib7000p_read_word(st, 897);
2765
2766
2767
2768
2769 st->i2c_master.gated_tuner_i2c_adap.dev.parent = i2c_adap->dev.parent;
2770
2771 dibx000_init_i2c_master(&st->i2c_master, DIB7000P, st->i2c_adap, st->i2c_addr);
2772
2773
2774 strscpy(st->dib7090_tuner_adap.name, "DiB7090 tuner interface",
2775 sizeof(st->dib7090_tuner_adap.name));
2776 st->dib7090_tuner_adap.algo = &dib7090_tuner_xfer_algo;
2777 st->dib7090_tuner_adap.algo_data = NULL;
2778 st->dib7090_tuner_adap.dev.parent = st->i2c_adap->dev.parent;
2779 i2c_set_adapdata(&st->dib7090_tuner_adap, st);
2780 i2c_add_adapter(&st->dib7090_tuner_adap);
2781
2782 dib7000p_demod_reset(st);
2783
2784 dib7000p_reset_stats(demod);
2785
2786 if (st->version == SOC7090) {
2787 dib7090_set_output_mode(demod, st->cfg.output_mode);
2788 dib7090_set_diversity_in(demod, 0);
2789 }
2790
2791 return demod;
2792
2793error:
2794 kfree(st);
2795 return NULL;
2796}
2797
2798void *dib7000p_attach(struct dib7000p_ops *ops)
2799{
2800 if (!ops)
2801 return NULL;
2802
2803 ops->slave_reset = dib7090_slave_reset;
2804 ops->get_adc_power = dib7090_get_adc_power;
2805 ops->dib7000pc_detection = dib7000pc_detection;
2806 ops->get_i2c_tuner = dib7090_get_i2c_tuner;
2807 ops->tuner_sleep = dib7090_tuner_sleep;
2808 ops->init = dib7000p_init;
2809 ops->set_agc1_min = dib7000p_set_agc1_min;
2810 ops->set_gpio = dib7000p_set_gpio;
2811 ops->i2c_enumeration = dib7000p_i2c_enumeration;
2812 ops->pid_filter = dib7000p_pid_filter;
2813 ops->pid_filter_ctrl = dib7000p_pid_filter_ctrl;
2814 ops->get_i2c_master = dib7000p_get_i2c_master;
2815 ops->update_pll = dib7000p_update_pll;
2816 ops->ctrl_timf = dib7000p_ctrl_timf;
2817 ops->get_agc_values = dib7000p_get_agc_values;
2818 ops->set_wbd_ref = dib7000p_set_wbd_ref;
2819
2820 return ops;
2821}
2822EXPORT_SYMBOL(dib7000p_attach);
2823
2824static const struct dvb_frontend_ops dib7000p_ops = {
2825 .delsys = { SYS_DVBT },
2826 .info = {
2827 .name = "DiBcom 7000PC",
2828 .frequency_min_hz = 44250 * kHz,
2829 .frequency_max_hz = 867250 * kHz,
2830 .frequency_stepsize_hz = 62500,
2831 .caps = FE_CAN_INVERSION_AUTO |
2832 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
2833 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
2834 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
2835 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
2836 },
2837
2838 .release = dib7000p_release,
2839
2840 .init = dib7000p_wakeup,
2841 .sleep = dib7000p_sleep,
2842
2843 .set_frontend = dib7000p_set_frontend,
2844 .get_tune_settings = dib7000p_fe_get_tune_settings,
2845 .get_frontend = dib7000p_get_frontend,
2846
2847 .read_status = dib7000p_read_status,
2848 .read_ber = dib7000p_read_ber,
2849 .read_signal_strength = dib7000p_read_signal_strength,
2850 .read_snr = dib7000p_read_snr,
2851 .read_ucblocks = dib7000p_read_unc_blocks,
2852};
2853
2854MODULE_AUTHOR("Olivier Grenie <olivie.grenie@parrot.com>");
2855MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2856MODULE_DESCRIPTION("Driver for the DiBcom 7000PC COFDM demodulator");
2857MODULE_LICENSE("GPL");
2858