]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/dvb/frontends/af9013.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[mirror_ubuntu-artful-kernel.git] / drivers / media / dvb / frontends / af9013.c
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, &params->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");
Ubuntu Artful kernel mirror