projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph...
[deliverable/linux.git] / drivers / media / dvb / frontends / mb86a16.c
1 /*
2 Fujitsu MB86A16 DVB-S/DSS DC Receiver driver
3
4 Copyright (C) Manu Abraham (abraham.manu@gmail.com)
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <linux/init.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/slab.h>
26
27 #include "dvb_frontend.h"
28 #include "mb86a16.h"
29 #include "mb86a16_priv.h"
30
31 unsigned int verbose = 5;
32 module_param(verbose, int, 0644);
33
34 #define ABS(x) ((x) < 0 ? (-x) : (x))
35
36 struct mb86a16_state {
37 struct i2c_adapter *i2c_adap;
38 const struct mb86a16_config *config;
39 struct dvb_frontend frontend;
40
41 /* tuning parameters */
42 int frequency;
43 int srate;
44
45 /* Internal stuff */
46 int master_clk;
47 int deci;
48 int csel;
49 int rsel;
50 };
51
52 #define MB86A16_ERROR 0
53 #define MB86A16_NOTICE 1
54 #define MB86A16_INFO 2
55 #define MB86A16_DEBUG 3
56
57 #define dprintk(x, y, z, format, arg...) do { \
58 if (z) { \
59 if ((x > MB86A16_ERROR) && (x > y)) \
60 printk(KERN_ERR "%s: " format "\n", __func__, ##arg); \
61 else if ((x > MB86A16_NOTICE) && (x > y)) \
62 printk(KERN_NOTICE "%s: " format "\n", __func__, ##arg); \
63 else if ((x > MB86A16_INFO) && (x > y)) \
64 printk(KERN_INFO "%s: " format "\n", __func__, ##arg); \
65 else if ((x > MB86A16_DEBUG) && (x > y)) \
66 printk(KERN_DEBUG "%s: " format "\n", __func__, ##arg); \
67 } else { \
68 if (x > y) \
69 printk(format, ##arg); \
70 } \
71 } while (0)
72
73 #define TRACE_IN dprintk(verbose, MB86A16_DEBUG, 1, "-->()")
74 #define TRACE_OUT dprintk(verbose, MB86A16_DEBUG, 1, "()-->")
75
76 static int mb86a16_write(struct mb86a16_state *state, u8 reg, u8 val)
77 {
78 int ret;
79 u8 buf[] = { reg, val };
80
81 struct i2c_msg msg = {
82 .addr = state->config->demod_address,
83 .flags = 0,
84 .buf = buf,
85 .len = 2
86 };
87
88 dprintk(verbose, MB86A16_DEBUG, 1,
89 "writing to [0x%02x],Reg[0x%02x],Data[0x%02x]",
90 state->config->demod_address, buf[0], buf[1]);
91
92 ret = i2c_transfer(state->i2c_adap, &msg, 1);
93
94 return (ret != 1) ? -EREMOTEIO : 0;
95 }
96
97 static int mb86a16_read(struct mb86a16_state *state, u8 reg, u8 *val)
98 {
99 int ret;
100 u8 b0[] = { reg };
101 u8 b1[] = { 0 };
102
103 struct i2c_msg msg[] = {
104 {
105 .addr = state->config->demod_address,
106 .flags = 0,
107 .buf = b0,
108 .len = 1
109 }, {
110 .addr = state->config->demod_address,
111 .flags = I2C_M_RD,
112 .buf = b1,
113 .len = 1
114 }
115 };
116 ret = i2c_transfer(state->i2c_adap, msg, 2);
117 if (ret != 2) {
118 dprintk(verbose, MB86A16_ERROR, 1, "read error(reg=0x%02x, ret=0x%i)",
119 reg, ret);
120
121 return -EREMOTEIO;
122 }
123 *val = b1[0];
124
125 return ret;
126 }
127
128 static int CNTM_set(struct mb86a16_state *state,
129 unsigned char timint1,
130 unsigned char timint2,
131 unsigned char cnext)
132 {
133 unsigned char val;
134
135 val = (timint1 << 4) | (timint2 << 2) | cnext;
136 if (mb86a16_write(state, MB86A16_CNTMR, val) < 0)
137 goto err;
138
139 return 0;
140
141 err:
142 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
143 return -EREMOTEIO;
144 }
145
146 static int smrt_set(struct mb86a16_state *state, int rate)
147 {
148 int tmp ;
149 int m ;
150 unsigned char STOFS0, STOFS1;
151
152 m = 1 << state->deci;
153 tmp = (8192 * state->master_clk - 2 * m * rate * 8192 + state->master_clk / 2) / state->master_clk;
154
155 STOFS0 = tmp & 0x0ff;
156 STOFS1 = (tmp & 0xf00) >> 8;
157
158 if (mb86a16_write(state, MB86A16_SRATE1, (state->deci << 2) |
159 (state->csel << 1) |
160 state->rsel) < 0)
161 goto err;
162 if (mb86a16_write(state, MB86A16_SRATE2, STOFS0) < 0)
163 goto err;
164 if (mb86a16_write(state, MB86A16_SRATE3, STOFS1) < 0)
165 goto err;
166
167 return 0;
168 err:
169 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
170 return -1;
171 }
172
173 static int srst(struct mb86a16_state *state)
174 {
175 if (mb86a16_write(state, MB86A16_RESET, 0x04) < 0)
176 goto err;
177
178 return 0;
179 err:
180 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
181 return -EREMOTEIO;
182
183 }
184
185 static int afcex_data_set(struct mb86a16_state *state,
186 unsigned char AFCEX_L,
187 unsigned char AFCEX_H)
188 {
189 if (mb86a16_write(state, MB86A16_AFCEXL, AFCEX_L) < 0)
190 goto err;
191 if (mb86a16_write(state, MB86A16_AFCEXH, AFCEX_H) < 0)
192 goto err;
193
194 return 0;
195 err:
196 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
197
198 return -1;
199 }
200
201 static int afcofs_data_set(struct mb86a16_state *state,
202 unsigned char AFCEX_L,
203 unsigned char AFCEX_H)
204 {
205 if (mb86a16_write(state, 0x58, AFCEX_L) < 0)
206 goto err;
207 if (mb86a16_write(state, 0x59, AFCEX_H) < 0)
208 goto err;
209
210 return 0;
211 err:
212 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
213 return -EREMOTEIO;
214 }
215
216 static int stlp_set(struct mb86a16_state *state,
217 unsigned char STRAS,
218 unsigned char STRBS)
219 {
220 if (mb86a16_write(state, MB86A16_STRFILTCOEF1, (STRBS << 3) | (STRAS)) < 0)
221 goto err;
222
223 return 0;
224 err:
225 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
226 return -EREMOTEIO;
227 }
228
229 static int Vi_set(struct mb86a16_state *state, unsigned char ETH, unsigned char VIA)
230 {
231 if (mb86a16_write(state, MB86A16_VISET2, 0x04) < 0)
232 goto err;
233 if (mb86a16_write(state, MB86A16_VISET3, 0xf5) < 0)
234 goto err;
235
236 return 0;
237 err:
238 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
239 return -EREMOTEIO;
240 }
241
242 static int initial_set(struct mb86a16_state *state)
243 {
244 if (stlp_set(state, 5, 7))
245 goto err;
246
247 udelay(100);
248 if (afcex_data_set(state, 0, 0))
249 goto err;
250
251 udelay(100);
252 if (afcofs_data_set(state, 0, 0))
253 goto err;
254
255 udelay(100);
256 if (mb86a16_write(state, MB86A16_CRLFILTCOEF1, 0x16) < 0)
257 goto err;
258 if (mb86a16_write(state, 0x2f, 0x21) < 0)
259 goto err;
260 if (mb86a16_write(state, MB86A16_VIMAG, 0x38) < 0)
261 goto err;
262 if (mb86a16_write(state, MB86A16_FAGCS1, 0x00) < 0)
263 goto err;
264 if (mb86a16_write(state, MB86A16_FAGCS2, 0x1c) < 0)
265 goto err;
266 if (mb86a16_write(state, MB86A16_FAGCS3, 0x20) < 0)
267 goto err;
268 if (mb86a16_write(state, MB86A16_FAGCS4, 0x1e) < 0)
269 goto err;
270 if (mb86a16_write(state, MB86A16_FAGCS5, 0x23) < 0)
271 goto err;
272 if (mb86a16_write(state, 0x54, 0xff) < 0)
273 goto err;
274 if (mb86a16_write(state, MB86A16_TSOUT, 0x00) < 0)
275 goto err;
276
277 return 0;
278
279 err:
280 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
281 return -EREMOTEIO;
282 }
283
284 static int S01T_set(struct mb86a16_state *state,
285 unsigned char s1t,
286 unsigned s0t)
287 {
288 if (mb86a16_write(state, 0x33, (s1t << 3) | s0t) < 0)
289 goto err;
290
291 return 0;
292 err:
293 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
294 return -EREMOTEIO;
295 }
296
297
298 static int EN_set(struct mb86a16_state *state,
299 int cren,
300 int afcen)
301 {
302 unsigned char val;
303
304 val = 0x7a | (cren << 7) | (afcen << 2);
305 if (mb86a16_write(state, 0x49, val) < 0)
306 goto err;
307
308 return 0;
309 err:
310 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
311 return -EREMOTEIO;
312 }
313
314 static int AFCEXEN_set(struct mb86a16_state *state,
315 int afcexen,
316 int smrt)
317 {
318 unsigned char AFCA ;
319
320 if (smrt > 18875)
321 AFCA = 4;
322 else if (smrt > 9375)
323 AFCA = 3;
324 else if (smrt > 2250)
325 AFCA = 2;
326 else
327 AFCA = 1;
328
329 if (mb86a16_write(state, 0x2a, 0x02 | (afcexen << 5) | (AFCA << 2)) < 0)
330 goto err;
331
332 return 0;
333
334 err:
335 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
336 return -EREMOTEIO;
337 }
338
339 static int DAGC_data_set(struct mb86a16_state *state,
340 unsigned char DAGCA,
341 unsigned char DAGCW)
342 {
343 if (mb86a16_write(state, 0x2d, (DAGCA << 3) | DAGCW) < 0)
344 goto err;
345
346 return 0;
347
348 err:
349 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
350 return -EREMOTEIO;
351 }
352
353 static void smrt_info_get(struct mb86a16_state *state, int rate)
354 {
355 if (rate >= 37501) {
356 state->deci = 0; state->csel = 0; state->rsel = 0;
357 } else if (rate >= 30001) {
358 state->deci = 0; state->csel = 0; state->rsel = 1;
359 } else if (rate >= 26251) {
360 state->deci = 0; state->csel = 1; state->rsel = 0;
361 } else if (rate >= 22501) {
362 state->deci = 0; state->csel = 1; state->rsel = 1;
363 } else if (rate >= 18751) {
364 state->deci = 1; state->csel = 0; state->rsel = 0;
365 } else if (rate >= 15001) {
366 state->deci = 1; state->csel = 0; state->rsel = 1;
367 } else if (rate >= 13126) {
368 state->deci = 1; state->csel = 1; state->rsel = 0;
369 } else if (rate >= 11251) {
370 state->deci = 1; state->csel = 1; state->rsel = 1;
371 } else if (rate >= 9376) {
372 state->deci = 2; state->csel = 0; state->rsel = 0;
373 } else if (rate >= 7501) {
374 state->deci = 2; state->csel = 0; state->rsel = 1;
375 } else if (rate >= 6563) {
376 state->deci = 2; state->csel = 1; state->rsel = 0;
377 } else if (rate >= 5626) {
378 state->deci = 2; state->csel = 1; state->rsel = 1;
379 } else if (rate >= 4688) {
380 state->deci = 3; state->csel = 0; state->rsel = 0;
381 } else if (rate >= 3751) {
382 state->deci = 3; state->csel = 0; state->rsel = 1;
383 } else if (rate >= 3282) {
384 state->deci = 3; state->csel = 1; state->rsel = 0;
385 } else if (rate >= 2814) {
386 state->deci = 3; state->csel = 1; state->rsel = 1;
387 } else if (rate >= 2344) {
388 state->deci = 4; state->csel = 0; state->rsel = 0;
389 } else if (rate >= 1876) {
390 state->deci = 4; state->csel = 0; state->rsel = 1;
391 } else if (rate >= 1641) {
392 state->deci = 4; state->csel = 1; state->rsel = 0;
393 } else if (rate >= 1407) {
394 state->deci = 4; state->csel = 1; state->rsel = 1;
395 } else if (rate >= 1172) {
396 state->deci = 5; state->csel = 0; state->rsel = 0;
397 } else if (rate >= 939) {
398 state->deci = 5; state->csel = 0; state->rsel = 1;
399 } else if (rate >= 821) {
400 state->deci = 5; state->csel = 1; state->rsel = 0;
401 } else {
402 state->deci = 5; state->csel = 1; state->rsel = 1;
403 }
404
405 if (state->csel == 0)
406 state->master_clk = 92000;
407 else
408 state->master_clk = 61333;
409
410 }
411
412 static int signal_det(struct mb86a16_state *state,
413 int smrt,
414 unsigned char *SIG)
415 {
416
417 int ret ;
418 int smrtd ;
419 int wait_sym ;
420
421 u32 wait_t;
422 unsigned char S[3] ;
423 int i ;
424
425 if (*SIG > 45) {
426 if (CNTM_set(state, 2, 1, 2) < 0) {
427 dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
428 return -1;
429 }
430 wait_sym = 40000;
431 } else {
432 if (CNTM_set(state, 3, 1, 2) < 0) {
433 dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
434 return -1;
435 }
436 wait_sym = 80000;
437 }
438 for (i = 0; i < 3; i++) {
439 if (i == 0)
440 smrtd = smrt * 98 / 100;
441 else if (i == 1)
442 smrtd = smrt;
443 else
444 smrtd = smrt * 102 / 100;
445 smrt_info_get(state, smrtd);
446 smrt_set(state, smrtd);
447 srst(state);
448 wait_t = (wait_sym + 99 * smrtd / 100) / smrtd;
449 if (wait_t == 0)
450 wait_t = 1;
451 msleep_interruptible(10);
452 if (mb86a16_read(state, 0x37, &(S[i])) != 2) {
453 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
454 return -EREMOTEIO;
455 }
456 }
457 if ((S[1] > S[0] * 112 / 100) &&
458 (S[1] > S[2] * 112 / 100)) {
459
460 ret = 1;
461 } else {
462 ret = 0;
463 }
464 *SIG = S[1];
465
466 if (CNTM_set(state, 0, 1, 2) < 0) {
467 dprintk(verbose, MB86A16_ERROR, 1, "CNTM set Error");
468 return -1;
469 }
470
471 return ret;
472 }
473
474 static int rf_val_set(struct mb86a16_state *state,
475 int f,
476 int smrt,
477 unsigned char R)
478 {
479 unsigned char C, F, B;
480 int M;
481 unsigned char rf_val[5];
482 int ack = -1;
483
484 if (smrt > 37750)
485 C = 1;
486 else if (smrt > 18875)
487 C = 2;
488 else if (smrt > 5500)
489 C = 3;
490 else
491 C = 4;
492
493 if (smrt > 30500)
494 F = 3;
495 else if (smrt > 9375)
496 F = 1;
497 else if (smrt > 4625)
498 F = 0;
499 else
500 F = 2;
501
502 if (f < 1060)
503 B = 0;
504 else if (f < 1175)
505 B = 1;
506 else if (f < 1305)
507 B = 2;
508 else if (f < 1435)
509 B = 3;
510 else if (f < 1570)
511 B = 4;
512 else if (f < 1715)
513 B = 5;
514 else if (f < 1845)
515 B = 6;
516 else if (f < 1980)
517 B = 7;
518 else if (f < 2080)
519 B = 8;
520 else
521 B = 9;
522
523 M = f * (1 << R) / 2;
524
525 rf_val[0] = 0x01 | (C << 3) | (F << 1);
526 rf_val[1] = (R << 5) | ((M & 0x1f000) >> 12);
527 rf_val[2] = (M & 0x00ff0) >> 4;
528 rf_val[3] = ((M & 0x0000f) << 4) | B;
529
530 /* Frequency Set */
531 if (mb86a16_write(state, 0x21, rf_val[0]) < 0)
532 ack = 0;
533 if (mb86a16_write(state, 0x22, rf_val[1]) < 0)
534 ack = 0;
535 if (mb86a16_write(state, 0x23, rf_val[2]) < 0)
536 ack = 0;
537 if (mb86a16_write(state, 0x24, rf_val[3]) < 0)
538 ack = 0;
539 if (mb86a16_write(state, 0x25, 0x01) < 0)
540 ack = 0;
541 if (ack == 0) {
542 dprintk(verbose, MB86A16_ERROR, 1, "RF Setup - I2C transfer error");
543 return -EREMOTEIO;
544 }
545
546 return 0;
547 }
548
549 static int afcerr_chk(struct mb86a16_state *state)
550 {
551 unsigned char AFCM_L, AFCM_H ;
552 int AFCM ;
553 int afcm, afcerr ;
554
555 if (mb86a16_read(state, 0x0e, &AFCM_L) != 2)
556 goto err;
557 if (mb86a16_read(state, 0x0f, &AFCM_H) != 2)
558 goto err;
559
560 AFCM = (AFCM_H << 8) + AFCM_L;
561
562 if (AFCM > 2048)
563 afcm = AFCM - 4096;
564 else
565 afcm = AFCM;
566 afcerr = afcm * state->master_clk / 8192;
567
568 return afcerr;
569
570 err:
571 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
572 return -EREMOTEIO;
573 }
574
575 static int dagcm_val_get(struct mb86a16_state *state)
576 {
577 int DAGCM;
578 unsigned char DAGCM_H, DAGCM_L;
579
580 if (mb86a16_read(state, 0x45, &DAGCM_L) != 2)
581 goto err;
582 if (mb86a16_read(state, 0x46, &DAGCM_H) != 2)
583 goto err;
584
585 DAGCM = (DAGCM_H << 8) + DAGCM_L;
586
587 return DAGCM;
588
589 err:
590 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
591 return -EREMOTEIO;
592 }
593
594 static int mb86a16_read_status(struct dvb_frontend *fe, fe_status_t *status)
595 {
596 u8 stat, stat2;
597 struct mb86a16_state *state = fe->demodulator_priv;
598
599 *status = 0;
600
601 if (mb86a16_read(state, MB86A16_SIG1, &stat) != 2)
602 goto err;
603 if (mb86a16_read(state, MB86A16_SIG2, &stat2) != 2)
604 goto err;
605 if ((stat > 25) && (stat2 > 25))
606 *status |= FE_HAS_SIGNAL;
607 if ((stat > 45) && (stat2 > 45))
608 *status |= FE_HAS_CARRIER;
609
610 if (mb86a16_read(state, MB86A16_STATUS, &stat) != 2)
611 goto err;
612
613 if (stat & 0x01)
614 *status |= FE_HAS_SYNC;
615 if (stat & 0x01)
616 *status |= FE_HAS_VITERBI;
617
618 if (mb86a16_read(state, MB86A16_FRAMESYNC, &stat) != 2)
619 goto err;
620
621 if ((stat & 0x0f) && (*status & FE_HAS_VITERBI))
622 *status |= FE_HAS_LOCK;
623
624 return 0;
625
626 err:
627 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
628 return -EREMOTEIO;
629 }
630
631 static int sync_chk(struct mb86a16_state *state,
632 unsigned char *VIRM)
633 {
634 unsigned char val;
635 int sync;
636
637 if (mb86a16_read(state, 0x0d, &val) != 2)
638 goto err;
639
640 dprintk(verbose, MB86A16_INFO, 1, "Status = %02x,", val);
641 sync = val & 0x01;
642 *VIRM = (val & 0x1c) >> 2;
643
644 return sync;
645 err:
646 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
647 return -EREMOTEIO;
648
649 }
650
651 static int freqerr_chk(struct mb86a16_state *state,
652 int fTP,
653 int smrt,
654 int unit)
655 {
656 unsigned char CRM, AFCML, AFCMH;
657 unsigned char temp1, temp2, temp3;
658 int crm, afcm, AFCM;
659 int crrerr, afcerr; /* kHz */
660 int frqerr; /* MHz */
661 int afcen, afcexen = 0;
662 int R, M, fOSC, fOSC_OFS;
663
664 if (mb86a16_read(state, 0x43, &CRM) != 2)
665 goto err;
666
667 if (CRM > 127)
668 crm = CRM - 256;
669 else
670 crm = CRM;
671
672 crrerr = smrt * crm / 256;
673 if (mb86a16_read(state, 0x49, &temp1) != 2)
674 goto err;
675
676 afcen = (temp1 & 0x04) >> 2;
677 if (afcen == 0) {
678 if (mb86a16_read(state, 0x2a, &temp1) != 2)
679 goto err;
680 afcexen = (temp1 & 0x20) >> 5;
681 }
682
683 if (afcen == 1) {
684 if (mb86a16_read(state, 0x0e, &AFCML) != 2)
685 goto err;
686 if (mb86a16_read(state, 0x0f, &AFCMH) != 2)
687 goto err;
688 } else if (afcexen == 1) {
689 if (mb86a16_read(state, 0x2b, &AFCML) != 2)
690 goto err;
691 if (mb86a16_read(state, 0x2c, &AFCMH) != 2)
692 goto err;
693 }
694 if ((afcen == 1) || (afcexen == 1)) {
695 smrt_info_get(state, smrt);
696 AFCM = ((AFCMH & 0x01) << 8) + AFCML;
697 if (AFCM > 255)
698 afcm = AFCM - 512;
699 else
700 afcm = AFCM;
701
702 afcerr = afcm * state->master_clk / 8192;
703 } else
704 afcerr = 0;
705
706 if (mb86a16_read(state, 0x22, &temp1) != 2)
707 goto err;
708 if (mb86a16_read(state, 0x23, &temp2) != 2)
709 goto err;
710 if (mb86a16_read(state, 0x24, &temp3) != 2)
711 goto err;
712
713 R = (temp1 & 0xe0) >> 5;
714 M = ((temp1 & 0x1f) << 12) + (temp2 << 4) + (temp3 >> 4);
715 if (R == 0)
716 fOSC = 2 * M;
717 else
718 fOSC = M;
719
720 fOSC_OFS = fOSC - fTP;
721
722 if (unit == 0) { /* MHz */
723 if (crrerr + afcerr + fOSC_OFS * 1000 >= 0)
724 frqerr = (crrerr + afcerr + fOSC_OFS * 1000 + 500) / 1000;
725 else
726 frqerr = (crrerr + afcerr + fOSC_OFS * 1000 - 500) / 1000;
727 } else { /* kHz */
728 frqerr = crrerr + afcerr + fOSC_OFS * 1000;
729 }
730
731 return frqerr;
732 err:
733 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
734 return -EREMOTEIO;
735 }
736
737 static unsigned char vco_dev_get(struct mb86a16_state *state, int smrt)
738 {
739 unsigned char R;
740
741 if (smrt > 9375)
742 R = 0;
743 else
744 R = 1;
745
746 return R;
747 }
748
749 static void swp_info_get(struct mb86a16_state *state,
750 int fOSC_start,
751 int smrt,
752 int v, int R,
753 int swp_ofs,
754 int *fOSC,
755 int *afcex_freq,
756 unsigned char *AFCEX_L,
757 unsigned char *AFCEX_H)
758 {
759 int AFCEX ;
760 int crnt_swp_freq ;
761
762 crnt_swp_freq = fOSC_start * 1000 + v * swp_ofs;
763
764 if (R == 0)
765 *fOSC = (crnt_swp_freq + 1000) / 2000 * 2;
766 else
767 *fOSC = (crnt_swp_freq + 500) / 1000;
768
769 if (*fOSC >= crnt_swp_freq)
770 *afcex_freq = *fOSC * 1000 - crnt_swp_freq;
771 else
772 *afcex_freq = crnt_swp_freq - *fOSC * 1000;
773
774 AFCEX = *afcex_freq * 8192 / state->master_clk;
775 *AFCEX_L = AFCEX & 0x00ff;
776 *AFCEX_H = (AFCEX & 0x0f00) >> 8;
777 }
778
779
780 static int swp_freq_calcuation(struct mb86a16_state *state, int i, int v, int *V, int vmax, int vmin,
781 int SIGMIN, int fOSC, int afcex_freq, int swp_ofs, unsigned char *SIG1)
782 {
783 int swp_freq ;
784
785 if ((i % 2 == 1) && (v <= vmax)) {
786 /* positive v (case 1) */
787 if ((v - 1 == vmin) &&
788 (*(V + 30 + v) >= 0) &&
789 (*(V + 30 + v - 1) >= 0) &&
790 (*(V + 30 + v - 1) > *(V + 30 + v)) &&
791 (*(V + 30 + v - 1) > SIGMIN)) {
792
793 swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
794 *SIG1 = *(V + 30 + v - 1);
795 } else if ((v == vmax) &&
796 (*(V + 30 + v) >= 0) &&
797 (*(V + 30 + v - 1) >= 0) &&
798 (*(V + 30 + v) > *(V + 30 + v - 1)) &&
799 (*(V + 30 + v) > SIGMIN)) {
800 /* (case 2) */
801 swp_freq = fOSC * 1000 + afcex_freq;
802 *SIG1 = *(V + 30 + v);
803 } else if ((*(V + 30 + v) > 0) &&
804 (*(V + 30 + v - 1) > 0) &&
805 (*(V + 30 + v - 2) > 0) &&
806 (*(V + 30 + v - 3) > 0) &&
807 (*(V + 30 + v - 1) > *(V + 30 + v)) &&
808 (*(V + 30 + v - 2) > *(V + 30 + v - 3)) &&
809 ((*(V + 30 + v - 1) > SIGMIN) ||
810 (*(V + 30 + v - 2) > SIGMIN))) {
811 /* (case 3) */
812 if (*(V + 30 + v - 1) >= *(V + 30 + v - 2)) {
813 swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
814 *SIG1 = *(V + 30 + v - 1);
815 } else {
816 swp_freq = fOSC * 1000 + afcex_freq - swp_ofs * 2;
817 *SIG1 = *(V + 30 + v - 2);
818 }
819 } else if ((v == vmax) &&
820 (*(V + 30 + v) >= 0) &&
821 (*(V + 30 + v - 1) >= 0) &&
822 (*(V + 30 + v - 2) >= 0) &&
823 (*(V + 30 + v) > *(V + 30 + v - 2)) &&
824 (*(V + 30 + v - 1) > *(V + 30 + v - 2)) &&
825 ((*(V + 30 + v) > SIGMIN) ||
826 (*(V + 30 + v - 1) > SIGMIN))) {
827 /* (case 4) */
828 if (*(V + 30 + v) >= *(V + 30 + v - 1)) {
829 swp_freq = fOSC * 1000 + afcex_freq;
830 *SIG1 = *(V + 30 + v);
831 } else {
832 swp_freq = fOSC * 1000 + afcex_freq - swp_ofs;
833 *SIG1 = *(V + 30 + v - 1);
834 }
835 } else {
836 swp_freq = -1 ;
837 }
838 } else if ((i % 2 == 0) && (v >= vmin)) {
839 /* Negative v (case 1) */
840 if ((*(V + 30 + v) > 0) &&
841 (*(V + 30 + v + 1) > 0) &&
842 (*(V + 30 + v + 2) > 0) &&
843 (*(V + 30 + v + 1) > *(V + 30 + v)) &&
844 (*(V + 30 + v + 1) > *(V + 30 + v + 2)) &&
845 (*(V + 30 + v + 1) > SIGMIN)) {
846
847 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
848 *SIG1 = *(V + 30 + v + 1);
849 } else if ((v + 1 == vmax) &&
850 (*(V + 30 + v) >= 0) &&
851 (*(V + 30 + v + 1) >= 0) &&
852 (*(V + 30 + v + 1) > *(V + 30 + v)) &&
853 (*(V + 30 + v + 1) > SIGMIN)) {
854 /* (case 2) */
855 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
856 *SIG1 = *(V + 30 + v);
857 } else if ((v == vmin) &&
858 (*(V + 30 + v) > 0) &&
859 (*(V + 30 + v + 1) > 0) &&
860 (*(V + 30 + v + 2) > 0) &&
861 (*(V + 30 + v) > *(V + 30 + v + 1)) &&
862 (*(V + 30 + v) > *(V + 30 + v + 2)) &&
863 (*(V + 30 + v) > SIGMIN)) {
864 /* (case 3) */
865 swp_freq = fOSC * 1000 + afcex_freq;
866 *SIG1 = *(V + 30 + v);
867 } else if ((*(V + 30 + v) >= 0) &&
868 (*(V + 30 + v + 1) >= 0) &&
869 (*(V + 30 + v + 2) >= 0) &&
870 (*(V + 30 + v + 3) >= 0) &&
871 (*(V + 30 + v + 1) > *(V + 30 + v)) &&
872 (*(V + 30 + v + 2) > *(V + 30 + v + 3)) &&
873 ((*(V + 30 + v + 1) > SIGMIN) ||
874 (*(V + 30 + v + 2) > SIGMIN))) {
875 /* (case 4) */
876 if (*(V + 30 + v + 1) >= *(V + 30 + v + 2)) {
877 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
878 *SIG1 = *(V + 30 + v + 1);
879 } else {
880 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs * 2;
881 *SIG1 = *(V + 30 + v + 2);
882 }
883 } else if ((*(V + 30 + v) >= 0) &&
884 (*(V + 30 + v + 1) >= 0) &&
885 (*(V + 30 + v + 2) >= 0) &&
886 (*(V + 30 + v + 3) >= 0) &&
887 (*(V + 30 + v) > *(V + 30 + v + 2)) &&
888 (*(V + 30 + v + 1) > *(V + 30 + v + 2)) &&
889 (*(V + 30 + v) > *(V + 30 + v + 3)) &&
890 (*(V + 30 + v + 1) > *(V + 30 + v + 3)) &&
891 ((*(V + 30 + v) > SIGMIN) ||
892 (*(V + 30 + v + 1) > SIGMIN))) {
893 /* (case 5) */
894 if (*(V + 30 + v) >= *(V + 30 + v + 1)) {
895 swp_freq = fOSC * 1000 + afcex_freq;
896 *SIG1 = *(V + 30 + v);
897 } else {
898 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
899 *SIG1 = *(V + 30 + v + 1);
900 }
901 } else if ((v + 2 == vmin) &&
902 (*(V + 30 + v) >= 0) &&
903 (*(V + 30 + v + 1) >= 0) &&
904 (*(V + 30 + v + 2) >= 0) &&
905 (*(V + 30 + v + 1) > *(V + 30 + v)) &&
906 (*(V + 30 + v + 2) > *(V + 30 + v)) &&
907 ((*(V + 30 + v + 1) > SIGMIN) ||
908 (*(V + 30 + v + 2) > SIGMIN))) {
909 /* (case 6) */
910 if (*(V + 30 + v + 1) >= *(V + 30 + v + 2)) {
911 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs;
912 *SIG1 = *(V + 30 + v + 1);
913 } else {
914 swp_freq = fOSC * 1000 + afcex_freq + swp_ofs * 2;
915 *SIG1 = *(V + 30 + v + 2);
916 }
917 } else if ((vmax == 0) && (vmin == 0) && (*(V + 30 + v) > SIGMIN)) {
918 swp_freq = fOSC * 1000;
919 *SIG1 = *(V + 30 + v);
920 } else
921 swp_freq = -1;
922 } else
923 swp_freq = -1;
924
925 return swp_freq;
926 }
927
928 static void swp_info_get2(struct mb86a16_state *state,
929 int smrt,
930 int R,
931 int swp_freq,
932 int *afcex_freq,
933 int *fOSC,
934 unsigned char *AFCEX_L,
935 unsigned char *AFCEX_H)
936 {
937 int AFCEX ;
938
939 if (R == 0)
940 *fOSC = (swp_freq + 1000) / 2000 * 2;
941 else
942 *fOSC = (swp_freq + 500) / 1000;
943
944 if (*fOSC >= swp_freq)
945 *afcex_freq = *fOSC * 1000 - swp_freq;
946 else
947 *afcex_freq = swp_freq - *fOSC * 1000;
948
949 AFCEX = *afcex_freq * 8192 / state->master_clk;
950 *AFCEX_L = AFCEX & 0x00ff;
951 *AFCEX_H = (AFCEX & 0x0f00) >> 8;
952 }
953
954 static void afcex_info_get(struct mb86a16_state *state,
955 int afcex_freq,
956 unsigned char *AFCEX_L,
957 unsigned char *AFCEX_H)
958 {
959 int AFCEX ;
960
961 AFCEX = afcex_freq * 8192 / state->master_clk;
962 *AFCEX_L = AFCEX & 0x00ff;
963 *AFCEX_H = (AFCEX & 0x0f00) >> 8;
964 }
965
966 static int SEQ_set(struct mb86a16_state *state, unsigned char loop)
967 {
968 /* SLOCK0 = 0 */
969 if (mb86a16_write(state, 0x32, 0x02 | (loop << 2)) < 0) {
970 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
971 return -EREMOTEIO;
972 }
973
974 return 0;
975 }
976
977 static int iq_vt_set(struct mb86a16_state *state, unsigned char IQINV)
978 {
979 /* Viterbi Rate, IQ Settings */
980 if (mb86a16_write(state, 0x06, 0xdf | (IQINV << 5)) < 0) {
981 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
982 return -EREMOTEIO;
983 }
984
985 return 0;
986 }
987
988 static int FEC_srst(struct mb86a16_state *state)
989 {
990 if (mb86a16_write(state, MB86A16_RESET, 0x02) < 0) {
991 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
992 return -EREMOTEIO;
993 }
994
995 return 0;
996 }
997
998 static int S2T_set(struct mb86a16_state *state, unsigned char S2T)
999 {
1000 if (mb86a16_write(state, 0x34, 0x70 | S2T) < 0) {
1001 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1002 return -EREMOTEIO;
1003 }
1004
1005 return 0;
1006 }
1007
1008 static int S45T_set(struct mb86a16_state *state, unsigned char S4T, unsigned char S5T)
1009 {
1010 if (mb86a16_write(state, 0x35, 0x00 | (S5T << 4) | S4T) < 0) {
1011 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1012 return -EREMOTEIO;
1013 }
1014
1015 return 0;
1016 }
1017
1018
1019 static int mb86a16_set_fe(struct mb86a16_state *state)
1020 {
1021 u8 agcval, cnmval;
1022
1023 int i, j;
1024 int fOSC = 0;
1025 int fOSC_start = 0;
1026 int wait_t;
1027 int fcp;
1028 int swp_ofs;
1029 int V[60];
1030 u8 SIG1MIN;
1031
1032 unsigned char CREN, AFCEN, AFCEXEN;
1033 unsigned char SIG1;
1034 unsigned char TIMINT1, TIMINT2, TIMEXT;
1035 unsigned char S0T, S1T;
1036 unsigned char S2T;
1037 /* unsigned char S2T, S3T; */
1038 unsigned char S4T, S5T;
1039 unsigned char AFCEX_L, AFCEX_H;
1040 unsigned char R;
1041 unsigned char VIRM;
1042 unsigned char ETH, VIA;
1043 unsigned char junk;
1044
1045 int loop;
1046 int ftemp;
1047 int v, vmax, vmin;
1048 int vmax_his, vmin_his;
1049 int swp_freq, prev_swp_freq[20];
1050 int prev_freq_num;
1051 int signal_dupl;
1052 int afcex_freq;
1053 int signal;
1054 int afcerr;
1055 int temp_freq, delta_freq;
1056 int dagcm[4];
1057 int smrt_d;
1058 /* int freq_err; */
1059 int n;
1060 int ret = -1;
1061 int sync;
1062
1063 dprintk(verbose, MB86A16_INFO, 1, "freq=%d Mhz, symbrt=%d Ksps", state->frequency, state->srate);
1064
1065 fcp = 3000;
1066 swp_ofs = state->srate / 4;
1067
1068 for (i = 0; i < 60; i++)
1069 V[i] = -1;
1070
1071 for (i = 0; i < 20; i++)
1072 prev_swp_freq[i] = 0;
1073
1074 SIG1MIN = 25;
1075
1076 for (n = 0; ((n < 3) && (ret == -1)); n++) {
1077 SEQ_set(state, 0);
1078 iq_vt_set(state, 0);
1079
1080 CREN = 0;
1081 AFCEN = 0;
1082 AFCEXEN = 1;
1083 TIMINT1 = 0;
1084 TIMINT2 = 1;
1085 TIMEXT = 2;
1086 S1T = 0;
1087 S0T = 0;
1088
1089 if (initial_set(state) < 0) {
1090 dprintk(verbose, MB86A16_ERROR, 1, "initial set failed");
1091 return -1;
1092 }
1093 if (DAGC_data_set(state, 3, 2) < 0) {
1094 dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1095 return -1;
1096 }
1097 if (EN_set(state, CREN, AFCEN) < 0) {
1098 dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1099 return -1; /* (0, 0) */
1100 }
1101 if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1102 dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1103 return -1; /* (1, smrt) = (1, symbolrate) */
1104 }
1105 if (CNTM_set(state, TIMINT1, TIMINT2, TIMEXT) < 0) {
1106 dprintk(verbose, MB86A16_ERROR, 1, "CNTM set error");
1107 return -1; /* (0, 1, 2) */
1108 }
1109 if (S01T_set(state, S1T, S0T) < 0) {
1110 dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1111 return -1; /* (0, 0) */
1112 }
1113 smrt_info_get(state, state->srate);
1114 if (smrt_set(state, state->srate) < 0) {
1115 dprintk(verbose, MB86A16_ERROR, 1, "smrt info get error");
1116 return -1;
1117 }
1118
1119 R = vco_dev_get(state, state->srate);
1120 if (R == 1)
1121 fOSC_start = state->frequency;
1122
1123 else if (R == 0) {
1124 if (state->frequency % 2 == 0) {
1125 fOSC_start = state->frequency;
1126 } else {
1127 fOSC_start = state->frequency + 1;
1128 if (fOSC_start > 2150)
1129 fOSC_start = state->frequency - 1;
1130 }
1131 }
1132 loop = 1;
1133 ftemp = fOSC_start * 1000;
1134 vmax = 0 ;
1135 while (loop == 1) {
1136 ftemp = ftemp + swp_ofs;
1137 vmax++;
1138
1139 /* Upper bound */
1140 if (ftemp > 2150000) {
1141 loop = 0;
1142 vmax--;
1143 } else {
1144 if ((ftemp == 2150000) ||
1145 (ftemp - state->frequency * 1000 >= fcp + state->srate / 4))
1146 loop = 0;
1147 }
1148 }
1149
1150 loop = 1;
1151 ftemp = fOSC_start * 1000;
1152 vmin = 0 ;
1153 while (loop == 1) {
1154 ftemp = ftemp - swp_ofs;
1155 vmin--;
1156
1157 /* Lower bound */
1158 if (ftemp < 950000) {
1159 loop = 0;
1160 vmin++;
1161 } else {
1162 if ((ftemp == 950000) ||
1163 (state->frequency * 1000 - ftemp >= fcp + state->srate / 4))
1164 loop = 0;
1165 }
1166 }
1167
1168 wait_t = (8000 + state->srate / 2) / state->srate;
1169 if (wait_t == 0)
1170 wait_t = 1;
1171
1172 i = 0;
1173 j = 0;
1174 prev_freq_num = 0;
1175 loop = 1;
1176 signal = 0;
1177 vmax_his = 0;
1178 vmin_his = 0;
1179 v = 0;
1180
1181 while (loop == 1) {
1182 swp_info_get(state, fOSC_start, state->srate,
1183 v, R, swp_ofs, &fOSC,
1184 &afcex_freq, &AFCEX_L, &AFCEX_H);
1185
1186 udelay(100);
1187 if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1188 dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1189 return -1;
1190 }
1191 udelay(100);
1192 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1193 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1194 return -1;
1195 }
1196 if (srst(state) < 0) {
1197 dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1198 return -1;
1199 }
1200 msleep_interruptible(wait_t);
1201
1202 if (mb86a16_read(state, 0x37, &SIG1) != 2) {
1203 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1204 return -1;
1205 }
1206 V[30 + v] = SIG1 ;
1207 swp_freq = swp_freq_calcuation(state, i, v, V, vmax, vmin,
1208 SIG1MIN, fOSC, afcex_freq,
1209 swp_ofs, &SIG1); /* changed */
1210
1211 signal_dupl = 0;
1212 for (j = 0; j < prev_freq_num; j++) {
1213 if ((ABS(prev_swp_freq[j] - swp_freq)) < (swp_ofs * 3 / 2)) {
1214 signal_dupl = 1;
1215 dprintk(verbose, MB86A16_INFO, 1, "Probably Duplicate Signal, j = %d", j);
1216 }
1217 }
1218 if ((signal_dupl == 0) && (swp_freq > 0) && (ABS(swp_freq - state->frequency * 1000) < fcp + state->srate / 6)) {
1219 dprintk(verbose, MB86A16_DEBUG, 1, "------ Signal detect ------ [swp_freq=[%07d, srate=%05d]]", swp_freq, state->srate);
1220 prev_swp_freq[prev_freq_num] = swp_freq;
1221 prev_freq_num++;
1222 swp_info_get2(state, state->srate, R, swp_freq,
1223 &afcex_freq, &fOSC,
1224 &AFCEX_L, &AFCEX_H);
1225
1226 if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1227 dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1228 return -1;
1229 }
1230 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1231 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1232 return -1;
1233 }
1234 signal = signal_det(state, state->srate, &SIG1);
1235 if (signal == 1) {
1236 dprintk(verbose, MB86A16_ERROR, 1, "***** Signal Found *****");
1237 loop = 0;
1238 } else {
1239 dprintk(verbose, MB86A16_ERROR, 1, "!!!!! No signal !!!!!, try again...");
1240 smrt_info_get(state, state->srate);
1241 if (smrt_set(state, state->srate) < 0) {
1242 dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1243 return -1;
1244 }
1245 }
1246 }
1247 if (v > vmax)
1248 vmax_his = 1 ;
1249 if (v < vmin)
1250 vmin_his = 1 ;
1251 i++;
1252
1253 if ((i % 2 == 1) && (vmax_his == 1))
1254 i++;
1255 if ((i % 2 == 0) && (vmin_his == 1))
1256 i++;
1257
1258 if (i % 2 == 1)
1259 v = (i + 1) / 2;
1260 else
1261 v = -i / 2;
1262
1263 if ((vmax_his == 1) && (vmin_his == 1))
1264 loop = 0 ;
1265 }
1266
1267 if (signal == 1) {
1268 dprintk(verbose, MB86A16_INFO, 1, " Start Freq Error Check");
1269 S1T = 7 ;
1270 S0T = 1 ;
1271 CREN = 0 ;
1272 AFCEN = 1 ;
1273 AFCEXEN = 0 ;
1274
1275 if (S01T_set(state, S1T, S0T) < 0) {
1276 dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1277 return -1;
1278 }
1279 smrt_info_get(state, state->srate);
1280 if (smrt_set(state, state->srate) < 0) {
1281 dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1282 return -1;
1283 }
1284 if (EN_set(state, CREN, AFCEN) < 0) {
1285 dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1286 return -1;
1287 }
1288 if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1289 dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1290 return -1;
1291 }
1292 afcex_info_get(state, afcex_freq, &AFCEX_L, &AFCEX_H);
1293 if (afcofs_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1294 dprintk(verbose, MB86A16_ERROR, 1, "AFCOFS data set error");
1295 return -1;
1296 }
1297 if (srst(state) < 0) {
1298 dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1299 return -1;
1300 }
1301 /* delay 4~200 */
1302 wait_t = 200000 / state->master_clk + 200000 / state->srate;
1303 msleep(wait_t);
1304 afcerr = afcerr_chk(state);
1305 if (afcerr == -1)
1306 return -1;
1307
1308 swp_freq = fOSC * 1000 + afcerr ;
1309 AFCEXEN = 1 ;
1310 if (state->srate >= 1500)
1311 smrt_d = state->srate / 3;
1312 else
1313 smrt_d = state->srate / 2;
1314 smrt_info_get(state, smrt_d);
1315 if (smrt_set(state, smrt_d) < 0) {
1316 dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1317 return -1;
1318 }
1319 if (AFCEXEN_set(state, AFCEXEN, smrt_d) < 0) {
1320 dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1321 return -1;
1322 }
1323 R = vco_dev_get(state, smrt_d);
1324 if (DAGC_data_set(state, 2, 0) < 0) {
1325 dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1326 return -1;
1327 }
1328 for (i = 0; i < 3; i++) {
1329 temp_freq = swp_freq + (i - 1) * state->srate / 8;
1330 swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1331 if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1332 dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1333 return -1;
1334 }
1335 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1336 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1337 return -1;
1338 }
1339 wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1340 msleep(wait_t);
1341 dagcm[i] = dagcm_val_get(state);
1342 }
1343 if ((dagcm[0] > dagcm[1]) &&
1344 (dagcm[0] > dagcm[2]) &&
1345 (dagcm[0] - dagcm[1] > 2 * (dagcm[2] - dagcm[1]))) {
1346
1347 temp_freq = swp_freq - 2 * state->srate / 8;
1348 swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1349 if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1350 dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1351 return -1;
1352 }
1353 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1354 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set");
1355 return -1;
1356 }
1357 wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1358 msleep(wait_t);
1359 dagcm[3] = dagcm_val_get(state);
1360 if (dagcm[3] > dagcm[1])
1361 delta_freq = (dagcm[2] - dagcm[0] + dagcm[1] - dagcm[3]) * state->srate / 300;
1362 else
1363 delta_freq = 0;
1364 } else if ((dagcm[2] > dagcm[1]) &&
1365 (dagcm[2] > dagcm[0]) &&
1366 (dagcm[2] - dagcm[1] > 2 * (dagcm[0] - dagcm[1]))) {
1367
1368 temp_freq = swp_freq + 2 * state->srate / 8;
1369 swp_info_get2(state, smrt_d, R, temp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1370 if (rf_val_set(state, fOSC, smrt_d, R) < 0) {
1371 dprintk(verbose, MB86A16_ERROR, 1, "rf val set");
1372 return -1;
1373 }
1374 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1375 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set");
1376 return -1;
1377 }
1378 wait_t = 200000 / state->master_clk + 40000 / smrt_d;
1379 msleep(wait_t);
1380 dagcm[3] = dagcm_val_get(state);
1381 if (dagcm[3] > dagcm[1])
1382 delta_freq = (dagcm[2] - dagcm[0] + dagcm[3] - dagcm[1]) * state->srate / 300;
1383 else
1384 delta_freq = 0 ;
1385
1386 } else {
1387 delta_freq = 0 ;
1388 }
1389 dprintk(verbose, MB86A16_INFO, 1, "SWEEP Frequency = %d", swp_freq);
1390 swp_freq += delta_freq;
1391 dprintk(verbose, MB86A16_INFO, 1, "Adjusting .., DELTA Freq = %d, SWEEP Freq=%d", delta_freq, swp_freq);
1392 if (ABS(state->frequency * 1000 - swp_freq) > 3800) {
1393 dprintk(verbose, MB86A16_INFO, 1, "NO -- SIGNAL !");
1394 } else {
1395
1396 S1T = 0;
1397 S0T = 3;
1398 CREN = 1;
1399 AFCEN = 0;
1400 AFCEXEN = 1;
1401
1402 if (S01T_set(state, S1T, S0T) < 0) {
1403 dprintk(verbose, MB86A16_ERROR, 1, "S01T set error");
1404 return -1;
1405 }
1406 if (DAGC_data_set(state, 0, 0) < 0) {
1407 dprintk(verbose, MB86A16_ERROR, 1, "DAGC data set error");
1408 return -1;
1409 }
1410 R = vco_dev_get(state, state->srate);
1411 smrt_info_get(state, state->srate);
1412 if (smrt_set(state, state->srate) < 0) {
1413 dprintk(verbose, MB86A16_ERROR, 1, "smrt set error");
1414 return -1;
1415 }
1416 if (EN_set(state, CREN, AFCEN) < 0) {
1417 dprintk(verbose, MB86A16_ERROR, 1, "EN set error");
1418 return -1;
1419 }
1420 if (AFCEXEN_set(state, AFCEXEN, state->srate) < 0) {
1421 dprintk(verbose, MB86A16_ERROR, 1, "AFCEXEN set error");
1422 return -1;
1423 }
1424 swp_info_get2(state, state->srate, R, swp_freq, &afcex_freq, &fOSC, &AFCEX_L, &AFCEX_H);
1425 if (rf_val_set(state, fOSC, state->srate, R) < 0) {
1426 dprintk(verbose, MB86A16_ERROR, 1, "rf val set error");
1427 return -1;
1428 }
1429 if (afcex_data_set(state, AFCEX_L, AFCEX_H) < 0) {
1430 dprintk(verbose, MB86A16_ERROR, 1, "afcex data set error");
1431 return -1;
1432 }
1433 if (srst(state) < 0) {
1434 dprintk(verbose, MB86A16_ERROR, 1, "srst error");
1435 return -1;
1436 }
1437 wait_t = 7 + (10000 + state->srate / 2) / state->srate;
1438 if (wait_t == 0)
1439 wait_t = 1;
1440 msleep_interruptible(wait_t);
1441 if (mb86a16_read(state, 0x37, &SIG1) != 2) {
1442 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1443 return -EREMOTEIO;
1444 }
1445
1446 if (SIG1 > 110) {
1447 S2T = 4; S4T = 1; S5T = 6; ETH = 4; VIA = 6;
1448 wait_t = 7 + (917504 + state->srate / 2) / state->srate;
1449 } else if (SIG1 > 105) {
1450 S2T = 4; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1451 wait_t = 7 + (1048576 + state->srate / 2) / state->srate;
1452 } else if (SIG1 > 85) {
1453 S2T = 5; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1454 wait_t = 7 + (1310720 + state->srate / 2) / state->srate;
1455 } else if (SIG1 > 65) {
1456 S2T = 6; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1457 wait_t = 7 + (1572864 + state->srate / 2) / state->srate;
1458 } else {
1459 S2T = 7; S4T = 2; S5T = 8; ETH = 7; VIA = 2;
1460 wait_t = 7 + (2097152 + state->srate / 2) / state->srate;
1461 }
1462 wait_t *= 2; /* FOS */
1463 S2T_set(state, S2T);
1464 S45T_set(state, S4T, S5T);
1465 Vi_set(state, ETH, VIA);
1466 srst(state);
1467 msleep_interruptible(wait_t);
1468 sync = sync_chk(state, &VIRM);
1469 dprintk(verbose, MB86A16_INFO, 1, "-------- Viterbi=[%d] SYNC=[%d] ---------", VIRM, sync);
1470 if (VIRM) {
1471 if (VIRM == 4) {
1472 /* 5/6 */
1473 if (SIG1 > 110)
1474 wait_t = (786432 + state->srate / 2) / state->srate;
1475 else
1476 wait_t = (1572864 + state->srate / 2) / state->srate;
1477 if (state->srate < 5000)
1478 /* FIXME ! , should be a long wait ! */
1479 msleep_interruptible(wait_t);
1480 else
1481 msleep_interruptible(wait_t);
1482
1483 if (sync_chk(state, &junk) == 0) {
1484 iq_vt_set(state, 1);
1485 FEC_srst(state);
1486 }
1487 }
1488 /* 1/2, 2/3, 3/4, 7/8 */
1489 if (SIG1 > 110)
1490 wait_t = (786432 + state->srate / 2) / state->srate;
1491 else
1492 wait_t = (1572864 + state->srate / 2) / state->srate;
1493 msleep_interruptible(wait_t);
1494 SEQ_set(state, 1);
1495 } else {
1496 dprintk(verbose, MB86A16_INFO, 1, "NO -- SYNC");
1497 SEQ_set(state, 1);
1498 ret = -1;
1499 }
1500 }
1501 } else {
1502 dprintk(verbose, MB86A16_INFO, 1, "NO -- SIGNAL");
1503 ret = -1;
1504 }
1505
1506 sync = sync_chk(state, &junk);
1507 if (sync) {
1508 dprintk(verbose, MB86A16_INFO, 1, "******* SYNC *******");
1509 freqerr_chk(state, state->frequency, state->srate, 1);
1510 ret = 0;
1511 break;
1512 }
1513 }
1514
1515 mb86a16_read(state, 0x15, &agcval);
1516 mb86a16_read(state, 0x26, &cnmval);
1517 dprintk(verbose, MB86A16_INFO, 1, "AGC = %02x CNM = %02x", agcval, cnmval);
1518
1519 return ret;
1520 }
1521
1522 static int mb86a16_send_diseqc_msg(struct dvb_frontend *fe,
1523 struct dvb_diseqc_master_cmd *cmd)
1524 {
1525 struct mb86a16_state *state = fe->demodulator_priv;
1526 int i;
1527 u8 regs;
1528
1529 if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA) < 0)
1530 goto err;
1531 if (mb86a16_write(state, MB86A16_DCCOUT, 0x00) < 0)
1532 goto err;
1533 if (mb86a16_write(state, MB86A16_TONEOUT2, 0x04) < 0)
1534 goto err;
1535
1536 regs = 0x18;
1537
1538 if (cmd->msg_len > 5 || cmd->msg_len < 4)
1539 return -EINVAL;
1540
1541 for (i = 0; i < cmd->msg_len; i++) {
1542 if (mb86a16_write(state, regs, cmd->msg[i]) < 0)
1543 goto err;
1544
1545 regs++;
1546 }
1547 i += 0x90;
1548
1549 msleep_interruptible(10);
1550
1551 if (mb86a16_write(state, MB86A16_DCC1, i) < 0)
1552 goto err;
1553 if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1554 goto err;
1555
1556 return 0;
1557
1558 err:
1559 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1560 return -EREMOTEIO;
1561 }
1562
1563 static int mb86a16_send_diseqc_burst(struct dvb_frontend *fe, fe_sec_mini_cmd_t burst)
1564 {
1565 struct mb86a16_state *state = fe->demodulator_priv;
1566
1567 switch (burst) {
1568 case SEC_MINI_A:
1569 if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1570 MB86A16_DCC1_TBEN |
1571 MB86A16_DCC1_TBO) < 0)
1572 goto err;
1573 if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1574 goto err;
1575 break;
1576 case SEC_MINI_B:
1577 if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1578 MB86A16_DCC1_TBEN) < 0)
1579 goto err;
1580 if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1581 goto err;
1582 break;
1583 }
1584
1585 return 0;
1586 err:
1587 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1588 return -EREMOTEIO;
1589 }
1590
1591 static int mb86a16_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
1592 {
1593 struct mb86a16_state *state = fe->demodulator_priv;
1594
1595 switch (tone) {
1596 case SEC_TONE_ON:
1597 if (mb86a16_write(state, MB86A16_TONEOUT2, 0x00) < 0)
1598 goto err;
1599 if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA |
1600 MB86A16_DCC1_CTOE) < 0)
1601
1602 goto err;
1603 if (mb86a16_write(state, MB86A16_DCCOUT, MB86A16_DCCOUT_DISEN) < 0)
1604 goto err;
1605 break;
1606 case SEC_TONE_OFF:
1607 if (mb86a16_write(state, MB86A16_TONEOUT2, 0x04) < 0)
1608 goto err;
1609 if (mb86a16_write(state, MB86A16_DCC1, MB86A16_DCC1_DISTA) < 0)
1610 goto err;
1611 if (mb86a16_write(state, MB86A16_DCCOUT, 0x00) < 0)
1612 goto err;
1613 break;
1614 default:
1615 return -EINVAL;
1616 }
1617 return 0;
1618
1619 err:
1620 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1621 return -EREMOTEIO;
1622 }
1623
1624 static enum dvbfe_search mb86a16_search(struct dvb_frontend *fe,
1625 struct dvb_frontend_parameters *p)
1626 {
1627 struct mb86a16_state *state = fe->demodulator_priv;
1628
1629 state->frequency = p->frequency / 1000;
1630 state->srate = p->u.qpsk.symbol_rate / 1000;
1631
1632 if (!mb86a16_set_fe(state)) {
1633 dprintk(verbose, MB86A16_ERROR, 1, "Succesfully acquired LOCK");
1634 return DVBFE_ALGO_SEARCH_SUCCESS;
1635 }
1636
1637 dprintk(verbose, MB86A16_ERROR, 1, "Lock acquisition failed!");
1638 return DVBFE_ALGO_SEARCH_FAILED;
1639 }
1640
1641 static void mb86a16_release(struct dvb_frontend *fe)
1642 {
1643 struct mb86a16_state *state = fe->demodulator_priv;
1644 kfree(state);
1645 }
1646
1647 static int mb86a16_init(struct dvb_frontend *fe)
1648 {
1649 return 0;
1650 }
1651
1652 static int mb86a16_sleep(struct dvb_frontend *fe)
1653 {
1654 return 0;
1655 }
1656
1657 static int mb86a16_read_ber(struct dvb_frontend *fe, u32 *ber)
1658 {
1659 u8 ber_mon, ber_tab, ber_lsb, ber_mid, ber_msb, ber_tim, ber_rst;
1660 u32 timer;
1661
1662 struct mb86a16_state *state = fe->demodulator_priv;
1663
1664 *ber = 0;
1665 if (mb86a16_read(state, MB86A16_BERMON, &ber_mon) != 2)
1666 goto err;
1667 if (mb86a16_read(state, MB86A16_BERTAB, &ber_tab) != 2)
1668 goto err;
1669 if (mb86a16_read(state, MB86A16_BERLSB, &ber_lsb) != 2)
1670 goto err;
1671 if (mb86a16_read(state, MB86A16_BERMID, &ber_mid) != 2)
1672 goto err;
1673 if (mb86a16_read(state, MB86A16_BERMSB, &ber_msb) != 2)
1674 goto err;
1675 /* BER monitor invalid when BER_EN = 0 */
1676 if (ber_mon & 0x04) {
1677 /* coarse, fast calculation */
1678 *ber = ber_tab & 0x1f;
1679 dprintk(verbose, MB86A16_DEBUG, 1, "BER coarse=[0x%02x]", *ber);
1680 if (ber_mon & 0x01) {
1681 /*
1682 * BER_SEL = 1, The monitored BER is the estimated
1683 * value with a Reed-Solomon decoder error amount at
1684 * the deinterleaver output.
1685 * monitored BER is expressed as a 20 bit output in total
1686 */
1687 ber_rst = ber_mon >> 3;
1688 *ber = (((ber_msb << 8) | ber_mid) << 8) | ber_lsb;
1689 if (ber_rst == 0)
1690 timer = 12500000;
1691 if (ber_rst == 1)
1692 timer = 25000000;
1693 if (ber_rst == 2)
1694 timer = 50000000;
1695 if (ber_rst == 3)
1696 timer = 100000000;
1697
1698 *ber /= timer;
1699 dprintk(verbose, MB86A16_DEBUG, 1, "BER fine=[0x%02x]", *ber);
1700 } else {
1701 /*
1702 * BER_SEL = 0, The monitored BER is the estimated
1703 * value with a Viterbi decoder error amount at the
1704 * QPSK demodulator output.
1705 * monitored BER is expressed as a 24 bit output in total
1706 */
1707 ber_tim = ber_mon >> 1;
1708 *ber = (((ber_msb << 8) | ber_mid) << 8) | ber_lsb;
1709 if (ber_tim == 0)
1710 timer = 16;
1711 if (ber_tim == 1)
1712 timer = 24;
1713
1714 *ber /= 2 ^ timer;
1715 dprintk(verbose, MB86A16_DEBUG, 1, "BER fine=[0x%02x]", *ber);
1716 }
1717 }
1718 return 0;
1719 err:
1720 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1721 return -EREMOTEIO;
1722 }
1723
1724 static int mb86a16_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1725 {
1726 u8 agcm = 0;
1727 struct mb86a16_state *state = fe->demodulator_priv;
1728
1729 *strength = 0;
1730 if (mb86a16_read(state, MB86A16_AGCM, &agcm) != 2) {
1731 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1732 return -EREMOTEIO;
1733 }
1734
1735 *strength = ((0xff - agcm) * 100) / 256;
1736 dprintk(verbose, MB86A16_DEBUG, 1, "Signal strength=[%d %%]", (u8) *strength);
1737 *strength = (0xffff - 0xff) + agcm;
1738
1739 return 0;
1740 }
1741
1742 struct cnr {
1743 u8 cn_reg;
1744 u8 cn_val;
1745 };
1746
1747 static const struct cnr cnr_tab[] = {
1748 { 35, 2 },
1749 { 40, 3 },
1750 { 50, 4 },
1751 { 60, 5 },
1752 { 70, 6 },
1753 { 80, 7 },
1754 { 92, 8 },
1755 { 103, 9 },
1756 { 115, 10 },
1757 { 138, 12 },
1758 { 162, 15 },
1759 { 180, 18 },
1760 { 185, 19 },
1761 { 189, 20 },
1762 { 195, 22 },
1763 { 199, 24 },
1764 { 201, 25 },
1765 { 202, 26 },
1766 { 203, 27 },
1767 { 205, 28 },
1768 { 208, 30 }
1769 };
1770
1771 static int mb86a16_read_snr(struct dvb_frontend *fe, u16 *snr)
1772 {
1773 struct mb86a16_state *state = fe->demodulator_priv;
1774 int i = 0;
1775 int low_tide = 2, high_tide = 30, q_level;
1776 u8 cn;
1777
1778 *snr = 0;
1779 if (mb86a16_read(state, 0x26, &cn) != 2) {
1780 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1781 return -EREMOTEIO;
1782 }
1783
1784 for (i = 0; i < ARRAY_SIZE(cnr_tab); i++) {
1785 if (cn < cnr_tab[i].cn_reg) {
1786 *snr = cnr_tab[i].cn_val;
1787 break;
1788 }
1789 }
1790 q_level = (*snr * 100) / (high_tide - low_tide);
1791 dprintk(verbose, MB86A16_ERROR, 1, "SNR (Quality) = [%d dB], Level=%d %%", *snr, q_level);
1792 *snr = (0xffff - 0xff) + *snr;
1793
1794 return 0;
1795 }
1796
1797 static int mb86a16_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1798 {
1799 u8 dist;
1800 struct mb86a16_state *state = fe->demodulator_priv;
1801
1802 if (mb86a16_read(state, MB86A16_DISTMON, &dist) != 2) {
1803 dprintk(verbose, MB86A16_ERROR, 1, "I2C transfer error");
1804 return -EREMOTEIO;
1805 }
1806 *ucblocks = dist;
1807
1808 return 0;
1809 }
1810
1811 static enum dvbfe_algo mb86a16_frontend_algo(struct dvb_frontend *fe)
1812 {
1813 return DVBFE_ALGO_CUSTOM;
1814 }
1815
1816 static struct dvb_frontend_ops mb86a16_ops = {
1817 .info = {
1818 .name = "Fujitsu MB86A16 DVB-S",
1819 .type = FE_QPSK,
1820 .frequency_min = 950000,
1821 .frequency_max = 2150000,
1822 .frequency_stepsize = 3000,
1823 .frequency_tolerance = 0,
1824 .symbol_rate_min = 1000000,
1825 .symbol_rate_max = 45000000,
1826 .symbol_rate_tolerance = 500,
1827 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
1828 FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 |
1829 FE_CAN_FEC_7_8 | FE_CAN_QPSK |
1830 FE_CAN_FEC_AUTO
1831 },
1832 .release = mb86a16_release,
1833
1834 .get_frontend_algo = mb86a16_frontend_algo,
1835 .search = mb86a16_search,
1836 .init = mb86a16_init,
1837 .sleep = mb86a16_sleep,
1838 .read_status = mb86a16_read_status,
1839
1840 .read_ber = mb86a16_read_ber,
1841 .read_signal_strength = mb86a16_read_signal_strength,
1842 .read_snr = mb86a16_read_snr,
1843 .read_ucblocks = mb86a16_read_ucblocks,
1844
1845 .diseqc_send_master_cmd = mb86a16_send_diseqc_msg,
1846 .diseqc_send_burst = mb86a16_send_diseqc_burst,
1847 .set_tone = mb86a16_set_tone,
1848 };
1849
1850 struct dvb_frontend *mb86a16_attach(const struct mb86a16_config *config,
1851 struct i2c_adapter *i2c_adap)
1852 {
1853 u8 dev_id = 0;
1854 struct mb86a16_state *state = NULL;
1855
1856 state = kmalloc(sizeof(struct mb86a16_state), GFP_KERNEL);
1857 if (state == NULL)
1858 goto error;
1859
1860 state->config = config;
1861 state->i2c_adap = i2c_adap;
1862
1863 mb86a16_read(state, 0x7f, &dev_id);
1864 if (dev_id != 0xfe)
1865 goto error;
1866
1867 memcpy(&state->frontend.ops, &mb86a16_ops, sizeof(struct dvb_frontend_ops));
1868 state->frontend.demodulator_priv = state;
1869 state->frontend.ops.set_voltage = state->config->set_voltage;
1870
1871 return &state->frontend;
1872 error:
1873 kfree(state);
1874 return NULL;
1875 }
1876 EXPORT_SYMBOL(mb86a16_attach);
1877 MODULE_LICENSE("GPL");
1878 MODULE_AUTHOR("Manu Abraham");
Linux kernel - Deliverables
This page took 0.085429 seconds and 6 git commands to generate.