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