?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / dvb / frontends / af9013.c
blobdac917f7bb7f8b79f6939a60aa1f43b40c580656
1 /*
2 * Afatech AF9013 demodulator driver
3 *
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 *
6 * Thanks to Afatech who kindly provided information.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 */
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/string.h>
30 #include <linux/slab.h>
31 #include <linux/firmware.h>
32
33 #include "dvb_frontend.h"
34 #include "af9013_priv.h"
35 #include "af9013.h"
36
37 int af9013_debug;
38
39 struct af9013_state {
40 struct i2c_adapter *i2c;
41 struct dvb_frontend frontend;
42
43 struct af9013_config config;
44
45 u16 signal_strength;
46 u32 ber;
47 u32 ucblocks;
48 u16 snr;
49 u32 frequency;
50 unsigned long next_statistics_check;
51 };
52
53 static u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
54
55 static int af9013_write_regs(struct af9013_state *state, u8 mbox, u16 reg,
56 u8 *val, u8 len)
57 {
58 u8 buf[3+len];
59 struct i2c_msg msg = {
60 .addr = state->config.demod_address,
61 .flags = 0,
62 .len = sizeof(buf),
63 .buf = buf };
64
65 buf[0] = reg >> 8;
66 buf[1] = reg & 0xff;
67 buf[2] = mbox;
68 memcpy(&buf[3], val, len);
69
70 if (i2c_transfer(state->i2c, &msg, 1) != 1) {
71 warn("I2C write failed reg:%04x len:%d", reg, len);
72 return -EREMOTEIO;
73 }
74 return 0;
75 }
76
77 static int af9013_write_ofdm_regs(struct af9013_state *state, u16 reg, u8 *val,
78 u8 len)
79 {
80 u8 mbox = (1 << 0)|(1 << 1)|((len - 1) << 2)|(0 << 6)|(0 << 7);
81 return af9013_write_regs(state, mbox, reg, val, len);
82 }
83
84 static int af9013_write_ofsm_regs(struct af9013_state *state, u16 reg, u8 *val,
85 u8 len)
86 {
87 u8 mbox = (1 << 0)|(1 << 1)|((len - 1) << 2)|(1 << 6)|(1 << 7);
88 return af9013_write_regs(state, mbox, reg, val, len);
89 }
90
91 /* write single register */
92 static int af9013_write_reg(struct af9013_state *state, u16 reg, u8 val)
93 {
94 return af9013_write_ofdm_regs(state, reg, &val, 1);
95 }
96
97 /* read single register */
98 static int af9013_read_reg(struct af9013_state *state, u16 reg, u8 *val)
99 {
100 u8 obuf[3] = { reg >> 8, reg & 0xff, 0 };
101 u8 ibuf[1];
102 struct i2c_msg msg[2] = {
103 {
104 .addr = state->config.demod_address,
105 .flags = 0,
106 .len = sizeof(obuf),
107 .buf = obuf
108 }, {
109 .addr = state->config.demod_address,
110 .flags = I2C_M_RD,
111 .len = sizeof(ibuf),
112 .buf = ibuf
113 }
114 };
115
116 if (i2c_transfer(state->i2c, msg, 2) != 2) {
117 warn("I2C read failed reg:%04x", reg);
118 return -EREMOTEIO;
119 }
120 *val = ibuf[0];
121 return 0;
122 }
123
124 static int af9013_write_reg_bits(struct af9013_state *state, u16 reg, u8 pos,
125 u8 len, u8 val)
126 {
127 int ret;
128 u8 tmp, mask;
129
130 ret = af9013_read_reg(state, reg, &tmp);
131 if (ret)
132 return ret;
133
134 mask = regmask[len - 1] << pos;
135 tmp = (tmp & ~mask) | ((val << pos) & mask);
136
137 return af9013_write_reg(state, reg, tmp);
138 }
139
140 static int af9013_read_reg_bits(struct af9013_state *state, u16 reg, u8 pos,
141 u8 len, u8 *val)
142 {
143 int ret;
144 u8 tmp;
145
146 ret = af9013_read_reg(state, reg, &tmp);
147 if (ret)
148 return ret;
149 *val = (tmp >> pos) & regmask[len - 1];
150 return 0;
151 }
152
153 static int af9013_set_gpio(struct af9013_state *state, u8 gpio, u8 gpioval)
154 {
155 int ret;
156 u8 pos;
157 u16 addr;
158 deb_info("%s: gpio:%d gpioval:%02x\n", __func__, gpio, gpioval);
159
160 /* GPIO0 & GPIO1 0xd735
161 GPIO2 & GPIO3 0xd736 */
162
163 switch (gpio) {
164 case 0:
165 case 1:
166 addr = 0xd735;
167 break;
168 case 2:
169 case 3:
170 addr = 0xd736;
171 break;
172
173 default:
174 err("invalid gpio:%d\n", gpio);
175 ret = -EINVAL;
176 goto error;
177 };
178
179 switch (gpio) {
180 case 0:
181 case 2:
182 pos = 0;
183 break;
184 case 1:
185 case 3:
186 default:
187 pos = 4;
188 break;
189 };
190
191 ret = af9013_write_reg_bits(state, addr, pos, 4, gpioval);
192
193 error:
194 return ret;
195 }
196
197 static u32 af913_div(u32 a, u32 b, u32 x)
198 {
199 u32 r = 0, c = 0, i;
200 deb_info("%s: a:%d b:%d x:%d\n", __func__, a, b, x);
201
202 if (a > b) {
203 c = a / b;
204 a = a - c * b;
205 }
206
207 for (i = 0; i < x; i++) {
208 if (a >= b) {
209 r += 1;
210 a -= b;
211 }
212 a <<= 1;
213 r <<= 1;
214 }
215 r = (c << (u32)x) + r;
216
217 deb_info("%s: a:%d b:%d x:%d r:%d r:%x\n", __func__, a, b, x, r, r);
218 return r;
219 }
220
221 static int af9013_set_coeff(struct af9013_state *state, fe_bandwidth_t bw)
222 {
223 int ret = 0;
224 u8 i = 0;
225 u8 buf[24];
226 u32 uninitialized_var(ns_coeff1_2048nu);
227 u32 uninitialized_var(ns_coeff1_8191nu);
228 u32 uninitialized_var(ns_coeff1_8192nu);
229 u32 uninitialized_var(ns_coeff1_8193nu);
230 u32 uninitialized_var(ns_coeff2_2k);
231 u32 uninitialized_var(ns_coeff2_8k);
232
233 deb_info("%s: adc_clock:%d bw:%d\n", __func__,
234 state->config.adc_clock, bw);
235
236 switch (state->config.adc_clock) {
237 case 28800: /* 28.800 MHz */
238 switch (bw) {
239 case BANDWIDTH_6_MHZ:
240 ns_coeff1_2048nu = 0x01e79e7a;
241 ns_coeff1_8191nu = 0x0079eb6e;
242 ns_coeff1_8192nu = 0x0079e79e;
243 ns_coeff1_8193nu = 0x0079e3cf;
244 ns_coeff2_2k = 0x00f3cf3d;
245 ns_coeff2_8k = 0x003cf3cf;
246 break;
247 case BANDWIDTH_7_MHZ:
248 ns_coeff1_2048nu = 0x0238e38e;
249 ns_coeff1_8191nu = 0x008e3d55;
250 ns_coeff1_8192nu = 0x008e38e4;
251 ns_coeff1_8193nu = 0x008e3472;
252 ns_coeff2_2k = 0x011c71c7;
253 ns_coeff2_8k = 0x00471c72;
254 break;
255 case BANDWIDTH_8_MHZ:
256 ns_coeff1_2048nu = 0x028a28a3;
257 ns_coeff1_8191nu = 0x00a28f3d;
258 ns_coeff1_8192nu = 0x00a28a29;
259 ns_coeff1_8193nu = 0x00a28514;
260 ns_coeff2_2k = 0x01451451;
261 ns_coeff2_8k = 0x00514514;
262 break;
263 default:
264 ret = -EINVAL;
265 }
266 break;
267 case 20480: /* 20.480 MHz */
268 switch (bw) {
269 case BANDWIDTH_6_MHZ:
270 ns_coeff1_2048nu = 0x02adb6dc;
271 ns_coeff1_8191nu = 0x00ab7313;
272 ns_coeff1_8192nu = 0x00ab6db7;
273 ns_coeff1_8193nu = 0x00ab685c;
274 ns_coeff2_2k = 0x0156db6e;
275 ns_coeff2_8k = 0x0055b6dc;
276 break;
277 case BANDWIDTH_7_MHZ:
278 ns_coeff1_2048nu = 0x03200001;
279 ns_coeff1_8191nu = 0x00c80640;
280 ns_coeff1_8192nu = 0x00c80000;
281 ns_coeff1_8193nu = 0x00c7f9c0;
282 ns_coeff2_2k = 0x01900000;
283 ns_coeff2_8k = 0x00640000;
284 break;
285 case BANDWIDTH_8_MHZ:
286 ns_coeff1_2048nu = 0x03924926;
287 ns_coeff1_8191nu = 0x00e4996e;
288 ns_coeff1_8192nu = 0x00e49249;
289 ns_coeff1_8193nu = 0x00e48b25;
290 ns_coeff2_2k = 0x01c92493;
291 ns_coeff2_8k = 0x00724925;
292 break;
293 default:
294 ret = -EINVAL;
295 }
296 break;
297 case 28000: /* 28.000 MHz */
298 switch (bw) {
299 case BANDWIDTH_6_MHZ:
300 ns_coeff1_2048nu = 0x01f58d10;
301 ns_coeff1_8191nu = 0x007d672f;
302 ns_coeff1_8192nu = 0x007d6344;
303 ns_coeff1_8193nu = 0x007d5f59;
304 ns_coeff2_2k = 0x00fac688;
305 ns_coeff2_8k = 0x003eb1a2;
306 break;
307 case BANDWIDTH_7_MHZ:
308 ns_coeff1_2048nu = 0x02492492;
309 ns_coeff1_8191nu = 0x00924db7;
310 ns_coeff1_8192nu = 0x00924925;
311 ns_coeff1_8193nu = 0x00924492;
312 ns_coeff2_2k = 0x01249249;
313 ns_coeff2_8k = 0x00492492;
314 break;
315 case BANDWIDTH_8_MHZ:
316 ns_coeff1_2048nu = 0x029cbc15;
317 ns_coeff1_8191nu = 0x00a7343f;
318 ns_coeff1_8192nu = 0x00a72f05;
319 ns_coeff1_8193nu = 0x00a729cc;
320 ns_coeff2_2k = 0x014e5e0a;
321 ns_coeff2_8k = 0x00539783;
322 break;
323 default:
324 ret = -EINVAL;
325 }
326 break;
327 case 25000: /* 25.000 MHz */
328 switch (bw) {
329 case BANDWIDTH_6_MHZ:
330 ns_coeff1_2048nu = 0x0231bcb5;
331 ns_coeff1_8191nu = 0x008c7391;
332 ns_coeff1_8192nu = 0x008c6f2d;
333 ns_coeff1_8193nu = 0x008c6aca;
334 ns_coeff2_2k = 0x0118de5b;
335 ns_coeff2_8k = 0x00463797;
336 break;
337 case BANDWIDTH_7_MHZ:
338 ns_coeff1_2048nu = 0x028f5c29;
339 ns_coeff1_8191nu = 0x00a3dc29;
340 ns_coeff1_8192nu = 0x00a3d70a;
341 ns_coeff1_8193nu = 0x00a3d1ec;
342 ns_coeff2_2k = 0x0147ae14;
343 ns_coeff2_8k = 0x0051eb85;
344 break;
345 case BANDWIDTH_8_MHZ:
346 ns_coeff1_2048nu = 0x02ecfb9d;
347 ns_coeff1_8191nu = 0x00bb44c1;
348 ns_coeff1_8192nu = 0x00bb3ee7;
349 ns_coeff1_8193nu = 0x00bb390d;
350 ns_coeff2_2k = 0x01767dce;
351 ns_coeff2_8k = 0x005d9f74;
352 break;
353 default:
354 ret = -EINVAL;
355 }
356 break;
357 default:
358 err("invalid xtal");
359 return -EINVAL;
360 }
361 if (ret) {
362 err("invalid bandwidth");
363 return ret;
364 }
365
366 buf[i++] = (u8) ((ns_coeff1_2048nu & 0x03000000) >> 24);
367 buf[i++] = (u8) ((ns_coeff1_2048nu & 0x00ff0000) >> 16);
368 buf[i++] = (u8) ((ns_coeff1_2048nu & 0x0000ff00) >> 8);
369 buf[i++] = (u8) ((ns_coeff1_2048nu & 0x000000ff));
370 buf[i++] = (u8) ((ns_coeff2_2k & 0x01c00000) >> 22);
371 buf[i++] = (u8) ((ns_coeff2_2k & 0x003fc000) >> 14);
372 buf[i++] = (u8) ((ns_coeff2_2k & 0x00003fc0) >> 6);
373 buf[i++] = (u8) ((ns_coeff2_2k & 0x0000003f));
374 buf[i++] = (u8) ((ns_coeff1_8191nu & 0x03000000) >> 24);
375 buf[i++] = (u8) ((ns_coeff1_8191nu & 0x00ffc000) >> 16);
376 buf[i++] = (u8) ((ns_coeff1_8191nu & 0x0000ff00) >> 8);
377 buf[i++] = (u8) ((ns_coeff1_8191nu & 0x000000ff));
378 buf[i++] = (u8) ((ns_coeff1_8192nu & 0x03000000) >> 24);
379 buf[i++] = (u8) ((ns_coeff1_8192nu & 0x00ffc000) >> 16);
380 buf[i++] = (u8) ((ns_coeff1_8192nu & 0x0000ff00) >> 8);
381 buf[i++] = (u8) ((ns_coeff1_8192nu & 0x000000ff));
382 buf[i++] = (u8) ((ns_coeff1_8193nu & 0x03000000) >> 24);
383 buf[i++] = (u8) ((ns_coeff1_8193nu & 0x00ffc000) >> 16);
384 buf[i++] = (u8) ((ns_coeff1_8193nu & 0x0000ff00) >> 8);
385 buf[i++] = (u8) ((ns_coeff1_8193nu & 0x000000ff));
386 buf[i++] = (u8) ((ns_coeff2_8k & 0x01c00000) >> 22);
387 buf[i++] = (u8) ((ns_coeff2_8k & 0x003fc000) >> 14);
388 buf[i++] = (u8) ((ns_coeff2_8k & 0x00003fc0) >> 6);
389 buf[i++] = (u8) ((ns_coeff2_8k & 0x0000003f));
390
391 deb_info("%s: coeff:", __func__);
392 debug_dump(buf, sizeof(buf), deb_info);
393
394 /* program */
395 for (i = 0; i < sizeof(buf); i++) {
396 ret = af9013_write_reg(state, 0xae00 + i, buf[i]);
397 if (ret)
398 break;
399 }
400
401 return ret;
402 }
403
404 static int af9013_set_adc_ctrl(struct af9013_state *state)
405 {
406 int ret;
407 u8 buf[3], tmp, i;
408 u32 adc_cw;
409
410 deb_info("%s: adc_clock:%d\n", __func__, state->config.adc_clock);
411
412 /* adc frequency type */
413 switch (state->config.adc_clock) {
414 case 28800: /* 28.800 MHz */
415 tmp = 0;
416 break;
417 case 20480: /* 20.480 MHz */
418 tmp = 1;
419 break;
420 case 28000: /* 28.000 MHz */
421 tmp = 2;
422 break;
423 case 25000: /* 25.000 MHz */
424 tmp = 3;
425 break;
426 default:
427 err("invalid xtal");
428 return -EINVAL;
429 }
430
431 adc_cw = af913_div(state->config.adc_clock*1000, 1000000ul, 19ul);
432
433 buf[0] = (u8) ((adc_cw & 0x000000ff));
434 buf[1] = (u8) ((adc_cw & 0x0000ff00) >> 8);
435 buf[2] = (u8) ((adc_cw & 0x00ff0000) >> 16);
436
437 deb_info("%s: adc_cw:", __func__);
438 debug_dump(buf, sizeof(buf), deb_info);
439
440 /* program */
441 for (i = 0; i < sizeof(buf); i++) {
442 ret = af9013_write_reg(state, 0xd180 + i, buf[i]);
443 if (ret)
444 goto error;
445 }
446 ret = af9013_write_reg_bits(state, 0x9bd2, 0, 4, tmp);
447 error:
448 return ret;
449 }
450
451 static int af9013_set_freq_ctrl(struct af9013_state *state, fe_bandwidth_t bw)
452 {
453 int ret;
454 u16 addr;
455 u8 buf[3], i, j;
456 u32 adc_freq, freq_cw;
457 s8 bfs_spec_inv;
458 int if_sample_freq;
459
460 for (j = 0; j < 3; j++) {
461 if (j == 0) {
462 addr = 0xd140; /* fcw normal */
463 bfs_spec_inv = state->config.rf_spec_inv ? -1 : 1;
464 } else if (j == 1) {
465 addr = 0x9be7; /* fcw dummy ram */
466 bfs_spec_inv = state->config.rf_spec_inv ? -1 : 1;
467 } else {
468 addr = 0x9bea; /* fcw inverted */
469 bfs_spec_inv = state->config.rf_spec_inv ? 1 : -1;
470 }
471
472 adc_freq = state->config.adc_clock * 1000;
473 if_sample_freq = state->config.tuner_if * 1000;
474
475 /* TDA18271 uses different sampling freq for every bw */
476 if (state->config.tuner == AF9013_TUNER_TDA18271) {
477 switch (bw) {
478 case BANDWIDTH_6_MHZ:
479 if_sample_freq = 3300000; /* 3.3 MHz */
480 break;
481 case BANDWIDTH_7_MHZ:
482 if_sample_freq = 3800000; /* 3.8 MHz */
483 break;
484 case BANDWIDTH_8_MHZ:
485 default:
486 if_sample_freq = 4300000; /* 4.3 MHz */
487 break;
488 }
489 }
490
491 while (if_sample_freq > (adc_freq / 2))
492 if_sample_freq = if_sample_freq - adc_freq;
493
494 if (if_sample_freq >= 0)
495 bfs_spec_inv = bfs_spec_inv * (-1);
496 else
497 if_sample_freq = if_sample_freq * (-1);
498
499 freq_cw = af913_div(if_sample_freq, adc_freq, 23ul);
500
501 if (bfs_spec_inv == -1)
502 freq_cw = 0x00800000 - freq_cw;
503
504 buf[0] = (u8) ((freq_cw & 0x000000ff));
505 buf[1] = (u8) ((freq_cw & 0x0000ff00) >> 8);
506 buf[2] = (u8) ((freq_cw & 0x007f0000) >> 16);
507
508
509 deb_info("%s: freq_cw:", __func__);
510 debug_dump(buf, sizeof(buf), deb_info);
511
512 /* program */
513 for (i = 0; i < sizeof(buf); i++) {
514 ret = af9013_write_reg(state, addr++, buf[i]);
515 if (ret)
516 goto error;
517 }
518 }
519 error:
520 return ret;
521 }
522
523 static int af9013_set_ofdm_params(struct af9013_state *state,
524 struct dvb_ofdm_parameters *params, u8 *auto_mode)
525 {
526 int ret;
527 u8 i, buf[3] = {0, 0, 0};
528 *auto_mode = 0; /* set if parameters are requested to auto set */
529
530 /* Try auto-detect transmission parameters in case of AUTO requested or
531 garbage parameters given by application for compatibility.
532 MPlayer seems to provide garbage parameters currently. */
533
534 switch (params->transmission_mode) {
535 case TRANSMISSION_MODE_AUTO:
536 *auto_mode = 1;
537 case TRANSMISSION_MODE_2K:
538 break;
539 case TRANSMISSION_MODE_8K:
540 buf[0] |= (1 << 0);
541 break;
542 default:
543 deb_info("%s: invalid transmission_mode\n", __func__);
544 *auto_mode = 1;
545 }
546
547 switch (params->guard_interval) {
548 case GUARD_INTERVAL_AUTO:
549 *auto_mode = 1;
550 case GUARD_INTERVAL_1_32:
551 break;
552 case GUARD_INTERVAL_1_16:
553 buf[0] |= (1 << 2);
554 break;
555 case GUARD_INTERVAL_1_8:
556 buf[0] |= (2 << 2);
557 break;
558 case GUARD_INTERVAL_1_4:
559 buf[0] |= (3 << 2);
560 break;
561 default:
562 deb_info("%s: invalid guard_interval\n", __func__);
563 *auto_mode = 1;
564 }
565
566 switch (params->hierarchy_information) {
567 case HIERARCHY_AUTO:
568 *auto_mode = 1;
569 case HIERARCHY_NONE:
570 break;
571 case HIERARCHY_1:
572 buf[0] |= (1 << 4);
573 break;
574 case HIERARCHY_2:
575 buf[0] |= (2 << 4);
576 break;
577 case HIERARCHY_4:
578 buf[0] |= (3 << 4);
579 break;
580 default:
581 deb_info("%s: invalid hierarchy_information\n", __func__);
582 *auto_mode = 1;
583 };
584
585 switch (params->constellation) {
586 case QAM_AUTO:
587 *auto_mode = 1;
588 case QPSK:
589 break;
590 case QAM_16:
591 buf[1] |= (1 << 6);
592 break;
593 case QAM_64:
594 buf[1] |= (2 << 6);
595 break;
596 default:
597 deb_info("%s: invalid constellation\n", __func__);
598 *auto_mode = 1;
599 }
600
601 /* Use HP. How and which case we can switch to LP? */
602 buf[1] |= (1 << 4);
603
604 switch (params->code_rate_HP) {
605 case FEC_AUTO:
606 *auto_mode = 1;
607 case FEC_1_2:
608 break;
609 case FEC_2_3:
610 buf[2] |= (1 << 0);
611 break;
612 case FEC_3_4:
613 buf[2] |= (2 << 0);
614 break;
615 case FEC_5_6:
616 buf[2] |= (3 << 0);
617 break;
618 case FEC_7_8:
619 buf[2] |= (4 << 0);
620 break;
621 default:
622 deb_info("%s: invalid code_rate_HP\n", __func__);
623 *auto_mode = 1;
624 }
625
626 switch (params->code_rate_LP) {
627 case FEC_AUTO:
628 /* if HIERARCHY_NONE and FEC_NONE then LP FEC is set to FEC_AUTO
629 by dvb_frontend.c for compatibility */
630 if (params->hierarchy_information != HIERARCHY_NONE)
631 *auto_mode = 1;
632 case FEC_1_2:
633 break;
634 case FEC_2_3:
635 buf[2] |= (1 << 3);
636 break;
637 case FEC_3_4:
638 buf[2] |= (2 << 3);
639 break;
640 case FEC_5_6:
641 buf[2] |= (3 << 3);
642 break;
643 case FEC_7_8:
644 buf[2] |= (4 << 3);
645 break;
646 case FEC_NONE:
647 if (params->hierarchy_information == HIERARCHY_AUTO)
648 break;
649 default:
650 deb_info("%s: invalid code_rate_LP\n", __func__);
651 *auto_mode = 1;
652 }
653
654 switch (params->bandwidth) {
655 case BANDWIDTH_6_MHZ:
656 break;
657 case BANDWIDTH_7_MHZ:
658 buf[1] |= (1 << 2);
659 break;
660 case BANDWIDTH_8_MHZ:
661 buf[1] |= (2 << 2);
662 break;
663 default:
664 deb_info("%s: invalid bandwidth\n", __func__);
665 buf[1] |= (2 << 2); /* cannot auto-detect BW, try 8 MHz */
666 }
667
668 /* program */
669 for (i = 0; i < sizeof(buf); i++) {
670 ret = af9013_write_reg(state, 0xd3c0 + i, buf[i]);
671 if (ret)
672 break;
673 }
674
675 return ret;
676 }
677
678 static int af9013_reset(struct af9013_state *state, u8 sleep)
679 {
680 int ret;
681 u8 tmp, i;
682 deb_info("%s\n", __func__);
683
684 /* enable OFDM reset */
685 ret = af9013_write_reg_bits(state, 0xd417, 4, 1, 1);
686 if (ret)
687 goto error;
688
689 /* start reset mechanism */
690 ret = af9013_write_reg(state, 0xaeff, 1);
691 if (ret)
692 goto error;
693
694 /* reset is done when bit 1 is set */
695 for (i = 0; i < 150; i++) {
696 ret = af9013_read_reg_bits(state, 0xd417, 1, 1, &tmp);
697 if (ret)
698 goto error;
699 if (tmp)
700 break; /* reset done */
701 msleep(10);
702 }
703 if (!tmp)
704 return -ETIMEDOUT;
705
706 /* don't clear reset when going to sleep */
707 if (!sleep) {
708 /* clear OFDM reset */
709 ret = af9013_write_reg_bits(state, 0xd417, 1, 1, 0);
710 if (ret)
711 goto error;
712
713 /* disable OFDM reset */
714 ret = af9013_write_reg_bits(state, 0xd417, 4, 1, 0);
715 }
716 error:
717 return ret;
718 }
719
720 static int af9013_power_ctrl(struct af9013_state *state, u8 onoff)
721 {
722 int ret;
723 deb_info("%s: onoff:%d\n", __func__, onoff);
724
725 if (onoff) {
726 /* power on */
727 ret = af9013_write_reg_bits(state, 0xd73a, 3, 1, 0);
728 if (ret)
729 goto error;
730 ret = af9013_write_reg_bits(state, 0xd417, 1, 1, 0);
731 if (ret)
732 goto error;
733 ret = af9013_write_reg_bits(state, 0xd417, 4, 1, 0);
734 } else {
735 /* power off */
736 ret = af9013_reset(state, 1);
737 if (ret)
738 goto error;
739 ret = af9013_write_reg_bits(state, 0xd73a, 3, 1, 1);
740 }
741 error:
742 return ret;
743 }
744
745 static int af9013_lock_led(struct af9013_state *state, u8 onoff)
746 {
747 deb_info("%s: onoff:%d\n", __func__, onoff);
748
749 return af9013_write_reg_bits(state, 0xd730, 0, 1, onoff);
750 }
751
752 static int af9013_set_frontend(struct dvb_frontend *fe,
753 struct dvb_frontend_parameters *params)
754 {
755 struct af9013_state *state = fe->demodulator_priv;
756 int ret;
757 u8 auto_mode; /* auto set TPS */
758
759 deb_info("%s: freq:%d bw:%d\n", __func__, params->frequency,
760 params->u.ofdm.bandwidth);
761
762 state->frequency = params->frequency;
763
764 /* program tuner */
765 if (fe->ops.tuner_ops.set_params)
766 fe->ops.tuner_ops.set_params(fe, params);
767
768 /* program CFOE coefficients */
769 ret = af9013_set_coeff(state, params->u.ofdm.bandwidth);
770 if (ret)
771 goto error;
772
773 /* program frequency control */
774 ret = af9013_set_freq_ctrl(state, params->u.ofdm.bandwidth);
775 if (ret)
776 goto error;
777
778 /* clear TPS lock flag (inverted flag) */
779 ret = af9013_write_reg_bits(state, 0xd330, 3, 1, 1);
780 if (ret)
781 goto error;
782
783 /* clear MPEG2 lock flag */
784 ret = af9013_write_reg_bits(state, 0xd507, 6, 1, 0);
785 if (ret)
786 goto error;
787
788 /* empty channel function */
789 ret = af9013_write_reg_bits(state, 0x9bfe, 0, 1, 0);
790 if (ret)
791 goto error;
792
793 /* empty DVB-T channel function */
794 ret = af9013_write_reg_bits(state, 0x9bc2, 0, 1, 0);
795 if (ret)
796 goto error;
797
798 /* program TPS and bandwidth, check if auto mode needed */
799 ret = af9013_set_ofdm_params(state, &params->u.ofdm, &auto_mode);
800 if (ret)
801 goto error;
802
803 if (auto_mode) {
804 /* clear easy mode flag */
805 ret = af9013_write_reg(state, 0xaefd, 0);
806 deb_info("%s: auto TPS\n", __func__);
807 } else {
808 /* set easy mode flag */
809 ret = af9013_write_reg(state, 0xaefd, 1);
810 if (ret)
811 goto error;
812 ret = af9013_write_reg(state, 0xaefe, 0);
813 deb_info("%s: manual TPS\n", __func__);
814 }
815 if (ret)
816 goto error;
817
818 /* everything is set, lets try to receive channel - OFSM GO! */
819 ret = af9013_write_reg(state, 0xffff, 0);
820 if (ret)
821 goto error;
822
823 error:
824 return ret;
825 }
826
827 static int af9013_get_frontend(struct dvb_frontend *fe,
828 struct dvb_frontend_parameters *p)
829 {
830 struct af9013_state *state = fe->demodulator_priv;
831 int ret;
832 u8 i, buf[3];
833 deb_info("%s\n", __func__);
834
835 /* read TPS registers */
836 for (i = 0; i < 3; i++) {
837 ret = af9013_read_reg(state, 0xd3c0 + i, &buf[i]);
838 if (ret)
839 goto error;
840 }
841
842 switch ((buf[1] >> 6) & 3) {
843 case 0:
844 p->u.ofdm.constellation = QPSK;
845 break;
846 case 1:
847 p->u.ofdm.constellation = QAM_16;
848 break;
849 case 2:
850 p->u.ofdm.constellation = QAM_64;
851 break;
852 }
853
854 switch ((buf[0] >> 0) & 3) {
855 case 0:
856 p->u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
857 break;
858 case 1:
859 p->u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
860 }
861
862 switch ((buf[0] >> 2) & 3) {
863 case 0:
864 p->u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
865 break;
866 case 1:
867 p->u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
868 break;
869 case 2:
870 p->u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
871 break;
872 case 3:
873 p->u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
874 break;
875 }
876
877 switch ((buf[0] >> 4) & 7) {
878 case 0:
879 p->u.ofdm.hierarchy_information = HIERARCHY_NONE;
880 break;
881 case 1:
882 p->u.ofdm.hierarchy_information = HIERARCHY_1;
883 break;
884 case 2:
885 p->u.ofdm.hierarchy_information = HIERARCHY_2;
886 break;
887 case 3:
888 p->u.ofdm.hierarchy_information = HIERARCHY_4;
889 break;
890 }
891
892 switch ((buf[2] >> 0) & 7) {
893 case 0:
894 p->u.ofdm.code_rate_HP = FEC_1_2;
895 break;
896 case 1:
897 p->u.ofdm.code_rate_HP = FEC_2_3;
898 break;
899 case 2:
900 p->u.ofdm.code_rate_HP = FEC_3_4;
901 break;
902 case 3:
903 p->u.ofdm.code_rate_HP = FEC_5_6;
904 break;
905 case 4:
906 p->u.ofdm.code_rate_HP = FEC_7_8;
907 break;
908 }
909
910 switch ((buf[2] >> 3) & 7) {
911 case 0:
912 p->u.ofdm.code_rate_LP = FEC_1_2;
913 break;
914 case 1:
915 p->u.ofdm.code_rate_LP = FEC_2_3;
916 break;
917 case 2:
918 p->u.ofdm.code_rate_LP = FEC_3_4;
919 break;
920 case 3:
921 p->u.ofdm.code_rate_LP = FEC_5_6;
922 break;
923 case 4:
924 p->u.ofdm.code_rate_LP = FEC_7_8;
925 break;
926 }
927
928 switch ((buf[1] >> 2) & 3) {
929 case 0:
930 p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
931 break;
932 case 1:
933 p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
934 break;
935 case 2:
936 p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
937 break;
938 }
939
940 p->inversion = INVERSION_AUTO;
941 p->frequency = state->frequency;
942
943 error:
944 return ret;
945 }
946
947 static int af9013_update_ber_unc(struct dvb_frontend *fe)
948 {
949 struct af9013_state *state = fe->demodulator_priv;
950 int ret;
951 u8 buf[3], i;
952 u32 error_bit_count = 0;
953 u32 total_bit_count = 0;
954 u32 abort_packet_count = 0;
955
956 state->ber = 0;
957
958 /* check if error bit count is ready */
959 ret = af9013_read_reg_bits(state, 0xd391, 4, 1, &buf[0]);
960 if (ret)
961 goto error;
962 if (!buf[0])
963 goto exit;
964
965 /* get RSD packet abort count */
966 for (i = 0; i < 2; i++) {
967 ret = af9013_read_reg(state, 0xd38a + i, &buf[i]);
968 if (ret)
969 goto error;
970 }
971 abort_packet_count = (buf[1] << 8) + buf[0];
972
973 /* get error bit count */
974 for (i = 0; i < 3; i++) {
975 ret = af9013_read_reg(state, 0xd387 + i, &buf[i]);
976 if (ret)
977 goto error;
978 }
979 error_bit_count = (buf[2] << 16) + (buf[1] << 8) + buf[0];
980 error_bit_count = error_bit_count - abort_packet_count * 8 * 8;
981
982 /* get used RSD counting period (10000 RSD packets used) */
983 for (i = 0; i < 2; i++) {
984 ret = af9013_read_reg(state, 0xd385 + i, &buf[i]);
985 if (ret)
986 goto error;
987 }
988 total_bit_count = (buf[1] << 8) + buf[0];
989 total_bit_count = total_bit_count - abort_packet_count;
990 total_bit_count = total_bit_count * 204 * 8;
991
992 if (total_bit_count)
993 state->ber = error_bit_count * 1000000000 / total_bit_count;
994
995 state->ucblocks += abort_packet_count;
996
997 deb_info("%s: err bits:%d total bits:%d abort count:%d\n", __func__,
998 error_bit_count, total_bit_count, abort_packet_count);
999
1000 /* set BER counting range */
1001 ret = af9013_write_reg(state, 0xd385, 10000 & 0xff);
1002 if (ret)
1003 goto error;
1004 ret = af9013_write_reg(state, 0xd386, 10000 >> 8);
1005 if (ret)
1006 goto error;
1007 /* reset and start BER counter */
1008 ret = af9013_write_reg_bits(state, 0xd391, 4, 1, 1);
1009 if (ret)
1010 goto error;
1011
1012 exit:
1013 error:
1014 return ret;
1015 }
1016
1017 static int af9013_update_snr(struct dvb_frontend *fe)
1018 {
1019 struct af9013_state *state = fe->demodulator_priv;
1020 int ret;
1021 u8 buf[3], i, len;
1022 u32 quant = 0;
1023 struct snr_table *uninitialized_var(snr_table);
1024
1025 /* check if quantizer ready (for snr) */
1026 ret = af9013_read_reg_bits(state, 0xd2e1, 3, 1, &buf[0]);
1027 if (ret)
1028 goto error;
1029 if (buf[0]) {
1030 /* quantizer ready - read it */
1031 for (i = 0; i < 3; i++) {
1032 ret = af9013_read_reg(state, 0xd2e3 + i, &buf[i]);
1033 if (ret)
1034 goto error;
1035 }
1036 quant = (buf[2] << 16) + (buf[1] << 8) + buf[0];
1037
1038 /* read current constellation */
1039 ret = af9013_read_reg(state, 0xd3c1, &buf[0]);
1040 if (ret)
1041 goto error;
1042
1043 switch ((buf[0] >> 6) & 3) {
1044 case 0:
1045 len = ARRAY_SIZE(qpsk_snr_table);
1046 snr_table = qpsk_snr_table;
1047 break;
1048 case 1:
1049 len = ARRAY_SIZE(qam16_snr_table);
1050 snr_table = qam16_snr_table;
1051 break;
1052 case 2:
1053 len = ARRAY_SIZE(qam64_snr_table);
1054 snr_table = qam64_snr_table;
1055 break;
1056 default:
1057 len = 0;
1058 break;
1059 }
1060
1061 if (len) {
1062 for (i = 0; i < len; i++) {
1063 if (quant < snr_table[i].val) {
1064 state->snr = snr_table[i].snr * 10;
1065 break;
1066 }
1067 }
1068 }
1069
1070 /* set quantizer super frame count */
1071 ret = af9013_write_reg(state, 0xd2e2, 1);
1072 if (ret)
1073 goto error;
1074
1075 /* check quantizer availability */
1076 for (i = 0; i < 10; i++) {
1077 msleep(10);
1078 ret = af9013_read_reg_bits(state, 0xd2e6, 0, 1,
1079 &buf[0]);
1080 if (ret)
1081 goto error;
1082 if (!buf[0])
1083 break;
1084 }
1085
1086 /* reset quantizer */
1087 ret = af9013_write_reg_bits(state, 0xd2e1, 3, 1, 1);
1088 if (ret)
1089 goto error;
1090 }
1091
1092 error:
1093 return ret;
1094 }
1095
1096 static int af9013_update_signal_strength(struct dvb_frontend *fe)
1097 {
1098 struct af9013_state *state = fe->demodulator_priv;
1099 int ret;
1100 u8 tmp0;
1101 u8 rf_gain, rf_50, rf_80, if_gain, if_50, if_80;
1102 int signal_strength;
1103
1104 deb_info("%s\n", __func__);
1105
1106 state->signal_strength = 0;
1107
1108 ret = af9013_read_reg_bits(state, 0x9bee, 0, 1, &tmp0);
1109 if (ret)
1110 goto error;
1111 if (tmp0) {
1112 ret = af9013_read_reg(state, 0x9bbd, &rf_50);
1113 if (ret)
1114 goto error;
1115 ret = af9013_read_reg(state, 0x9bd0, &rf_80);
1116 if (ret)
1117 goto error;
1118 ret = af9013_read_reg(state, 0x9be2, &if_50);
1119 if (ret)
1120 goto error;
1121 ret = af9013_read_reg(state, 0x9be4, &if_80);
1122 if (ret)
1123 goto error;
1124 ret = af9013_read_reg(state, 0xd07c, &rf_gain);
1125 if (ret)
1126 goto error;
1127 ret = af9013_read_reg(state, 0xd07d, &if_gain);
1128 if (ret)
1129 goto error;
1130 signal_strength = (0xffff / (9 * (rf_50 + if_50) - \
1131 11 * (rf_80 + if_80))) * (10 * (rf_gain + if_gain) - \
1132 11 * (rf_80 + if_80));
1133 if (signal_strength < 0)
1134 signal_strength = 0;
1135 else if (signal_strength > 0xffff)
1136 signal_strength = 0xffff;
1137
1138 state->signal_strength = signal_strength;
1139 }
1140
1141 error:
1142 return ret;
1143 }
1144
1145 static int af9013_update_statistics(struct dvb_frontend *fe)
1146 {
1147 struct af9013_state *state = fe->demodulator_priv;
1148 int ret;
1149
1150 if (time_before(jiffies, state->next_statistics_check))
1151 return 0;
1152
1153 /* set minimum statistic update interval */
1154 state->next_statistics_check = jiffies + msecs_to_jiffies(1200);
1155
1156 ret = af9013_update_signal_strength(fe);
1157 if (ret)
1158 goto error;
1159 ret = af9013_update_snr(fe);
1160 if (ret)
1161 goto error;
1162 ret = af9013_update_ber_unc(fe);
1163 if (ret)
1164 goto error;
1165
1166 error:
1167 return ret;
1168 }
1169
1170 static int af9013_get_tune_settings(struct dvb_frontend *fe,
1171 struct dvb_frontend_tune_settings *fesettings)
1172 {
1173 fesettings->min_delay_ms = 800;
1174 fesettings->step_size = 0;
1175 fesettings->max_drift = 0;
1176
1177 return 0;
1178 }
1179
1180 static int af9013_read_status(struct dvb_frontend *fe, fe_status_t *status)
1181 {
1182 struct af9013_state *state = fe->demodulator_priv;
1183 int ret = 0;
1184 u8 tmp;
1185 *status = 0;
1186
1187 /* MPEG2 lock */
1188 ret = af9013_read_reg_bits(state, 0xd507, 6, 1, &tmp);
1189 if (ret)
1190 goto error;
1191 if (tmp)
1192 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI |
1193 FE_HAS_SYNC | FE_HAS_LOCK;
1194
1195 if (!*status) {
1196 /* TPS lock */
1197 ret = af9013_read_reg_bits(state, 0xd330, 3, 1, &tmp);
1198 if (ret)
1199 goto error;
1200 if (tmp)
1201 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
1202 FE_HAS_VITERBI;
1203 }
1204
1205 if (!*status) {
1206 /* CFO lock */
1207 ret = af9013_read_reg_bits(state, 0xd333, 7, 1, &tmp);
1208 if (ret)
1209 goto error;
1210 if (tmp)
1211 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
1212 }
1213
1214 if (!*status) {
1215 /* SFOE lock */
1216 ret = af9013_read_reg_bits(state, 0xd334, 6, 1, &tmp);
1217 if (ret)
1218 goto error;
1219 if (tmp)
1220 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
1221 }
1222
1223 if (!*status) {
1224 /* AGC lock */
1225 ret = af9013_read_reg_bits(state, 0xd1a0, 6, 1, &tmp);
1226 if (ret)
1227 goto error;
1228 if (tmp)
1229 *status |= FE_HAS_SIGNAL;
1230 }
1231
1232 ret = af9013_update_statistics(fe);
1233
1234 error:
1235 return ret;
1236 }
1237
1238
1239 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber)
1240 {
1241 struct af9013_state *state = fe->demodulator_priv;
1242 int ret;
1243 ret = af9013_update_statistics(fe);
1244 *ber = state->ber;
1245 return ret;
1246 }
1247
1248 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
1249 {
1250 struct af9013_state *state = fe->demodulator_priv;
1251 int ret;
1252 ret = af9013_update_statistics(fe);
1253 *strength = state->signal_strength;
1254 return ret;
1255 }
1256
1257 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr)
1258 {
1259 struct af9013_state *state = fe->demodulator_priv;
1260 int ret;
1261 ret = af9013_update_statistics(fe);
1262 *snr = state->snr;
1263 return ret;
1264 }
1265
1266 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1267 {
1268 struct af9013_state *state = fe->demodulator_priv;
1269 int ret;
1270 ret = af9013_update_statistics(fe);
1271 *ucblocks = state->ucblocks;
1272 return ret;
1273 }
1274
1275 static int af9013_sleep(struct dvb_frontend *fe)
1276 {
1277 struct af9013_state *state = fe->demodulator_priv;
1278 int ret;
1279 deb_info("%s\n", __func__);
1280
1281 ret = af9013_lock_led(state, 0);
1282 if (ret)
1283 goto error;
1284
1285 ret = af9013_power_ctrl(state, 0);
1286 error:
1287 return ret;
1288 }
1289
1290 static int af9013_init(struct dvb_frontend *fe)
1291 {
1292 struct af9013_state *state = fe->demodulator_priv;
1293 int ret, i, len;
1294 u8 tmp0, tmp1;
1295 struct regdesc *init;
1296 deb_info("%s\n", __func__);
1297
1298 /* reset OFDM */
1299 ret = af9013_reset(state, 0);
1300 if (ret)
1301 goto error;
1302
1303 /* power on */
1304 ret = af9013_power_ctrl(state, 1);
1305 if (ret)
1306 goto error;
1307
1308 /* enable ADC */
1309 ret = af9013_write_reg(state, 0xd73a, 0xa4);
1310 if (ret)
1311 goto error;
1312
1313 /* write API version to firmware */
1314 for (i = 0; i < sizeof(state->config.api_version); i++) {
1315 ret = af9013_write_reg(state, 0x9bf2 + i,
1316 state->config.api_version[i]);
1317 if (ret)
1318 goto error;
1319 }
1320
1321 /* program ADC control */
1322 ret = af9013_set_adc_ctrl(state);
1323 if (ret)
1324 goto error;
1325
1326 /* set I2C master clock */
1327 ret = af9013_write_reg(state, 0xd416, 0x14);
1328 if (ret)
1329 goto error;
1330
1331 /* set 16 embx */
1332 ret = af9013_write_reg_bits(state, 0xd700, 1, 1, 1);
1333 if (ret)
1334 goto error;
1335
1336 /* set no trigger */
1337 ret = af9013_write_reg_bits(state, 0xd700, 2, 1, 0);
1338 if (ret)
1339 goto error;
1340
1341 /* set read-update bit for constellation */
1342 ret = af9013_write_reg_bits(state, 0xd371, 1, 1, 1);
1343 if (ret)
1344 goto error;
1345
1346 /* enable FEC monitor */
1347 ret = af9013_write_reg_bits(state, 0xd392, 1, 1, 1);
1348 if (ret)
1349 goto error;
1350
1351 /* load OFSM settings */
1352 deb_info("%s: load ofsm settings\n", __func__);
1353 len = ARRAY_SIZE(ofsm_init);
1354 init = ofsm_init;
1355 for (i = 0; i < len; i++) {
1356 ret = af9013_write_reg_bits(state, init[i].addr, init[i].pos,
1357 init[i].len, init[i].val);
1358 if (ret)
1359 goto error;
1360 }
1361
1362 /* load tuner specific settings */
1363 deb_info("%s: load tuner specific settings\n", __func__);
1364 switch (state->config.tuner) {
1365 case AF9013_TUNER_MXL5003D:
1366 len = ARRAY_SIZE(tuner_init_mxl5003d);
1367 init = tuner_init_mxl5003d;
1368 break;
1369 case AF9013_TUNER_MXL5005D:
1370 case AF9013_TUNER_MXL5005R:
1371 len = ARRAY_SIZE(tuner_init_mxl5005);
1372 init = tuner_init_mxl5005;
1373 break;
1374 case AF9013_TUNER_ENV77H11D5:
1375 len = ARRAY_SIZE(tuner_init_env77h11d5);
1376 init = tuner_init_env77h11d5;
1377 break;
1378 case AF9013_TUNER_MT2060:
1379 len = ARRAY_SIZE(tuner_init_mt2060);
1380 init = tuner_init_mt2060;
1381 break;
1382 case AF9013_TUNER_MC44S803:
1383 len = ARRAY_SIZE(tuner_init_mc44s803);
1384 init = tuner_init_mc44s803;
1385 break;
1386 case AF9013_TUNER_QT1010:
1387 case AF9013_TUNER_QT1010A:
1388 len = ARRAY_SIZE(tuner_init_qt1010);
1389 init = tuner_init_qt1010;
1390 break;
1391 case AF9013_TUNER_MT2060_2:
1392 len = ARRAY_SIZE(tuner_init_mt2060_2);
1393 init = tuner_init_mt2060_2;
1394 break;
1395 case AF9013_TUNER_TDA18271:
1396 len = ARRAY_SIZE(tuner_init_tda18271);
1397 init = tuner_init_tda18271;
1398 break;
1399 case AF9013_TUNER_UNKNOWN:
1400 default:
1401 len = ARRAY_SIZE(tuner_init_unknown);
1402 init = tuner_init_unknown;
1403 break;
1404 }
1405
1406 for (i = 0; i < len; i++) {
1407 ret = af9013_write_reg_bits(state, init[i].addr, init[i].pos,
1408 init[i].len, init[i].val);
1409 if (ret)
1410 goto error;
1411 }
1412
1413 /* set TS mode */
1414 deb_info("%s: setting ts mode\n", __func__);
1415 tmp0 = 0; /* parallel mode */
1416 tmp1 = 0; /* serial mode */
1417 switch (state->config.output_mode) {
1418 case AF9013_OUTPUT_MODE_PARALLEL:
1419 tmp0 = 1;
1420 break;
1421 case AF9013_OUTPUT_MODE_SERIAL:
1422 tmp1 = 1;
1423 break;
1424 case AF9013_OUTPUT_MODE_USB:
1425 /* usb mode for AF9015 */
1426 default:
1427 break;
1428 }
1429 ret = af9013_write_reg_bits(state, 0xd500, 1, 1, tmp0); /* parallel */
1430 if (ret)
1431 goto error;
1432 ret = af9013_write_reg_bits(state, 0xd500, 2, 1, tmp1); /* serial */
1433 if (ret)
1434 goto error;
1435
1436 /* enable lock led */
1437 ret = af9013_lock_led(state, 1);
1438 if (ret)
1439 goto error;
1440
1441 error:
1442 return ret;
1443 }
1444
1445 static struct dvb_frontend_ops af9013_ops;
1446
1447 static int af9013_download_firmware(struct af9013_state *state)
1448 {
1449 int i, len, packets, remainder, ret;
1450 const struct firmware *fw;
1451 u16 addr = 0x5100; /* firmware start address */
1452 u16 checksum = 0;
1453 u8 val;
1454 u8 fw_params[4];
1455 u8 *data;
1456 u8 *fw_file = AF9013_DEFAULT_FIRMWARE;
1457
1458 msleep(100);
1459 /* check whether firmware is already running */
1460 ret = af9013_read_reg(state, 0x98be, &val);
1461 if (ret)
1462 goto error;
1463 else
1464 deb_info("%s: firmware status:%02x\n", __func__, val);
1465
1466 if (val == 0x0c) /* fw is running, no need for download */
1467 goto exit;
1468
1469 info("found a '%s' in cold state, will try to load a firmware",
1470 af9013_ops.info.name);
1471
1472 /* request the firmware, this will block and timeout */
1473 ret = request_firmware(&fw, fw_file, state->i2c->dev.parent);
1474 if (ret) {
1475 err("did not find the firmware file. (%s) "
1476 "Please see linux/Documentation/dvb/ for more details" \
1477 " on firmware-problems. (%d)",
1478 fw_file, ret);
1479 goto error;
1480 }
1481
1482 info("downloading firmware from file '%s'", fw_file);
1483
1484 /* calc checksum */
1485 for (i = 0; i < fw->size; i++)
1486 checksum += fw->data[i];
1487
1488 fw_params[0] = checksum >> 8;
1489 fw_params[1] = checksum & 0xff;
1490 fw_params[2] = fw->size >> 8;
1491 fw_params[3] = fw->size & 0xff;
1492
1493 /* write fw checksum & size */
1494 ret = af9013_write_ofsm_regs(state, 0x50fc,
1495 fw_params, sizeof(fw_params));
1496 if (ret)
1497 goto error_release;
1498
1499 #define FW_PACKET_MAX_DATA 16
1500
1501 packets = fw->size / FW_PACKET_MAX_DATA;
1502 remainder = fw->size % FW_PACKET_MAX_DATA;
1503 len = FW_PACKET_MAX_DATA;
1504 for (i = 0; i <= packets; i++) {
1505 if (i == packets) /* set size of the last packet */
1506 len = remainder;
1507
1508 data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
1509 ret = af9013_write_ofsm_regs(state, addr, data, len);
1510 addr += FW_PACKET_MAX_DATA;
1511
1512 if (ret) {
1513 err("firmware download failed at %d with %d", i, ret);
1514 goto error_release;
1515 }
1516 }
1517
1518 /* request boot firmware */
1519 ret = af9013_write_reg(state, 0xe205, 1);
1520 if (ret)
1521 goto error_release;
1522
1523 for (i = 0; i < 15; i++) {
1524 msleep(100);
1525
1526 /* check firmware status */
1527 ret = af9013_read_reg(state, 0x98be, &val);
1528 if (ret)
1529 goto error_release;
1530
1531 deb_info("%s: firmware status:%02x\n", __func__, val);
1532
1533 if (val == 0x0c || val == 0x04) /* success or fail */
1534 break;
1535 }
1536
1537 if (val == 0x04) {
1538 err("firmware did not run");
1539 ret = -1;
1540 } else if (val != 0x0c) {
1541 err("firmware boot timeout");
1542 ret = -1;
1543 }
1544
1545 error_release:
1546 release_firmware(fw);
1547 error:
1548 exit:
1549 if (!ret)
1550 info("found a '%s' in warm state.", af9013_ops.info.name);
1551 return ret;
1552 }
1553
1554 static int af9013_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
1555 {
1556 int ret;
1557 struct af9013_state *state = fe->demodulator_priv;
1558 deb_info("%s: enable:%d\n", __func__, enable);
1559
1560 if (state->config.output_mode == AF9013_OUTPUT_MODE_USB)
1561 ret = af9013_write_reg_bits(state, 0xd417, 3, 1, enable);
1562 else
1563 ret = af9013_write_reg_bits(state, 0xd607, 2, 1, enable);
1564
1565 return ret;
1566 }
1567
1568 static void af9013_release(struct dvb_frontend *fe)
1569 {
1570 struct af9013_state *state = fe->demodulator_priv;
1571 kfree(state);
1572 }
1573
1574 static struct dvb_frontend_ops af9013_ops;
1575
1576 struct dvb_frontend *af9013_attach(const struct af9013_config *config,
1577 struct i2c_adapter *i2c)
1578 {
1579 int ret;
1580 struct af9013_state *state = NULL;
1581 u8 buf[4], i;
1582
1583 /* allocate memory for the internal state */
1584 state = kzalloc(sizeof(struct af9013_state), GFP_KERNEL);
1585 if (state == NULL)
1586 goto error;
1587
1588 /* setup the state */
1589 state->i2c = i2c;
1590 memcpy(&state->config, config, sizeof(struct af9013_config));
1591
1592 /* chip version */
1593 ret = af9013_read_reg_bits(state, 0xd733, 4, 4, &buf[2]);
1594 if (ret)
1595 goto error;
1596
1597 /* ROM version */
1598 for (i = 0; i < 2; i++) {
1599 ret = af9013_read_reg(state, 0x116b + i, &buf[i]);
1600 if (ret)
1601 goto error;
1602 }
1603 deb_info("%s: chip version:%d ROM version:%d.%d\n", __func__,
1604 buf[2], buf[0], buf[1]);
1605
1606 /* download firmware */
1607 if (state->config.output_mode != AF9013_OUTPUT_MODE_USB) {
1608 ret = af9013_download_firmware(state);
1609 if (ret)
1610 goto error;
1611 }
1612
1613 /* firmware version */
1614 for (i = 0; i < 4; i++) {
1615 ret = af9013_read_reg(state, 0x5103 + i, &buf[i]);
1616 if (ret)
1617 goto error;
1618 }
1619 info("firmware version:%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3]);
1620
1621 /* settings for mp2if */
1622 if (state->config.output_mode == AF9013_OUTPUT_MODE_USB) {
1623 /* AF9015 split PSB to 1.5k + 0.5k */
1624 ret = af9013_write_reg_bits(state, 0xd50b, 2, 1, 1);
1625 } else {
1626 /* AF9013 change the output bit to data7 */
1627 ret = af9013_write_reg_bits(state, 0xd500, 3, 1, 1);
1628 if (ret)
1629 goto error;
1630 /* AF9013 set mpeg to full speed */
1631 ret = af9013_write_reg_bits(state, 0xd502, 4, 1, 1);
1632 }
1633 if (ret)
1634 goto error;
1635 ret = af9013_write_reg_bits(state, 0xd520, 4, 1, 1);
1636 if (ret)
1637 goto error;
1638
1639 /* set GPIOs */
1640 for (i = 0; i < sizeof(state->config.gpio); i++) {
1641 ret = af9013_set_gpio(state, i, state->config.gpio[i]);
1642 if (ret)
1643 goto error;
1644 }
1645
1646 /* create dvb_frontend */
1647 memcpy(&state->frontend.ops, &af9013_ops,
1648 sizeof(struct dvb_frontend_ops));
1649 state->frontend.demodulator_priv = state;
1650
1651 return &state->frontend;
1652 error:
1653 kfree(state);
1654 return NULL;
1655 }
1656 EXPORT_SYMBOL(af9013_attach);
1657
1658 static struct dvb_frontend_ops af9013_ops = {
1659 .info = {
1660 .name = "Afatech AF9013 DVB-T",
1661 .type = FE_OFDM,
1662 .frequency_min = 174000000,
1663 .frequency_max = 862000000,
1664 .frequency_stepsize = 250000,
1665 .frequency_tolerance = 0,
1666 .caps =
1667 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1668 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1669 FE_CAN_QPSK | FE_CAN_QAM_16 |
1670 FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
1671 FE_CAN_TRANSMISSION_MODE_AUTO |
1672 FE_CAN_GUARD_INTERVAL_AUTO |
1673 FE_CAN_HIERARCHY_AUTO |
1674 FE_CAN_RECOVER |
1675 FE_CAN_MUTE_TS
1676 },
1677
1678 .release = af9013_release,
1679 .init = af9013_init,
1680 .sleep = af9013_sleep,
1681 .i2c_gate_ctrl = af9013_i2c_gate_ctrl,
1682
1683 .set_frontend = af9013_set_frontend,
1684 .get_frontend = af9013_get_frontend,
1685
1686 .get_tune_settings = af9013_get_tune_settings,
1687
1688 .read_status = af9013_read_status,
1689 .read_ber = af9013_read_ber,
1690 .read_signal_strength = af9013_read_signal_strength,
1691 .read_snr = af9013_read_snr,
1692 .read_ucblocks = af9013_read_ucblocks,
1693 };
1694
1695 module_param_named(debug, af9013_debug, int, 0644);
1696 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
1697
1698 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1699 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver");
1700 MODULE_LICENSE("GPL");
Tomato firmware and modifications.