?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / media / dvb-frontends / stv0900_sw.c
blob3ca52ba411e630611d38ca5f89207298606dc448
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * stv0900_sw.c
4 *
5 * Driver for ST STV0900 satellite demodulator IC.
6 *
7 * Copyright (C) ST Microelectronics.
8 * Copyright (C) 2009 NetUP Inc.
9 * Copyright (C) 2009 Igor M. Liplianin <liplianin@netup.ru>
10 */
11
12 #include "stv0900.h"
13 #include "stv0900_reg.h"
14 #include "stv0900_priv.h"
15
16 s32 shiftx(s32 x, int demod, s32 shift)
17 {
18 if (demod == 1)
19 return x - shift;
20
21 return x;
22 }
23
24 int stv0900_check_signal_presence(struct stv0900_internal *intp,
25 enum fe_stv0900_demod_num demod)
26 {
27 s32 carr_offset,
28 agc2_integr,
29 max_carrier;
30
31 int no_signal = FALSE;
32
33 carr_offset = (stv0900_read_reg(intp, CFR2) << 8)
34 | stv0900_read_reg(intp, CFR1);
35 carr_offset = ge2comp(carr_offset, 16);
36 agc2_integr = (stv0900_read_reg(intp, AGC2I1) << 8)
37 | stv0900_read_reg(intp, AGC2I0);
38 max_carrier = intp->srch_range[demod] / 1000;
39
40 max_carrier += (max_carrier / 10);
41 max_carrier = 65536 * (max_carrier / 2);
42 max_carrier /= intp->mclk / 1000;
43 if (max_carrier > 0x4000)
44 max_carrier = 0x4000;
45
46 if ((agc2_integr > 0x2000)
47 || (carr_offset > (2 * max_carrier))
48 || (carr_offset < (-2 * max_carrier)))
49 no_signal = TRUE;
50
51 return no_signal;
52 }
53
54 static void stv0900_get_sw_loop_params(struct stv0900_internal *intp,
55 s32 *frequency_inc, s32 *sw_timeout,
56 s32 *steps,
57 enum fe_stv0900_demod_num demod)
58 {
59 s32 timeout, freq_inc, max_steps, srate, max_carrier;
60
61 enum fe_stv0900_search_standard standard;
62
63 srate = intp->symbol_rate[demod];
64 max_carrier = intp->srch_range[demod] / 1000;
65 max_carrier += max_carrier / 10;
66 standard = intp->srch_standard[demod];
67
68 max_carrier = 65536 * (max_carrier / 2);
69 max_carrier /= intp->mclk / 1000;
70
71 if (max_carrier > 0x4000)
72 max_carrier = 0x4000;
73
74 freq_inc = srate;
75 freq_inc /= intp->mclk >> 10;
76 freq_inc = freq_inc << 6;
77
78 switch (standard) {
79 case STV0900_SEARCH_DVBS1:
80 case STV0900_SEARCH_DSS:
81 freq_inc *= 3;
82 timeout = 20;
83 break;
84 case STV0900_SEARCH_DVBS2:
85 freq_inc *= 4;
86 timeout = 25;
87 break;
88 case STV0900_AUTO_SEARCH:
89 default:
90 freq_inc *= 3;
91 timeout = 25;
92 break;
93 }
94
95 freq_inc /= 100;
96
97 if ((freq_inc > max_carrier) || (freq_inc < 0))
98 freq_inc = max_carrier / 2;
99
100 timeout *= 27500;
101
102 if (srate > 0)
103 timeout /= srate / 1000;
104
105 if ((timeout > 100) || (timeout < 0))
106 timeout = 100;
107
108 max_steps = (max_carrier / freq_inc) + 1;
109
110 if ((max_steps > 100) || (max_steps < 0)) {
111 max_steps = 100;
112 freq_inc = max_carrier / max_steps;
113 }
114
115 *frequency_inc = freq_inc;
116 *sw_timeout = timeout;
117 *steps = max_steps;
118
119 }
120
121 static int stv0900_search_carr_sw_loop(struct stv0900_internal *intp,
122 s32 FreqIncr, s32 Timeout, int zigzag,
123 s32 MaxStep, enum fe_stv0900_demod_num demod)
124 {
125 int no_signal,
126 lock = FALSE;
127 s32 stepCpt,
128 freqOffset,
129 max_carrier;
130
131 max_carrier = intp->srch_range[demod] / 1000;
132 max_carrier += (max_carrier / 10);
133
134 max_carrier = 65536 * (max_carrier / 2);
135 max_carrier /= intp->mclk / 1000;
136
137 if (max_carrier > 0x4000)
138 max_carrier = 0x4000;
139
140 if (zigzag == TRUE)
141 freqOffset = 0;
142 else
143 freqOffset = -max_carrier + FreqIncr;
144
145 stepCpt = 0;
146
147 do {
148 stv0900_write_reg(intp, DMDISTATE, 0x1c);
149 stv0900_write_reg(intp, CFRINIT1, (freqOffset / 256) & 0xff);
150 stv0900_write_reg(intp, CFRINIT0, freqOffset & 0xff);
151 stv0900_write_reg(intp, DMDISTATE, 0x18);
152 stv0900_write_bits(intp, ALGOSWRST, 1);
153
154 if (intp->chip_id == 0x12) {
155 stv0900_write_bits(intp, RST_HWARE, 1);
156 stv0900_write_bits(intp, RST_HWARE, 0);
157 }
158
159 if (zigzag == TRUE) {
160 if (freqOffset >= 0)
161 freqOffset = -freqOffset - 2 * FreqIncr;
162 else
163 freqOffset = -freqOffset;
164 } else
165 freqOffset += + 2 * FreqIncr;
166
167 stepCpt++;
168 lock = stv0900_get_demod_lock(intp, demod, Timeout);
169 no_signal = stv0900_check_signal_presence(intp, demod);
170
171 } while ((lock == FALSE)
172 && (no_signal == FALSE)
173 && ((freqOffset - FreqIncr) < max_carrier)
174 && ((freqOffset + FreqIncr) > -max_carrier)
175 && (stepCpt < MaxStep));
176
177 stv0900_write_bits(intp, ALGOSWRST, 0);
178
179 return lock;
180 }
181
182 static int stv0900_sw_algo(struct stv0900_internal *intp,
183 enum fe_stv0900_demod_num demod)
184 {
185 int lock = FALSE,
186 no_signal,
187 zigzag;
188 s32 s2fw,
189 fqc_inc,
190 sft_stp_tout,
191 trial_cntr,
192 max_steps;
193
194 stv0900_get_sw_loop_params(intp, &fqc_inc, &sft_stp_tout,
195 &max_steps, demod);
196 switch (intp->srch_standard[demod]) {
197 case STV0900_SEARCH_DVBS1:
198 case STV0900_SEARCH_DSS:
199 if (intp->chip_id >= 0x20)
200 stv0900_write_reg(intp, CARFREQ, 0x3b);
201 else
202 stv0900_write_reg(intp, CARFREQ, 0xef);
203
204 stv0900_write_reg(intp, DMDCFGMD, 0x49);
205 zigzag = FALSE;
206 break;
207 case STV0900_SEARCH_DVBS2:
208 if (intp->chip_id >= 0x20)
209 stv0900_write_reg(intp, CORRELABS, 0x79);
210 else
211 stv0900_write_reg(intp, CORRELABS, 0x68);
212
213 stv0900_write_reg(intp, DMDCFGMD, 0x89);
214
215 zigzag = TRUE;
216 break;
217 case STV0900_AUTO_SEARCH:
218 default:
219 if (intp->chip_id >= 0x20) {
220 stv0900_write_reg(intp, CARFREQ, 0x3b);
221 stv0900_write_reg(intp, CORRELABS, 0x79);
222 } else {
223 stv0900_write_reg(intp, CARFREQ, 0xef);
224 stv0900_write_reg(intp, CORRELABS, 0x68);
225 }
226
227 stv0900_write_reg(intp, DMDCFGMD, 0xc9);
228 zigzag = FALSE;
229 break;
230 }
231
232 trial_cntr = 0;
233 do {
234 lock = stv0900_search_carr_sw_loop(intp,
235 fqc_inc,
236 sft_stp_tout,
237 zigzag,
238 max_steps,
239 demod);
240 no_signal = stv0900_check_signal_presence(intp, demod);
241 trial_cntr++;
242 if ((lock == TRUE)
243 || (no_signal == TRUE)
244 || (trial_cntr == 2)) {
245
246 if (intp->chip_id >= 0x20) {
247 stv0900_write_reg(intp, CARFREQ, 0x49);
248 stv0900_write_reg(intp, CORRELABS, 0x9e);
249 } else {
250 stv0900_write_reg(intp, CARFREQ, 0xed);
251 stv0900_write_reg(intp, CORRELABS, 0x88);
252 }
253
254 if ((stv0900_get_bits(intp, HEADER_MODE) ==
255 STV0900_DVBS2_FOUND) &&
256 (lock == TRUE)) {
257 msleep(sft_stp_tout);
258 s2fw = stv0900_get_bits(intp, FLYWHEEL_CPT);
259
260 if (s2fw < 0xd) {
261 msleep(sft_stp_tout);
262 s2fw = stv0900_get_bits(intp,
263 FLYWHEEL_CPT);
264 }
265
266 if (s2fw < 0xd) {
267 lock = FALSE;
268
269 if (trial_cntr < 2) {
270 if (intp->chip_id >= 0x20)
271 stv0900_write_reg(intp,
272 CORRELABS,
273 0x79);
274 else
275 stv0900_write_reg(intp,
276 CORRELABS,
277 0x68);
278
279 stv0900_write_reg(intp,
280 DMDCFGMD,
281 0x89);
282 }
283 }
284 }
285 }
286
287 } while ((lock == FALSE)
288 && (trial_cntr < 2)
289 && (no_signal == FALSE));
290
291 return lock;
292 }
293
294 static u32 stv0900_get_symbol_rate(struct stv0900_internal *intp,
295 u32 mclk,
296 enum fe_stv0900_demod_num demod)
297 {
298 s32 rem1, rem2, intval1, intval2, srate;
299
300 srate = (stv0900_get_bits(intp, SYMB_FREQ3) << 24) +
301 (stv0900_get_bits(intp, SYMB_FREQ2) << 16) +
302 (stv0900_get_bits(intp, SYMB_FREQ1) << 8) +
303 (stv0900_get_bits(intp, SYMB_FREQ0));
304 dprintk("lock: srate=%d r0=0x%x r1=0x%x r2=0x%x r3=0x%x \n",
305 srate, stv0900_get_bits(intp, SYMB_FREQ0),
306 stv0900_get_bits(intp, SYMB_FREQ1),
307 stv0900_get_bits(intp, SYMB_FREQ2),
308 stv0900_get_bits(intp, SYMB_FREQ3));
309
310 intval1 = (mclk) >> 16;
311 intval2 = (srate) >> 16;
312
313 rem1 = (mclk) % 0x10000;
314 rem2 = (srate) % 0x10000;
315 srate = (intval1 * intval2) +
316 ((intval1 * rem2) >> 16) +
317 ((intval2 * rem1) >> 16);
318
319 return srate;
320 }
321
322 static void stv0900_set_symbol_rate(struct stv0900_internal *intp,
323 u32 mclk, u32 srate,
324 enum fe_stv0900_demod_num demod)
325 {
326 u32 symb;
327
328 dprintk("%s: Mclk %d, SR %d, Dmd %d\n", __func__, mclk,
329 srate, demod);
330
331 if (srate > 60000000) {
332 symb = srate << 4;
333 symb /= (mclk >> 12);
334 } else if (srate > 6000000) {
335 symb = srate << 6;
336 symb /= (mclk >> 10);
337 } else {
338 symb = srate << 9;
339 symb /= (mclk >> 7);
340 }
341
342 stv0900_write_reg(intp, SFRINIT1, (symb >> 8) & 0x7f);
343 stv0900_write_reg(intp, SFRINIT1 + 1, (symb & 0xff));
344 }
345
346 static void stv0900_set_max_symbol_rate(struct stv0900_internal *intp,
347 u32 mclk, u32 srate,
348 enum fe_stv0900_demod_num demod)
349 {
350 u32 symb;
351
352 srate = 105 * (srate / 100);
353
354 if (srate > 60000000) {
355 symb = srate << 4;
356 symb /= (mclk >> 12);
357 } else if (srate > 6000000) {
358 symb = srate << 6;
359 symb /= (mclk >> 10);
360 } else {
361 symb = srate << 9;
362 symb /= (mclk >> 7);
363 }
364
365 if (symb < 0x7fff) {
366 stv0900_write_reg(intp, SFRUP1, (symb >> 8) & 0x7f);
367 stv0900_write_reg(intp, SFRUP1 + 1, (symb & 0xff));
368 } else {
369 stv0900_write_reg(intp, SFRUP1, 0x7f);
370 stv0900_write_reg(intp, SFRUP1 + 1, 0xff);
371 }
372 }
373
374 static void stv0900_set_min_symbol_rate(struct stv0900_internal *intp,
375 u32 mclk, u32 srate,
376 enum fe_stv0900_demod_num demod)
377 {
378 u32 symb;
379
380 srate = 95 * (srate / 100);
381 if (srate > 60000000) {
382 symb = srate << 4;
383 symb /= (mclk >> 12);
384
385 } else if (srate > 6000000) {
386 symb = srate << 6;
387 symb /= (mclk >> 10);
388
389 } else {
390 symb = srate << 9;
391 symb /= (mclk >> 7);
392 }
393
394 stv0900_write_reg(intp, SFRLOW1, (symb >> 8) & 0xff);
395 stv0900_write_reg(intp, SFRLOW1 + 1, (symb & 0xff));
396 }
397
398 static s32 stv0900_get_timing_offst(struct stv0900_internal *intp,
399 u32 srate,
400 enum fe_stv0900_demod_num demod)
401 {
402 s32 timingoffset;
403
404
405 timingoffset = (stv0900_read_reg(intp, TMGREG2) << 16) +
406 (stv0900_read_reg(intp, TMGREG2 + 1) << 8) +
407 (stv0900_read_reg(intp, TMGREG2 + 2));
408
409 timingoffset = ge2comp(timingoffset, 24);
410
411
412 if (timingoffset == 0)
413 timingoffset = 1;
414
415 timingoffset = ((s32)srate * 10) / ((s32)0x1000000 / timingoffset);
416 timingoffset /= 320;
417
418 return timingoffset;
419 }
420
421 static void stv0900_set_dvbs2_rolloff(struct stv0900_internal *intp,
422 enum fe_stv0900_demod_num demod)
423 {
424 s32 rolloff;
425
426 if (intp->chip_id == 0x10) {
427 stv0900_write_bits(intp, MANUALSX_ROLLOFF, 1);
428 rolloff = stv0900_read_reg(intp, MATSTR1) & 0x03;
429 stv0900_write_bits(intp, ROLLOFF_CONTROL, rolloff);
430 } else if (intp->chip_id <= 0x20)
431 stv0900_write_bits(intp, MANUALSX_ROLLOFF, 0);
432 else /* cut 3.0 */
433 stv0900_write_bits(intp, MANUALS2_ROLLOFF, 0);
434 }
435
436 static u32 stv0900_carrier_width(u32 srate, enum fe_stv0900_rolloff ro)
437 {
438 u32 rolloff;
439
440 switch (ro) {
441 case STV0900_20:
442 rolloff = 20;
443 break;
444 case STV0900_25:
445 rolloff = 25;
446 break;
447 case STV0900_35:
448 default:
449 rolloff = 35;
450 break;
451 }
452
453 return srate + (srate * rolloff) / 100;
454 }
455
456 static int stv0900_check_timing_lock(struct stv0900_internal *intp,
457 enum fe_stv0900_demod_num demod)
458 {
459 int timingLock = FALSE;
460 s32 i,
461 timingcpt = 0;
462 u8 car_freq,
463 tmg_th_high,
464 tmg_th_low;
465
466 car_freq = stv0900_read_reg(intp, CARFREQ);
467 tmg_th_high = stv0900_read_reg(intp, TMGTHRISE);
468 tmg_th_low = stv0900_read_reg(intp, TMGTHFALL);
469 stv0900_write_reg(intp, TMGTHRISE, 0x20);
470 stv0900_write_reg(intp, TMGTHFALL, 0x0);
471 stv0900_write_bits(intp, CFR_AUTOSCAN, 0);
472 stv0900_write_reg(intp, RTC, 0x80);
473 stv0900_write_reg(intp, RTCS2, 0x40);
474 stv0900_write_reg(intp, CARFREQ, 0x0);
475 stv0900_write_reg(intp, CFRINIT1, 0x0);
476 stv0900_write_reg(intp, CFRINIT0, 0x0);
477 stv0900_write_reg(intp, AGC2REF, 0x65);
478 stv0900_write_reg(intp, DMDISTATE, 0x18);
479 msleep(7);
480
481 for (i = 0; i < 10; i++) {
482 if (stv0900_get_bits(intp, TMGLOCK_QUALITY) >= 2)
483 timingcpt++;
484
485 msleep(1);
486 }
487
488 if (timingcpt >= 3)
489 timingLock = TRUE;
490
491 stv0900_write_reg(intp, AGC2REF, 0x38);
492 stv0900_write_reg(intp, RTC, 0x88);
493 stv0900_write_reg(intp, RTCS2, 0x68);
494 stv0900_write_reg(intp, CARFREQ, car_freq);
495 stv0900_write_reg(intp, TMGTHRISE, tmg_th_high);
496 stv0900_write_reg(intp, TMGTHFALL, tmg_th_low);
497
498 return timingLock;
499 }
500
501 static int stv0900_get_demod_cold_lock(struct dvb_frontend *fe,
502 s32 demod_timeout)
503 {
504 struct stv0900_state *state = fe->demodulator_priv;
505 struct stv0900_internal *intp = state->internal;
506 enum fe_stv0900_demod_num demod = state->demod;
507 int lock = FALSE,
508 d = demod;
509 s32 srate,
510 search_range,
511 locktimeout,
512 currier_step,
513 nb_steps,
514 current_step,
515 direction,
516 tuner_freq,
517 timeout,
518 freq;
519
520 srate = intp->symbol_rate[d];
521 search_range = intp->srch_range[d];
522
523 if (srate >= 10000000)
524 locktimeout = demod_timeout / 3;
525 else
526 locktimeout = demod_timeout / 2;
527
528 lock = stv0900_get_demod_lock(intp, d, locktimeout);
529
530 if (lock != FALSE)
531 return lock;
532
533 if (srate >= 10000000) {
534 if (stv0900_check_timing_lock(intp, d) == TRUE) {
535 stv0900_write_reg(intp, DMDISTATE, 0x1f);
536 stv0900_write_reg(intp, DMDISTATE, 0x15);
537 lock = stv0900_get_demod_lock(intp, d, demod_timeout);
538 } else
539 lock = FALSE;
540
541 return lock;
542 }
543
544 if (intp->chip_id <= 0x20) {
545 if (srate <= 1000000)
546 currier_step = 500;
547 else if (srate <= 4000000)
548 currier_step = 1000;
549 else if (srate <= 7000000)
550 currier_step = 2000;
551 else if (srate <= 10000000)
552 currier_step = 3000;
553 else
554 currier_step = 5000;
555
556 if (srate >= 2000000) {
557 timeout = (demod_timeout / 3);
558 if (timeout > 1000)
559 timeout = 1000;
560 } else
561 timeout = (demod_timeout / 2);
562 } else {
563 /*cut 3.0 */
564 currier_step = srate / 4000;
565 timeout = (demod_timeout * 3) / 4;
566 }
567
568 nb_steps = ((search_range / 1000) / currier_step);
569
570 if ((nb_steps % 2) != 0)
571 nb_steps += 1;
572
573 if (nb_steps <= 0)
574 nb_steps = 2;
575 else if (nb_steps > 12)
576 nb_steps = 12;
577
578 current_step = 1;
579 direction = 1;
580
581 if (intp->chip_id <= 0x20) {
582 tuner_freq = intp->freq[d];
583 intp->bw[d] = stv0900_carrier_width(intp->symbol_rate[d],
584 intp->rolloff) + intp->symbol_rate[d];
585 } else
586 tuner_freq = 0;
587
588 while ((current_step <= nb_steps) && (lock == FALSE)) {
589 if (direction > 0)
590 tuner_freq += (current_step * currier_step);
591 else
592 tuner_freq -= (current_step * currier_step);
593
594 if (intp->chip_id <= 0x20) {
595 if (intp->tuner_type[d] == 3)
596 stv0900_set_tuner_auto(intp, tuner_freq,
597 intp->bw[d], demod);
598 else
599 stv0900_set_tuner(fe, tuner_freq, intp->bw[d]);
600
601 stv0900_write_reg(intp, DMDISTATE, 0x1c);
602 stv0900_write_reg(intp, CFRINIT1, 0);
603 stv0900_write_reg(intp, CFRINIT0, 0);
604 stv0900_write_reg(intp, DMDISTATE, 0x1f);
605 stv0900_write_reg(intp, DMDISTATE, 0x15);
606 } else {
607 stv0900_write_reg(intp, DMDISTATE, 0x1c);
608 freq = (tuner_freq * 65536) / (intp->mclk / 1000);
609 stv0900_write_bits(intp, CFR_INIT1, MSB(freq));
610 stv0900_write_bits(intp, CFR_INIT0, LSB(freq));
611 stv0900_write_reg(intp, DMDISTATE, 0x1f);
612 stv0900_write_reg(intp, DMDISTATE, 0x05);
613 }
614
615 lock = stv0900_get_demod_lock(intp, d, timeout);
616 direction *= -1;
617 current_step++;
618 }
619
620 return lock;
621 }
622
623 static void stv0900_get_lock_timeout(s32 *demod_timeout, s32 *fec_timeout,
624 s32 srate,
625 enum fe_stv0900_search_algo algo)
626 {
627 switch (algo) {
628 case STV0900_BLIND_SEARCH:
629 if (srate <= 1500000) {
630 (*demod_timeout) = 1500;
631 (*fec_timeout) = 400;
632 } else if (srate <= 5000000) {
633 (*demod_timeout) = 1000;
634 (*fec_timeout) = 300;
635 } else {
636 (*demod_timeout) = 700;
637 (*fec_timeout) = 100;
638 }
639
640 break;
641 case STV0900_COLD_START:
642 case STV0900_WARM_START:
643 default:
644 if (srate <= 1000000) {
645 (*demod_timeout) = 3000;
646 (*fec_timeout) = 1700;
647 } else if (srate <= 2000000) {
648 (*demod_timeout) = 2500;
649 (*fec_timeout) = 1100;
650 } else if (srate <= 5000000) {
651 (*demod_timeout) = 1000;
652 (*fec_timeout) = 550;
653 } else if (srate <= 10000000) {
654 (*demod_timeout) = 700;
655 (*fec_timeout) = 250;
656 } else if (srate <= 20000000) {
657 (*demod_timeout) = 400;
658 (*fec_timeout) = 130;
659 } else {
660 (*demod_timeout) = 300;
661 (*fec_timeout) = 100;
662 }
663
664 break;
665
666 }
667
668 if (algo == STV0900_WARM_START)
669 (*demod_timeout) /= 2;
670 }
671
672 static void stv0900_set_viterbi_tracq(struct stv0900_internal *intp,
673 enum fe_stv0900_demod_num demod)
674 {
675
676 s32 vth_reg = VTH12;
677
678 dprintk("%s\n", __func__);
679
680 stv0900_write_reg(intp, vth_reg++, 0xd0);
681 stv0900_write_reg(intp, vth_reg++, 0x7d);
682 stv0900_write_reg(intp, vth_reg++, 0x53);
683 stv0900_write_reg(intp, vth_reg++, 0x2f);
684 stv0900_write_reg(intp, vth_reg++, 0x24);
685 stv0900_write_reg(intp, vth_reg++, 0x1f);
686 }
687
688 static void stv0900_set_viterbi_standard(struct stv0900_internal *intp,
689 enum fe_stv0900_search_standard standard,
690 enum fe_stv0900_fec fec,
691 enum fe_stv0900_demod_num demod)
692 {
693 dprintk("%s: ViterbiStandard = ", __func__);
694
695 switch (standard) {
696 case STV0900_AUTO_SEARCH:
697 dprintk("Auto\n");
698 stv0900_write_reg(intp, FECM, 0x10);
699 stv0900_write_reg(intp, PRVIT, 0x3f);
700 break;
701 case STV0900_SEARCH_DVBS1:
702 dprintk("DVBS1\n");
703 stv0900_write_reg(intp, FECM, 0x00);
704 switch (fec) {
705 case STV0900_FEC_UNKNOWN:
706 default:
707 stv0900_write_reg(intp, PRVIT, 0x2f);
708 break;
709 case STV0900_FEC_1_2:
710 stv0900_write_reg(intp, PRVIT, 0x01);
711 break;
712 case STV0900_FEC_2_3:
713 stv0900_write_reg(intp, PRVIT, 0x02);
714 break;
715 case STV0900_FEC_3_4:
716 stv0900_write_reg(intp, PRVIT, 0x04);
717 break;
718 case STV0900_FEC_5_6:
719 stv0900_write_reg(intp, PRVIT, 0x08);
720 break;
721 case STV0900_FEC_7_8:
722 stv0900_write_reg(intp, PRVIT, 0x20);
723 break;
724 }
725
726 break;
727 case STV0900_SEARCH_DSS:
728 dprintk("DSS\n");
729 stv0900_write_reg(intp, FECM, 0x80);
730 switch (fec) {
731 case STV0900_FEC_UNKNOWN:
732 default:
733 stv0900_write_reg(intp, PRVIT, 0x13);
734 break;
735 case STV0900_FEC_1_2:
736 stv0900_write_reg(intp, PRVIT, 0x01);
737 break;
738 case STV0900_FEC_2_3:
739 stv0900_write_reg(intp, PRVIT, 0x02);
740 break;
741 case STV0900_FEC_6_7:
742 stv0900_write_reg(intp, PRVIT, 0x10);
743 break;
744 }
745 break;
746 default:
747 break;
748 }
749 }
750
751 static enum fe_stv0900_fec stv0900_get_vit_fec(struct stv0900_internal *intp,
752 enum fe_stv0900_demod_num demod)
753 {
754 enum fe_stv0900_fec prate;
755 s32 rate_fld = stv0900_get_bits(intp, VIT_CURPUN);
756
757 switch (rate_fld) {
758 case 13:
759 prate = STV0900_FEC_1_2;
760 break;
761 case 18:
762 prate = STV0900_FEC_2_3;
763 break;
764 case 21:
765 prate = STV0900_FEC_3_4;
766 break;
767 case 24:
768 prate = STV0900_FEC_5_6;
769 break;
770 case 25:
771 prate = STV0900_FEC_6_7;
772 break;
773 case 26:
774 prate = STV0900_FEC_7_8;
775 break;
776 default:
777 prate = STV0900_FEC_UNKNOWN;
778 break;
779 }
780
781 return prate;
782 }
783
784 static void stv0900_set_dvbs1_track_car_loop(struct stv0900_internal *intp,
785 enum fe_stv0900_demod_num demod,
786 u32 srate)
787 {
788 if (intp->chip_id >= 0x30) {
789 if (srate >= 15000000) {
790 stv0900_write_reg(intp, ACLC, 0x2b);
791 stv0900_write_reg(intp, BCLC, 0x1a);
792 } else if ((srate >= 7000000) && (15000000 > srate)) {
793 stv0900_write_reg(intp, ACLC, 0x0c);
794 stv0900_write_reg(intp, BCLC, 0x1b);
795 } else if (srate < 7000000) {
796 stv0900_write_reg(intp, ACLC, 0x2c);
797 stv0900_write_reg(intp, BCLC, 0x1c);
798 }
799
800 } else { /*cut 2.0 and 1.x*/
801 stv0900_write_reg(intp, ACLC, 0x1a);
802 stv0900_write_reg(intp, BCLC, 0x09);
803 }
804
805 }
806
807 static void stv0900_track_optimization(struct dvb_frontend *fe)
808 {
809 struct stv0900_state *state = fe->demodulator_priv;
810 struct stv0900_internal *intp = state->internal;
811 enum fe_stv0900_demod_num demod = state->demod;
812
813 s32 srate,
814 pilots,
815 aclc,
816 freq1,
817 freq0,
818 i = 0,
819 timed,
820 timef,
821 blind_tun_sw = 0,
822 modulation;
823
824 enum fe_stv0900_modcode foundModcod;
825
826 dprintk("%s\n", __func__);
827
828 srate = stv0900_get_symbol_rate(intp, intp->mclk, demod);
829 srate += stv0900_get_timing_offst(intp, srate, demod);
830
831 switch (intp->result[demod].standard) {
832 case STV0900_DVBS1_STANDARD:
833 case STV0900_DSS_STANDARD:
834 dprintk("%s: found DVB-S or DSS\n", __func__);
835 if (intp->srch_standard[demod] == STV0900_AUTO_SEARCH) {
836 stv0900_write_bits(intp, DVBS1_ENABLE, 1);
837 stv0900_write_bits(intp, DVBS2_ENABLE, 0);
838 }
839
840 stv0900_write_bits(intp, ROLLOFF_CONTROL, intp->rolloff);
841 stv0900_write_bits(intp, MANUALSX_ROLLOFF, 1);
842
843 if (intp->chip_id < 0x30) {
844 stv0900_write_reg(intp, ERRCTRL1, 0x75);
845 break;
846 }
847
848 if (stv0900_get_vit_fec(intp, demod) == STV0900_FEC_1_2) {
849 stv0900_write_reg(intp, GAUSSR0, 0x98);
850 stv0900_write_reg(intp, CCIR0, 0x18);
851 } else {
852 stv0900_write_reg(intp, GAUSSR0, 0x18);
853 stv0900_write_reg(intp, CCIR0, 0x18);
854 }
855
856 stv0900_write_reg(intp, ERRCTRL1, 0x75);
857 break;
858 case STV0900_DVBS2_STANDARD:
859 dprintk("%s: found DVB-S2\n", __func__);
860 stv0900_write_bits(intp, DVBS1_ENABLE, 0);
861 stv0900_write_bits(intp, DVBS2_ENABLE, 1);
862 stv0900_write_reg(intp, ACLC, 0);
863 stv0900_write_reg(intp, BCLC, 0);
864 if (intp->result[demod].frame_len == STV0900_LONG_FRAME) {
865 foundModcod = stv0900_get_bits(intp, DEMOD_MODCOD);
866 pilots = stv0900_get_bits(intp, DEMOD_TYPE) & 0x01;
867 aclc = stv0900_get_optim_carr_loop(srate,
868 foundModcod,
869 pilots,
870 intp->chip_id);
871 if (foundModcod <= STV0900_QPSK_910)
872 stv0900_write_reg(intp, ACLC2S2Q, aclc);
873 else if (foundModcod <= STV0900_8PSK_910) {
874 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
875 stv0900_write_reg(intp, ACLC2S28, aclc);
876 }
877
878 if ((intp->demod_mode == STV0900_SINGLE) &&
879 (foundModcod > STV0900_8PSK_910)) {
880 if (foundModcod <= STV0900_16APSK_910) {
881 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
882 stv0900_write_reg(intp, ACLC2S216A,
883 aclc);
884 } else if (foundModcod <= STV0900_32APSK_910) {
885 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
886 stv0900_write_reg(intp, ACLC2S232A,
887 aclc);
888 }
889 }
890
891 } else {
892 modulation = intp->result[demod].modulation;
893 aclc = stv0900_get_optim_short_carr_loop(srate,
894 modulation, intp->chip_id);
895 if (modulation == STV0900_QPSK)
896 stv0900_write_reg(intp, ACLC2S2Q, aclc);
897 else if (modulation == STV0900_8PSK) {
898 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
899 stv0900_write_reg(intp, ACLC2S28, aclc);
900 } else if (modulation == STV0900_16APSK) {
901 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
902 stv0900_write_reg(intp, ACLC2S216A, aclc);
903 } else if (modulation == STV0900_32APSK) {
904 stv0900_write_reg(intp, ACLC2S2Q, 0x2a);
905 stv0900_write_reg(intp, ACLC2S232A, aclc);
906 }
907
908 }
909
910 if (intp->chip_id <= 0x11) {
911 if (intp->demod_mode != STV0900_SINGLE)
912 stv0900_activate_s2_modcod(intp, demod);
913
914 }
915
916 stv0900_write_reg(intp, ERRCTRL1, 0x67);
917 break;
918 case STV0900_UNKNOWN_STANDARD:
919 default:
920 dprintk("%s: found unknown standard\n", __func__);
921 stv0900_write_bits(intp, DVBS1_ENABLE, 1);
922 stv0900_write_bits(intp, DVBS2_ENABLE, 1);
923 break;
924 }
925
926 freq1 = stv0900_read_reg(intp, CFR2);
927 freq0 = stv0900_read_reg(intp, CFR1);
928 if (intp->srch_algo[demod] == STV0900_BLIND_SEARCH) {
929 stv0900_write_reg(intp, SFRSTEP, 0x00);
930 stv0900_write_bits(intp, SCAN_ENABLE, 0);
931 stv0900_write_bits(intp, CFR_AUTOSCAN, 0);
932 stv0900_write_reg(intp, TMGCFG2, 0xc1);
933 stv0900_set_symbol_rate(intp, intp->mclk, srate, demod);
934 blind_tun_sw = 1;
935 if (intp->result[demod].standard != STV0900_DVBS2_STANDARD)
936 stv0900_set_dvbs1_track_car_loop(intp, demod, srate);
937
938 }
939
940 if (intp->chip_id >= 0x20) {
941 if ((intp->srch_standard[demod] == STV0900_SEARCH_DVBS1) ||
942 (intp->srch_standard[demod] ==
943 STV0900_SEARCH_DSS) ||
944 (intp->srch_standard[demod] ==
945 STV0900_AUTO_SEARCH)) {
946 stv0900_write_reg(intp, VAVSRVIT, 0x0a);
947 stv0900_write_reg(intp, VITSCALE, 0x0);
948 }
949 }
950
951 if (intp->chip_id < 0x20)
952 stv0900_write_reg(intp, CARHDR, 0x08);
953
954 if (intp->chip_id == 0x10)
955 stv0900_write_reg(intp, CORRELEXP, 0x0a);
956
957 stv0900_write_reg(intp, AGC2REF, 0x38);
958
959 if ((intp->chip_id >= 0x20) ||
960 (blind_tun_sw == 1) ||
961 (intp->symbol_rate[demod] < 10000000)) {
962 stv0900_write_reg(intp, CFRINIT1, freq1);
963 stv0900_write_reg(intp, CFRINIT0, freq0);
964 intp->bw[demod] = stv0900_carrier_width(srate,
965 intp->rolloff) + 10000000;
966
967 if ((intp->chip_id >= 0x20) || (blind_tun_sw == 1)) {
968 if (intp->srch_algo[demod] != STV0900_WARM_START) {
969 if (intp->tuner_type[demod] == 3)
970 stv0900_set_tuner_auto(intp,
971 intp->freq[demod],
972 intp->bw[demod],
973 demod);
974 else
975 stv0900_set_bandwidth(fe,
976 intp->bw[demod]);
977 }
978 }
979
980 if ((intp->srch_algo[demod] == STV0900_BLIND_SEARCH) ||
981 (intp->symbol_rate[demod] < 10000000))
982 msleep(50);
983 else
984 msleep(5);
985
986 stv0900_get_lock_timeout(&timed, &timef, srate,
987 STV0900_WARM_START);
988
989 if (stv0900_get_demod_lock(intp, demod, timed / 2) == FALSE) {
990 stv0900_write_reg(intp, DMDISTATE, 0x1f);
991 stv0900_write_reg(intp, CFRINIT1, freq1);
992 stv0900_write_reg(intp, CFRINIT0, freq0);
993 stv0900_write_reg(intp, DMDISTATE, 0x18);
994 i = 0;
995 while ((stv0900_get_demod_lock(intp,
996 demod,
997 timed / 2) == FALSE) &&
998 (i <= 2)) {
999 stv0900_write_reg(intp, DMDISTATE, 0x1f);
1000 stv0900_write_reg(intp, CFRINIT1, freq1);
1001 stv0900_write_reg(intp, CFRINIT0, freq0);
1002 stv0900_write_reg(intp, DMDISTATE, 0x18);
1003 i++;
1004 }
1005 }
1006
1007 }
1008
1009 if (intp->chip_id >= 0x20)
1010 stv0900_write_reg(intp, CARFREQ, 0x49);
1011
1012 if ((intp->result[demod].standard == STV0900_DVBS1_STANDARD) ||
1013 (intp->result[demod].standard == STV0900_DSS_STANDARD))
1014 stv0900_set_viterbi_tracq(intp, demod);
1015
1016 }
1017
1018 static int stv0900_get_fec_lock(struct stv0900_internal *intp,
1019 enum fe_stv0900_demod_num demod, s32 time_out)
1020 {
1021 s32 timer = 0, lock = 0;
1022
1023 enum fe_stv0900_search_state dmd_state;
1024
1025 dprintk("%s\n", __func__);
1026
1027 dmd_state = stv0900_get_bits(intp, HEADER_MODE);
1028
1029 while ((timer < time_out) && (lock == 0)) {
1030 switch (dmd_state) {
1031 case STV0900_SEARCH:
1032 case STV0900_PLH_DETECTED:
1033 default:
1034 lock = 0;
1035 break;
1036 case STV0900_DVBS2_FOUND:
1037 lock = stv0900_get_bits(intp, PKTDELIN_LOCK);
1038 break;
1039 case STV0900_DVBS_FOUND:
1040 lock = stv0900_get_bits(intp, LOCKEDVIT);
1041 break;
1042 }
1043
1044 if (lock == 0) {
1045 msleep(10);
1046 timer += 10;
1047 }
1048 }
1049
1050 if (lock)
1051 dprintk("%s: DEMOD FEC LOCK OK\n", __func__);
1052 else
1053 dprintk("%s: DEMOD FEC LOCK FAIL\n", __func__);
1054
1055 return lock;
1056 }
1057
1058 static int stv0900_wait_for_lock(struct stv0900_internal *intp,
1059 enum fe_stv0900_demod_num demod,
1060 s32 dmd_timeout, s32 fec_timeout)
1061 {
1062
1063 s32 timer = 0, lock = 0;
1064
1065 dprintk("%s\n", __func__);
1066
1067 lock = stv0900_get_demod_lock(intp, demod, dmd_timeout);
1068
1069 if (lock)
1070 lock = stv0900_get_fec_lock(intp, demod, fec_timeout);
1071
1072 if (lock) {
1073 lock = 0;
1074
1075 dprintk("%s: Timer = %d, time_out = %d\n",
1076 __func__, timer, fec_timeout);
1077
1078 while ((timer < fec_timeout) && (lock == 0)) {
1079 lock = stv0900_get_bits(intp, TSFIFO_LINEOK);
1080 msleep(1);
1081 timer++;
1082 }
1083 }
1084
1085 if (lock)
1086 dprintk("%s: DEMOD LOCK OK\n", __func__);
1087 else
1088 dprintk("%s: DEMOD LOCK FAIL\n", __func__);
1089
1090 if (lock)
1091 return TRUE;
1092 else
1093 return FALSE;
1094 }
1095
1096 enum fe_stv0900_tracking_standard stv0900_get_standard(struct dvb_frontend *fe,
1097 enum fe_stv0900_demod_num demod)
1098 {
1099 struct stv0900_state *state = fe->demodulator_priv;
1100 struct stv0900_internal *intp = state->internal;
1101 enum fe_stv0900_tracking_standard fnd_standard;
1102
1103 int hdr_mode = stv0900_get_bits(intp, HEADER_MODE);
1104
1105 switch (hdr_mode) {
1106 case 2:
1107 fnd_standard = STV0900_DVBS2_STANDARD;
1108 break;
1109 case 3:
1110 if (stv0900_get_bits(intp, DSS_DVB) == 1)
1111 fnd_standard = STV0900_DSS_STANDARD;
1112 else
1113 fnd_standard = STV0900_DVBS1_STANDARD;
1114
1115 break;
1116 default:
1117 fnd_standard = STV0900_UNKNOWN_STANDARD;
1118 }
1119
1120 dprintk("%s: standard %d\n", __func__, fnd_standard);
1121
1122 return fnd_standard;
1123 }
1124
1125 static s32 stv0900_get_carr_freq(struct stv0900_internal *intp, u32 mclk,
1126 enum fe_stv0900_demod_num demod)
1127 {
1128 s32 derot,
1129 rem1,
1130 rem2,
1131 intval1,
1132 intval2;
1133
1134 derot = (stv0900_get_bits(intp, CAR_FREQ2) << 16) +
1135 (stv0900_get_bits(intp, CAR_FREQ1) << 8) +
1136 (stv0900_get_bits(intp, CAR_FREQ0));
1137
1138 derot = ge2comp(derot, 24);
1139 intval1 = mclk >> 12;
1140 intval2 = derot >> 12;
1141 rem1 = mclk % 0x1000;
1142 rem2 = derot % 0x1000;
1143 derot = (intval1 * intval2) +
1144 ((intval1 * rem2) >> 12) +
1145 ((intval2 * rem1) >> 12);
1146
1147 return derot;
1148 }
1149
1150 static u32 stv0900_get_tuner_freq(struct dvb_frontend *fe)
1151 {
1152 struct dvb_frontend_ops *frontend_ops = NULL;
1153 struct dvb_tuner_ops *tuner_ops = NULL;
1154 u32 freq = 0;
1155
1156 frontend_ops = &fe->ops;
1157 tuner_ops = &frontend_ops->tuner_ops;
1158
1159 if (tuner_ops->get_frequency) {
1160 if ((tuner_ops->get_frequency(fe, &freq)) < 0)
1161 dprintk("%s: Invalid parameter\n", __func__);
1162 else
1163 dprintk("%s: Frequency=%d\n", __func__, freq);
1164
1165 }
1166
1167 return freq;
1168 }
1169
1170 static enum
1171 fe_stv0900_signal_type stv0900_get_signal_params(struct dvb_frontend *fe)
1172 {
1173 struct stv0900_state *state = fe->demodulator_priv;
1174 struct stv0900_internal *intp = state->internal;
1175 enum fe_stv0900_demod_num demod = state->demod;
1176 enum fe_stv0900_signal_type range = STV0900_OUTOFRANGE;
1177 struct stv0900_signal_info *result = &intp->result[demod];
1178 s32 offsetFreq,
1179 srate_offset;
1180 int i = 0,
1181 d = demod;
1182
1183 u8 timing;
1184
1185 msleep(5);
1186 if (intp->srch_algo[d] == STV0900_BLIND_SEARCH) {
1187 timing = stv0900_read_reg(intp, TMGREG2);
1188 i = 0;
1189 stv0900_write_reg(intp, SFRSTEP, 0x5c);
1190
1191 while ((i <= 50) && (timing != 0) && (timing != 0xff)) {
1192 timing = stv0900_read_reg(intp, TMGREG2);
1193 msleep(5);
1194 i += 5;
1195 }
1196 }
1197
1198 result->standard = stv0900_get_standard(fe, d);
1199 if (intp->tuner_type[demod] == 3)
1200 result->frequency = stv0900_get_freq_auto(intp, d);
1201 else
1202 result->frequency = stv0900_get_tuner_freq(fe);
1203
1204 offsetFreq = stv0900_get_carr_freq(intp, intp->mclk, d) / 1000;
1205 result->frequency += offsetFreq;
1206 result->symbol_rate = stv0900_get_symbol_rate(intp, intp->mclk, d);
1207 srate_offset = stv0900_get_timing_offst(intp, result->symbol_rate, d);
1208 result->symbol_rate += srate_offset;
1209 result->fec = stv0900_get_vit_fec(intp, d);
1210 result->modcode = stv0900_get_bits(intp, DEMOD_MODCOD);
1211 result->pilot = stv0900_get_bits(intp, DEMOD_TYPE) & 0x01;
1212 result->frame_len = ((u32)stv0900_get_bits(intp, DEMOD_TYPE)) >> 1;
1213 result->rolloff = stv0900_get_bits(intp, ROLLOFF_STATUS);
1214
1215 dprintk("%s: modcode=0x%x \n", __func__, result->modcode);
1216
1217 switch (result->standard) {
1218 case STV0900_DVBS2_STANDARD:
1219 result->spectrum = stv0900_get_bits(intp, SPECINV_DEMOD);
1220 if (result->modcode <= STV0900_QPSK_910)
1221 result->modulation = STV0900_QPSK;
1222 else if (result->modcode <= STV0900_8PSK_910)
1223 result->modulation = STV0900_8PSK;
1224 else if (result->modcode <= STV0900_16APSK_910)
1225 result->modulation = STV0900_16APSK;
1226 else if (result->modcode <= STV0900_32APSK_910)
1227 result->modulation = STV0900_32APSK;
1228 else
1229 result->modulation = STV0900_UNKNOWN;
1230 break;
1231 case STV0900_DVBS1_STANDARD:
1232 case STV0900_DSS_STANDARD:
1233 result->spectrum = stv0900_get_bits(intp, IQINV);
1234 result->modulation = STV0900_QPSK;
1235 break;
1236 default:
1237 break;
1238 }
1239
1240 if ((intp->srch_algo[d] == STV0900_BLIND_SEARCH) ||
1241 (intp->symbol_rate[d] < 10000000)) {
1242 offsetFreq = result->frequency - intp->freq[d];
1243 if (intp->tuner_type[demod] == 3)
1244 intp->freq[d] = stv0900_get_freq_auto(intp, d);
1245 else
1246 intp->freq[d] = stv0900_get_tuner_freq(fe);
1247
1248 if (abs(offsetFreq) <= ((intp->srch_range[d] / 2000) + 500))
1249 range = STV0900_RANGEOK;
1250 else if (abs(offsetFreq) <=
1251 (stv0900_carrier_width(result->symbol_rate,
1252 result->rolloff) / 2000))
1253 range = STV0900_RANGEOK;
1254
1255 } else if (abs(offsetFreq) <= ((intp->srch_range[d] / 2000) + 500))
1256 range = STV0900_RANGEOK;
1257
1258 dprintk("%s: range %d\n", __func__, range);
1259
1260 return range;
1261 }
1262
1263 static enum
1264 fe_stv0900_signal_type stv0900_dvbs1_acq_workaround(struct dvb_frontend *fe)
1265 {
1266 struct stv0900_state *state = fe->demodulator_priv;
1267 struct stv0900_internal *intp = state->internal;
1268 enum fe_stv0900_demod_num demod = state->demod;
1269 enum fe_stv0900_signal_type signal_type = STV0900_NODATA;
1270
1271 s32 srate,
1272 demod_timeout,
1273 fec_timeout,
1274 freq1,
1275 freq0;
1276
1277 intp->result[demod].locked = FALSE;
1278
1279 if (stv0900_get_bits(intp, HEADER_MODE) == STV0900_DVBS_FOUND) {
1280 srate = stv0900_get_symbol_rate(intp, intp->mclk, demod);
1281 srate += stv0900_get_timing_offst(intp, srate, demod);
1282 if (intp->srch_algo[demod] == STV0900_BLIND_SEARCH)
1283 stv0900_set_symbol_rate(intp, intp->mclk, srate, demod);
1284
1285 stv0900_get_lock_timeout(&demod_timeout, &fec_timeout,
1286 srate, STV0900_WARM_START);
1287 freq1 = stv0900_read_reg(intp, CFR2);
1288 freq0 = stv0900_read_reg(intp, CFR1);
1289 stv0900_write_bits(intp, CFR_AUTOSCAN, 0);
1290 stv0900_write_bits(intp, SPECINV_CONTROL,
1291 STV0900_IQ_FORCE_SWAPPED);
1292 stv0900_write_reg(intp, DMDISTATE, 0x1c);
1293 stv0900_write_reg(intp, CFRINIT1, freq1);
1294 stv0900_write_reg(intp, CFRINIT0, freq0);
1295 stv0900_write_reg(intp, DMDISTATE, 0x18);
1296 if (stv0900_wait_for_lock(intp, demod,
1297 demod_timeout, fec_timeout) == TRUE) {
1298 intp->result[demod].locked = TRUE;
1299 signal_type = stv0900_get_signal_params(fe);
1300 stv0900_track_optimization(fe);
1301 } else {
1302 stv0900_write_bits(intp, SPECINV_CONTROL,
1303 STV0900_IQ_FORCE_NORMAL);
1304 stv0900_write_reg(intp, DMDISTATE, 0x1c);
1305 stv0900_write_reg(intp, CFRINIT1, freq1);
1306 stv0900_write_reg(intp, CFRINIT0, freq0);
1307 stv0900_write_reg(intp, DMDISTATE, 0x18);
1308 if (stv0900_wait_for_lock(intp, demod,
1309 demod_timeout, fec_timeout) == TRUE) {
1310 intp->result[demod].locked = TRUE;
1311 signal_type = stv0900_get_signal_params(fe);
1312 stv0900_track_optimization(fe);
1313 }
1314
1315 }
1316
1317 } else
1318 intp->result[demod].locked = FALSE;
1319
1320 return signal_type;
1321 }
1322
1323 static u16 stv0900_blind_check_agc2_min_level(struct stv0900_internal *intp,
1324 enum fe_stv0900_demod_num demod)
1325 {
1326 u32 minagc2level = 0xffff,
1327 agc2level,
1328 init_freq, freq_step;
1329
1330 s32 i, j, nb_steps, direction;
1331
1332 dprintk("%s\n", __func__);
1333
1334 stv0900_write_reg(intp, AGC2REF, 0x38);
1335 stv0900_write_bits(intp, SCAN_ENABLE, 0);
1336 stv0900_write_bits(intp, CFR_AUTOSCAN, 0);
1337
1338 stv0900_write_bits(intp, AUTO_GUP, 1);
1339 stv0900_write_bits(intp, AUTO_GLOW, 1);
1340
1341 stv0900_write_reg(intp, DMDT0M, 0x0);
1342
1343 stv0900_set_symbol_rate(intp, intp->mclk, 1000000, demod);
1344 nb_steps = -1 + (intp->srch_range[demod] / 1000000);
1345 nb_steps /= 2;
1346 nb_steps = (2 * nb_steps) + 1;
1347
1348 if (nb_steps < 0)
1349 nb_steps = 1;
1350
1351 direction = 1;
1352
1353 freq_step = (1000000 << 8) / (intp->mclk >> 8);
1354
1355 init_freq = 0;
1356
1357 for (i = 0; i < nb_steps; i++) {
1358 if (direction > 0)
1359 init_freq = init_freq + (freq_step * i);
1360 else
1361 init_freq = init_freq - (freq_step * i);
1362
1363 direction *= -1;
1364 stv0900_write_reg(intp, DMDISTATE, 0x5C);
1365 stv0900_write_reg(intp, CFRINIT1, (init_freq >> 8) & 0xff);
1366 stv0900_write_reg(intp, CFRINIT0, init_freq & 0xff);
1367 stv0900_write_reg(intp, DMDISTATE, 0x58);
1368 msleep(10);
1369 agc2level = 0;
1370
1371 for (j = 0; j < 10; j++)
1372 agc2level += (stv0900_read_reg(intp, AGC2I1) << 8)
1373 | stv0900_read_reg(intp, AGC2I0);
1374
1375 agc2level /= 10;
1376
1377 if (agc2level < minagc2level)
1378 minagc2level = agc2level;
1379
1380 }
1381
1382 return (u16)minagc2level;
1383 }
1384
1385 static u32 stv0900_search_srate_coarse(struct dvb_frontend *fe)
1386 {
1387 struct stv0900_state *state = fe->demodulator_priv;
1388 struct stv0900_internal *intp = state->internal;
1389 enum fe_stv0900_demod_num demod = state->demod;
1390 int timing_lck = FALSE;
1391 s32 i, timingcpt = 0,
1392 direction = 1,
1393 nb_steps,
1394 current_step = 0,
1395 tuner_freq;
1396 u32 agc2_th,
1397 coarse_srate = 0,
1398 agc2_integr = 0,
1399 currier_step = 1200;
1400
1401 if (intp->chip_id >= 0x30)
1402 agc2_th = 0x2e00;
1403 else
1404 agc2_th = 0x1f00;
1405
1406 stv0900_write_bits(intp, DEMOD_MODE, 0x1f);
1407 stv0900_write_reg(intp, TMGCFG, 0x12);
1408 stv0900_write_reg(intp, TMGTHRISE, 0xf0);
1409 stv0900_write_reg(intp, TMGTHFALL, 0xe0);
1410 stv0900_write_bits(intp, SCAN_ENABLE, 1);
1411 stv0900_write_bits(intp, CFR_AUTOSCAN, 1);
1412 stv0900_write_reg(intp, SFRUP1, 0x83);
1413 stv0900_write_reg(intp, SFRUP0, 0xc0);
1414 stv0900_write_reg(intp, SFRLOW1, 0x82);
1415 stv0900_write_reg(intp, SFRLOW0, 0xa0);
1416 stv0900_write_reg(intp, DMDT0M, 0x0);
1417 stv0900_write_reg(intp, AGC2REF, 0x50);
1418
1419 if (intp->chip_id >= 0x30) {
1420 stv0900_write_reg(intp, CARFREQ, 0x99);
1421 stv0900_write_reg(intp, SFRSTEP, 0x98);
1422 } else if (intp->chip_id >= 0x20) {
1423 stv0900_write_reg(intp, CARFREQ, 0x6a);
1424 stv0900_write_reg(intp, SFRSTEP, 0x95);
1425 } else {
1426 stv0900_write_reg(intp, CARFREQ, 0xed);
1427 stv0900_write_reg(intp, SFRSTEP, 0x73);
1428 }
1429
1430 if (intp->symbol_rate[demod] <= 2000000)
1431 currier_step = 1000;
1432 else if (intp->symbol_rate[demod] <= 5000000)
1433 currier_step = 2000;
1434 else if (intp->symbol_rate[demod] <= 12000000)
1435 currier_step = 3000;
1436 else
1437 currier_step = 5000;
1438
1439 nb_steps = -1 + ((intp->srch_range[demod] / 1000) / currier_step);
1440 nb_steps /= 2;
1441 nb_steps = (2 * nb_steps) + 1;
1442
1443 if (nb_steps < 0)
1444 nb_steps = 1;
1445 else if (nb_steps > 10) {
1446 nb_steps = 11;
1447 currier_step = (intp->srch_range[demod] / 1000) / 10;
1448 }
1449
1450 current_step = 0;
1451 direction = 1;
1452
1453 tuner_freq = intp->freq[demod];
1454
1455 while ((timing_lck == FALSE) && (current_step < nb_steps)) {
1456 stv0900_write_reg(intp, DMDISTATE, 0x5f);
1457 stv0900_write_bits(intp, DEMOD_MODE, 0);
1458
1459 msleep(50);
1460
1461 for (i = 0; i < 10; i++) {
1462 if (stv0900_get_bits(intp, TMGLOCK_QUALITY) >= 2)
1463 timingcpt++;
1464
1465 agc2_integr += (stv0900_read_reg(intp, AGC2I1) << 8) |
1466 stv0900_read_reg(intp, AGC2I0);
1467 }
1468
1469 agc2_integr /= 10;
1470 coarse_srate = stv0900_get_symbol_rate(intp, intp->mclk, demod);
1471 current_step++;
1472 direction *= -1;
1473
1474 dprintk("lock: I2C_DEMOD_MODE_FIELD =0. Search started. tuner freq=%d agc2=0x%x srate_coarse=%d tmg_cpt=%d\n",
1475 tuner_freq, agc2_integr, coarse_srate, timingcpt);
1476
1477 if ((timingcpt >= 5) &&
1478 (agc2_integr < agc2_th) &&
1479 (coarse_srate < 55000000) &&
1480 (coarse_srate > 850000))
1481 timing_lck = TRUE;
1482 else if (current_step < nb_steps) {
1483 if (direction > 0)
1484 tuner_freq += (current_step * currier_step);
1485 else
1486 tuner_freq -= (current_step * currier_step);
1487
1488 if (intp->tuner_type[demod] == 3)
1489 stv0900_set_tuner_auto(intp, tuner_freq,
1490 intp->bw[demod], demod);
1491 else
1492 stv0900_set_tuner(fe, tuner_freq,
1493 intp->bw[demod]);
1494 }
1495 }
1496
1497 if (timing_lck == FALSE)
1498 coarse_srate = 0;
1499 else
1500 coarse_srate = stv0900_get_symbol_rate(intp, intp->mclk, demod);
1501
1502 return coarse_srate;
1503 }
1504
1505 static u32 stv0900_search_srate_fine(struct dvb_frontend *fe)
1506 {
1507 struct stv0900_state *state = fe->demodulator_priv;
1508 struct stv0900_internal *intp = state->internal;
1509 enum fe_stv0900_demod_num demod = state->demod;
1510 u32 coarse_srate,
1511 coarse_freq,
1512 symb,
1513 symbmax,
1514 symbmin,
1515 symbcomp;
1516
1517 coarse_srate = stv0900_get_symbol_rate(intp, intp->mclk, demod);
1518
1519 if (coarse_srate > 3000000) {
1520 symbmax = 13 * (coarse_srate / 10);
1521 symbmax = (symbmax / 1000) * 65536;
1522 symbmax /= (intp->mclk / 1000);
1523
1524 symbmin = 10 * (coarse_srate / 13);
1525 symbmin = (symbmin / 1000)*65536;
1526 symbmin /= (intp->mclk / 1000);
1527
1528 symb = (coarse_srate / 1000) * 65536;
1529 symb /= (intp->mclk / 1000);
1530 } else {
1531 symbmax = 13 * (coarse_srate / 10);
1532 symbmax = (symbmax / 100) * 65536;
1533 symbmax /= (intp->mclk / 100);
1534
1535 symbmin = 10 * (coarse_srate / 14);
1536 symbmin = (symbmin / 100) * 65536;
1537 symbmin /= (intp->mclk / 100);
1538
1539 symb = (coarse_srate / 100) * 65536;
1540 symb /= (intp->mclk / 100);
1541 }
1542
1543 symbcomp = 13 * (coarse_srate / 10);
1544 coarse_freq = (stv0900_read_reg(intp, CFR2) << 8)
1545 | stv0900_read_reg(intp, CFR1);
1546
1547 if (symbcomp < intp->symbol_rate[demod])
1548 coarse_srate = 0;
1549 else {
1550 stv0900_write_reg(intp, DMDISTATE, 0x1f);
1551 stv0900_write_reg(intp, TMGCFG2, 0xc1);
1552 stv0900_write_reg(intp, TMGTHRISE, 0x20);
1553 stv0900_write_reg(intp, TMGTHFALL, 0x00);
1554 stv0900_write_reg(intp, TMGCFG, 0xd2);
1555 stv0900_write_bits(intp, CFR_AUTOSCAN, 0);
1556 stv0900_write_reg(intp, AGC2REF, 0x38);
1557
1558 if (intp->chip_id >= 0x30)
1559 stv0900_write_reg(intp, CARFREQ, 0x79);
1560 else if (intp->chip_id >= 0x20)
1561 stv0900_write_reg(intp, CARFREQ, 0x49);
1562 else
1563 stv0900_write_reg(intp, CARFREQ, 0xed);
1564
1565 stv0900_write_reg(intp, SFRUP1, (symbmax >> 8) & 0x7f);
1566 stv0900_write_reg(intp, SFRUP0, (symbmax & 0xff));
1567
1568 stv0900_write_reg(intp, SFRLOW1, (symbmin >> 8) & 0x7f);
1569 stv0900_write_reg(intp, SFRLOW0, (symbmin & 0xff));
1570
1571 stv0900_write_reg(intp, SFRINIT1, (symb >> 8) & 0xff);
1572 stv0900_write_reg(intp, SFRINIT0, (symb & 0xff));
1573
1574 stv0900_write_reg(intp, DMDT0M, 0x20);
1575 stv0900_write_reg(intp, CFRINIT1, (coarse_freq >> 8) & 0xff);
1576 stv0900_write_reg(intp, CFRINIT0, coarse_freq & 0xff);
1577 stv0900_write_reg(intp, DMDISTATE, 0x15);
1578 }
1579
1580 return coarse_srate;
1581 }
1582
1583 static int stv0900_blind_search_algo(struct dvb_frontend *fe)
1584 {
1585 struct stv0900_state *state = fe->demodulator_priv;
1586 struct stv0900_internal *intp = state->internal;
1587 enum fe_stv0900_demod_num demod = state->demod;
1588 u8 k_ref_tmg,
1589 k_ref_tmg_max,
1590 k_ref_tmg_min;
1591 u32 coarse_srate,
1592 agc2_th;
1593 int lock = FALSE,
1594 coarse_fail = FALSE;
1595 s32 demod_timeout = 500,
1596 fec_timeout = 50,
1597 fail_cpt,
1598 i,
1599 agc2_overflow;
1600 u16 agc2_int;
1601 u8 dstatus2;
1602
1603 dprintk("%s\n", __func__);
1604
1605 if (intp->chip_id < 0x20) {
1606 k_ref_tmg_max = 233;
1607 k_ref_tmg_min = 143;
1608 } else {
1609 k_ref_tmg_max = 110;
1610 k_ref_tmg_min = 10;
1611 }
1612
1613 if (intp->chip_id <= 0x20)
1614 agc2_th = STV0900_BLIND_SEARCH_AGC2_TH;
1615 else
1616 agc2_th = STV0900_BLIND_SEARCH_AGC2_TH_CUT30;
1617
1618 agc2_int = stv0900_blind_check_agc2_min_level(intp, demod);
1619
1620 dprintk("%s agc2_int=%d agc2_th=%d \n", __func__, agc2_int, agc2_th);
1621 if (agc2_int > agc2_th)
1622 return FALSE;
1623
1624 if (intp->chip_id == 0x10)
1625 stv0900_write_reg(intp, CORRELEXP, 0xaa);
1626
1627 if (intp->chip_id < 0x20)
1628 stv0900_write_reg(intp, CARHDR, 0x55);
1629 else
1630 stv0900_write_reg(intp, CARHDR, 0x20);
1631
1632 if (intp->chip_id <= 0x20)
1633 stv0900_write_reg(intp, CARCFG, 0xc4);
1634 else
1635 stv0900_write_reg(intp, CARCFG, 0x6);
1636
1637 stv0900_write_reg(intp, RTCS2, 0x44);
1638
1639 if (intp->chip_id >= 0x20) {
1640 stv0900_write_reg(intp, EQUALCFG, 0x41);
1641 stv0900_write_reg(intp, FFECFG, 0x41);
1642 stv0900_write_reg(intp, VITSCALE, 0x82);
1643 stv0900_write_reg(intp, VAVSRVIT, 0x0);
1644 }
1645
1646 k_ref_tmg = k_ref_tmg_max;
1647
1648 do {
1649 stv0900_write_reg(intp, KREFTMG, k_ref_tmg);
1650 if (stv0900_search_srate_coarse(fe) != 0) {
1651 coarse_srate = stv0900_search_srate_fine(fe);
1652
1653 if (coarse_srate != 0) {
1654 stv0900_get_lock_timeout(&demod_timeout,
1655 &fec_timeout,
1656 coarse_srate,
1657 STV0900_BLIND_SEARCH);
1658 lock = stv0900_get_demod_lock(intp,
1659 demod,
1660 demod_timeout);
1661 } else
1662 lock = FALSE;
1663 } else {
1664 fail_cpt = 0;
1665 agc2_overflow = 0;
1666
1667 for (i = 0; i < 10; i++) {
1668 agc2_int = (stv0900_read_reg(intp, AGC2I1) << 8)
1669 | stv0900_read_reg(intp, AGC2I0);
1670
1671 if (agc2_int >= 0xff00)
1672 agc2_overflow++;
1673
1674 dstatus2 = stv0900_read_reg(intp, DSTATUS2);
1675
1676 if (((dstatus2 & 0x1) == 0x1) &&
1677 ((dstatus2 >> 7) == 1))
1678 fail_cpt++;
1679 }
1680
1681 if ((fail_cpt > 7) || (agc2_overflow > 7))
1682 coarse_fail = TRUE;
1683
1684 lock = FALSE;
1685 }
1686 k_ref_tmg -= 30;
1687 } while ((k_ref_tmg >= k_ref_tmg_min) &&
1688 (lock == FALSE) &&
1689 (coarse_fail == FALSE));
1690
1691 return lock;
1692 }
1693
1694 static void stv0900_set_viterbi_acq(struct stv0900_internal *intp,
1695 enum fe_stv0900_demod_num demod)
1696 {
1697 s32 vth_reg = VTH12;
1698
1699 dprintk("%s\n", __func__);
1700
1701 stv0900_write_reg(intp, vth_reg++, 0x96);
1702 stv0900_write_reg(intp, vth_reg++, 0x64);
1703 stv0900_write_reg(intp, vth_reg++, 0x36);
1704 stv0900_write_reg(intp, vth_reg++, 0x23);
1705 stv0900_write_reg(intp, vth_reg++, 0x1e);
1706 stv0900_write_reg(intp, vth_reg++, 0x19);
1707 }
1708
1709 static void stv0900_set_search_standard(struct stv0900_internal *intp,
1710 enum fe_stv0900_demod_num demod)
1711 {
1712
1713 dprintk("%s\n", __func__);
1714
1715 switch (intp->srch_standard[demod]) {
1716 case STV0900_SEARCH_DVBS1:
1717 dprintk("Search Standard = DVBS1\n");
1718 break;
1719 case STV0900_SEARCH_DSS:
1720 dprintk("Search Standard = DSS\n");
1721 break;
1722 case STV0900_SEARCH_DVBS2:
1723 dprintk("Search Standard = DVBS2\n");
1724 break;
1725 case STV0900_AUTO_SEARCH:
1726 default:
1727 dprintk("Search Standard = AUTO\n");
1728 break;
1729 }
1730
1731 switch (intp->srch_standard[demod]) {
1732 case STV0900_SEARCH_DVBS1:
1733 case STV0900_SEARCH_DSS:
1734 stv0900_write_bits(intp, DVBS1_ENABLE, 1);
1735 stv0900_write_bits(intp, DVBS2_ENABLE, 0);
1736 stv0900_write_bits(intp, STOP_CLKVIT, 0);
1737 stv0900_set_dvbs1_track_car_loop(intp,
1738 demod,
1739 intp->symbol_rate[demod]);
1740 stv0900_write_reg(intp, CAR2CFG, 0x22);
1741
1742 stv0900_set_viterbi_acq(intp, demod);
1743 stv0900_set_viterbi_standard(intp,
1744 intp->srch_standard[demod],
1745 intp->fec[demod], demod);
1746
1747 break;
1748 case STV0900_SEARCH_DVBS2:
1749 stv0900_write_bits(intp, DVBS1_ENABLE, 0);
1750 stv0900_write_bits(intp, DVBS2_ENABLE, 1);
1751 stv0900_write_bits(intp, STOP_CLKVIT, 1);
1752 stv0900_write_reg(intp, ACLC, 0x1a);
1753 stv0900_write_reg(intp, BCLC, 0x09);
1754 if (intp->chip_id <= 0x20) /*cut 1.x and 2.0*/
1755 stv0900_write_reg(intp, CAR2CFG, 0x26);
1756 else
1757 stv0900_write_reg(intp, CAR2CFG, 0x66);
1758
1759 if (intp->demod_mode != STV0900_SINGLE) {
1760 if (intp->chip_id <= 0x11)
1761 stv0900_stop_all_s2_modcod(intp, demod);
1762 else
1763 stv0900_activate_s2_modcod(intp, demod);
1764
1765 } else
1766 stv0900_activate_s2_modcod_single(intp, demod);
1767
1768 stv0900_set_viterbi_tracq(intp, demod);
1769
1770 break;
1771 case STV0900_AUTO_SEARCH:
1772 default:
1773 stv0900_write_bits(intp, DVBS1_ENABLE, 1);
1774 stv0900_write_bits(intp, DVBS2_ENABLE, 1);
1775 stv0900_write_bits(intp, STOP_CLKVIT, 0);
1776 stv0900_write_reg(intp, ACLC, 0x1a);
1777 stv0900_write_reg(intp, BCLC, 0x09);
1778 stv0900_set_dvbs1_track_car_loop(intp,
1779 demod,
1780 intp->symbol_rate[demod]);
1781 if (intp->chip_id <= 0x20) /*cut 1.x and 2.0*/
1782 stv0900_write_reg(intp, CAR2CFG, 0x26);
1783 else
1784 stv0900_write_reg(intp, CAR2CFG, 0x66);
1785
1786 if (intp->demod_mode != STV0900_SINGLE) {
1787 if (intp->chip_id <= 0x11)
1788 stv0900_stop_all_s2_modcod(intp, demod);
1789 else
1790 stv0900_activate_s2_modcod(intp, demod);
1791
1792 } else
1793 stv0900_activate_s2_modcod_single(intp, demod);
1794
1795 stv0900_set_viterbi_tracq(intp, demod);
1796 stv0900_set_viterbi_standard(intp,
1797 intp->srch_standard[demod],
1798 intp->fec[demod], demod);
1799
1800 break;
1801 }
1802 }
1803
1804 enum fe_stv0900_signal_type stv0900_algo(struct dvb_frontend *fe)
1805 {
1806 struct stv0900_state *state = fe->demodulator_priv;
1807 struct stv0900_internal *intp = state->internal;
1808 enum fe_stv0900_demod_num demod = state->demod;
1809
1810 s32 demod_timeout = 500, fec_timeout = 50;
1811 s32 aq_power, agc1_power, i;
1812
1813 int lock = FALSE, low_sr = FALSE;
1814
1815 enum fe_stv0900_signal_type signal_type = STV0900_NOCARRIER;
1816 enum fe_stv0900_search_algo algo;
1817 int no_signal = FALSE;
1818
1819 dprintk("%s\n", __func__);
1820
1821 algo = intp->srch_algo[demod];
1822 stv0900_write_bits(intp, RST_HWARE, 1);
1823 stv0900_write_reg(intp, DMDISTATE, 0x5c);
1824 if (intp->chip_id >= 0x20) {
1825 if (intp->symbol_rate[demod] > 5000000)
1826 stv0900_write_reg(intp, CORRELABS, 0x9e);
1827 else
1828 stv0900_write_reg(intp, CORRELABS, 0x82);
1829 } else
1830 stv0900_write_reg(intp, CORRELABS, 0x88);
1831
1832 stv0900_get_lock_timeout(&demod_timeout, &fec_timeout,
1833 intp->symbol_rate[demod],
1834 intp->srch_algo[demod]);
1835
1836 if (intp->srch_algo[demod] == STV0900_BLIND_SEARCH) {
1837 intp->bw[demod] = 2 * 36000000;
1838
1839 stv0900_write_reg(intp, TMGCFG2, 0xc0);
1840 stv0900_write_reg(intp, CORRELMANT, 0x70);
1841
1842 stv0900_set_symbol_rate(intp, intp->mclk, 1000000, demod);
1843 } else {
1844 stv0900_write_reg(intp, DMDT0M, 0x20);
1845 stv0900_write_reg(intp, TMGCFG, 0xd2);
1846
1847 if (intp->symbol_rate[demod] < 2000000)
1848 stv0900_write_reg(intp, CORRELMANT, 0x63);
1849 else
1850 stv0900_write_reg(intp, CORRELMANT, 0x70);
1851
1852 stv0900_write_reg(intp, AGC2REF, 0x38);
1853
1854 intp->bw[demod] =
1855 stv0900_carrier_width(intp->symbol_rate[demod],
1856 intp->rolloff);
1857 if (intp->chip_id >= 0x20) {
1858 stv0900_write_reg(intp, KREFTMG, 0x5a);
1859
1860 if (intp->srch_algo[demod] == STV0900_COLD_START) {
1861 intp->bw[demod] += 10000000;
1862 intp->bw[demod] *= 15;
1863 intp->bw[demod] /= 10;
1864 } else if (intp->srch_algo[demod] == STV0900_WARM_START)
1865 intp->bw[demod] += 10000000;
1866
1867 } else {
1868 stv0900_write_reg(intp, KREFTMG, 0xc1);
1869 intp->bw[demod] += 10000000;
1870 intp->bw[demod] *= 15;
1871 intp->bw[demod] /= 10;
1872 }
1873
1874 stv0900_write_reg(intp, TMGCFG2, 0xc1);
1875
1876 stv0900_set_symbol_rate(intp, intp->mclk,
1877 intp->symbol_rate[demod], demod);
1878 stv0900_set_max_symbol_rate(intp, intp->mclk,
1879 intp->symbol_rate[demod], demod);
1880 stv0900_set_min_symbol_rate(intp, intp->mclk,
1881 intp->symbol_rate[demod], demod);
1882 if (intp->symbol_rate[demod] >= 10000000)
1883 low_sr = FALSE;
1884 else
1885 low_sr = TRUE;
1886
1887 }
1888
1889 if (intp->tuner_type[demod] == 3)
1890 stv0900_set_tuner_auto(intp, intp->freq[demod],
1891 intp->bw[demod], demod);
1892 else
1893 stv0900_set_tuner(fe, intp->freq[demod], intp->bw[demod]);
1894
1895 agc1_power = MAKEWORD(stv0900_get_bits(intp, AGCIQ_VALUE1),
1896 stv0900_get_bits(intp, AGCIQ_VALUE0));
1897
1898 aq_power = 0;
1899
1900 if (agc1_power == 0) {
1901 for (i = 0; i < 5; i++)
1902 aq_power += (stv0900_get_bits(intp, POWER_I) +
1903 stv0900_get_bits(intp, POWER_Q)) / 2;
1904
1905 aq_power /= 5;
1906 }
1907
1908 if ((agc1_power == 0) && (aq_power < IQPOWER_THRESHOLD)) {
1909 intp->result[demod].locked = FALSE;
1910 signal_type = STV0900_NOAGC1;
1911 dprintk("%s: NO AGC1, POWERI, POWERQ\n", __func__);
1912 } else {
1913 stv0900_write_bits(intp, SPECINV_CONTROL,
1914 intp->srch_iq_inv[demod]);
1915 if (intp->chip_id <= 0x20) /*cut 2.0*/
1916 stv0900_write_bits(intp, MANUALSX_ROLLOFF, 1);
1917 else /*cut 3.0*/
1918 stv0900_write_bits(intp, MANUALS2_ROLLOFF, 1);
1919
1920 stv0900_set_search_standard(intp, demod);
1921
1922 if (intp->srch_algo[demod] != STV0900_BLIND_SEARCH)
1923 stv0900_start_search(intp, demod);
1924 }
1925
1926 if (signal_type == STV0900_NOAGC1)
1927 return signal_type;
1928
1929 if (intp->chip_id == 0x12) {
1930 stv0900_write_bits(intp, RST_HWARE, 0);
1931 msleep(3);
1932 stv0900_write_bits(intp, RST_HWARE, 1);
1933 stv0900_write_bits(intp, RST_HWARE, 0);
1934 }
1935
1936 if (algo == STV0900_BLIND_SEARCH)
1937 lock = stv0900_blind_search_algo(fe);
1938 else if (algo == STV0900_COLD_START)
1939 lock = stv0900_get_demod_cold_lock(fe, demod_timeout);
1940 else if (algo == STV0900_WARM_START)
1941 lock = stv0900_get_demod_lock(intp, demod, demod_timeout);
1942
1943 if ((lock == FALSE) && (algo == STV0900_COLD_START)) {
1944 if (low_sr == FALSE) {
1945 if (stv0900_check_timing_lock(intp, demod) == TRUE)
1946 lock = stv0900_sw_algo(intp, demod);
1947 }
1948 }
1949
1950 if (lock == TRUE)
1951 signal_type = stv0900_get_signal_params(fe);
1952
1953 if ((lock == TRUE) && (signal_type == STV0900_RANGEOK)) {
1954 stv0900_track_optimization(fe);
1955 if (intp->chip_id <= 0x11) {
1956 if ((stv0900_get_standard(fe, 0) ==
1957 STV0900_DVBS1_STANDARD) &&
1958 (stv0900_get_standard(fe, 1) ==
1959 STV0900_DVBS1_STANDARD)) {
1960 msleep(20);
1961 stv0900_write_bits(intp, RST_HWARE, 0);
1962 } else {
1963 stv0900_write_bits(intp, RST_HWARE, 0);
1964 msleep(3);
1965 stv0900_write_bits(intp, RST_HWARE, 1);
1966 stv0900_write_bits(intp, RST_HWARE, 0);
1967 }
1968
1969 } else if (intp->chip_id >= 0x20) {
1970 stv0900_write_bits(intp, RST_HWARE, 0);
1971 msleep(3);
1972 stv0900_write_bits(intp, RST_HWARE, 1);
1973 stv0900_write_bits(intp, RST_HWARE, 0);
1974 }
1975
1976 if (stv0900_wait_for_lock(intp, demod,
1977 fec_timeout, fec_timeout) == TRUE) {
1978 lock = TRUE;
1979 intp->result[demod].locked = TRUE;
1980 if (intp->result[demod].standard ==
1981 STV0900_DVBS2_STANDARD) {
1982 stv0900_set_dvbs2_rolloff(intp, demod);
1983 stv0900_write_bits(intp, RESET_UPKO_COUNT, 1);
1984 stv0900_write_bits(intp, RESET_UPKO_COUNT, 0);
1985 stv0900_write_reg(intp, ERRCTRL1, 0x67);
1986 } else {
1987 stv0900_write_reg(intp, ERRCTRL1, 0x75);
1988 }
1989
1990 stv0900_write_reg(intp, FBERCPT4, 0);
1991 stv0900_write_reg(intp, ERRCTRL2, 0xc1);
1992 } else {
1993 lock = FALSE;
1994 signal_type = STV0900_NODATA;
1995 no_signal = stv0900_check_signal_presence(intp, demod);
1996
1997 intp->result[demod].locked = FALSE;
1998 }
1999 }
2000
2001 if ((signal_type != STV0900_NODATA) || (no_signal != FALSE))
2002 return signal_type;
2003
2004 if (intp->chip_id > 0x11) {
2005 intp->result[demod].locked = FALSE;
2006 return signal_type;
2007 }
2008
2009 if ((stv0900_get_bits(intp, HEADER_MODE) == STV0900_DVBS_FOUND) &&
2010 (intp->srch_iq_inv[demod] <= STV0900_IQ_AUTO_NORMAL_FIRST))
2011 signal_type = stv0900_dvbs1_acq_workaround(fe);
2012
2013 return signal_type;
2014 }
2015
Linux with added FPC-III support