]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/dvb-frontends/drxk_hard.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'asoc/fix/si476x' into asoc-next
[mirror_ubuntu-artful-kernel.git] / drivers / media / dvb-frontends / drxk_hard.c
1 /*
2 * drxk_hard: DRX-K DVB-C/T demodulator driver
3 *
4 * Copyright (C) 2010-2011 Digital Devices GmbH
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 only, as published by the Free Software Foundation.
9 *
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA
21 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
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/firmware.h>
30 #include <linux/i2c.h>
31 #include <linux/hardirq.h>
32 #include <asm/div64.h>
33
34 #include "dvb_frontend.h"
35 #include "drxk.h"
36 #include "drxk_hard.h"
37
38 static int PowerDownDVBT(struct drxk_state *state, bool setPowerMode);
39 static int PowerDownQAM(struct drxk_state *state);
40 static int SetDVBTStandard(struct drxk_state *state,
41 enum OperationMode oMode);
42 static int SetQAMStandard(struct drxk_state *state,
43 enum OperationMode oMode);
44 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
45 s32 tunerFreqOffset);
46 static int SetDVBTStandard(struct drxk_state *state,
47 enum OperationMode oMode);
48 static int DVBTStart(struct drxk_state *state);
49 static int SetDVBT(struct drxk_state *state, u16 IntermediateFreqkHz,
50 s32 tunerFreqOffset);
51 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus);
52 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus);
53 static int SwitchAntennaToQAM(struct drxk_state *state);
54 static int SwitchAntennaToDVBT(struct drxk_state *state);
55
56 static bool IsDVBT(struct drxk_state *state)
57 {
58 return state->m_OperationMode == OM_DVBT;
59 }
60
61 static bool IsQAM(struct drxk_state *state)
62 {
63 return state->m_OperationMode == OM_QAM_ITU_A ||
64 state->m_OperationMode == OM_QAM_ITU_B ||
65 state->m_OperationMode == OM_QAM_ITU_C;
66 }
67
68 #define NOA1ROM 0
69
70 #define DRXDAP_FASI_SHORT_FORMAT(addr) (((addr) & 0xFC30FF80) == 0)
71 #define DRXDAP_FASI_LONG_FORMAT(addr) (((addr) & 0xFC30FF80) != 0)
72
73 #define DEFAULT_MER_83 165
74 #define DEFAULT_MER_93 250
75
76 #ifndef DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH
77 #define DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH (0x02)
78 #endif
79
80 #ifndef DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH
81 #define DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH (0x03)
82 #endif
83
84 #define DEFAULT_DRXK_MPEG_LOCK_TIMEOUT 700
85 #define DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT 500
86
87 #ifndef DRXK_KI_RAGC_ATV
88 #define DRXK_KI_RAGC_ATV 4
89 #endif
90 #ifndef DRXK_KI_IAGC_ATV
91 #define DRXK_KI_IAGC_ATV 6
92 #endif
93 #ifndef DRXK_KI_DAGC_ATV
94 #define DRXK_KI_DAGC_ATV 7
95 #endif
96
97 #ifndef DRXK_KI_RAGC_QAM
98 #define DRXK_KI_RAGC_QAM 3
99 #endif
100 #ifndef DRXK_KI_IAGC_QAM
101 #define DRXK_KI_IAGC_QAM 4
102 #endif
103 #ifndef DRXK_KI_DAGC_QAM
104 #define DRXK_KI_DAGC_QAM 7
105 #endif
106 #ifndef DRXK_KI_RAGC_DVBT
107 #define DRXK_KI_RAGC_DVBT (IsA1WithPatchCode(state) ? 3 : 2)
108 #endif
109 #ifndef DRXK_KI_IAGC_DVBT
110 #define DRXK_KI_IAGC_DVBT (IsA1WithPatchCode(state) ? 4 : 2)
111 #endif
112 #ifndef DRXK_KI_DAGC_DVBT
113 #define DRXK_KI_DAGC_DVBT (IsA1WithPatchCode(state) ? 10 : 7)
114 #endif
115
116 #ifndef DRXK_AGC_DAC_OFFSET
117 #define DRXK_AGC_DAC_OFFSET (0x800)
118 #endif
119
120 #ifndef DRXK_BANDWIDTH_8MHZ_IN_HZ
121 #define DRXK_BANDWIDTH_8MHZ_IN_HZ (0x8B8249L)
122 #endif
123
124 #ifndef DRXK_BANDWIDTH_7MHZ_IN_HZ
125 #define DRXK_BANDWIDTH_7MHZ_IN_HZ (0x7A1200L)
126 #endif
127
128 #ifndef DRXK_BANDWIDTH_6MHZ_IN_HZ
129 #define DRXK_BANDWIDTH_6MHZ_IN_HZ (0x68A1B6L)
130 #endif
131
132 #ifndef DRXK_QAM_SYMBOLRATE_MAX
133 #define DRXK_QAM_SYMBOLRATE_MAX (7233000)
134 #endif
135
136 #define DRXK_BL_ROM_OFFSET_TAPS_DVBT 56
137 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_A 64
138 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_C 0x5FE0
139 #define DRXK_BL_ROM_OFFSET_TAPS_BG 24
140 #define DRXK_BL_ROM_OFFSET_TAPS_DKILLP 32
141 #define DRXK_BL_ROM_OFFSET_TAPS_NTSC 40
142 #define DRXK_BL_ROM_OFFSET_TAPS_FM 48
143 #define DRXK_BL_ROM_OFFSET_UCODE 0
144
145 #define DRXK_BLC_TIMEOUT 100
146
147 #define DRXK_BLCC_NR_ELEMENTS_TAPS 2
148 #define DRXK_BLCC_NR_ELEMENTS_UCODE 6
149
150 #define DRXK_BLDC_NR_ELEMENTS_TAPS 28
151
152 #ifndef DRXK_OFDM_NE_NOTCH_WIDTH
153 #define DRXK_OFDM_NE_NOTCH_WIDTH (4)
154 #endif
155
156 #define DRXK_QAM_SL_SIG_POWER_QAM16 (40960)
157 #define DRXK_QAM_SL_SIG_POWER_QAM32 (20480)
158 #define DRXK_QAM_SL_SIG_POWER_QAM64 (43008)
159 #define DRXK_QAM_SL_SIG_POWER_QAM128 (20992)
160 #define DRXK_QAM_SL_SIG_POWER_QAM256 (43520)
161
162 static unsigned int debug;
163 module_param(debug, int, 0644);
164 MODULE_PARM_DESC(debug, "enable debug messages");
165
166 #define dprintk(level, fmt, arg...) do { \
167 if (debug >= level) \
168 printk(KERN_DEBUG "drxk: %s" fmt, __func__, ## arg); \
169 } while (0)
170
171
172 static inline u32 MulDiv32(u32 a, u32 b, u32 c)
173 {
174 u64 tmp64;
175
176 tmp64 = (u64) a * (u64) b;
177 do_div(tmp64, c);
178
179 return (u32) tmp64;
180 }
181
182 static inline u32 Frac28a(u32 a, u32 c)
183 {
184 int i = 0;
185 u32 Q1 = 0;
186 u32 R0 = 0;
187
188 R0 = (a % c) << 4; /* 32-28 == 4 shifts possible at max */
189 Q1 = a / c; /* integer part, only the 4 least significant bits
190 will be visible in the result */
191
192 /* division using radix 16, 7 nibbles in the result */
193 for (i = 0; i < 7; i++) {
194 Q1 = (Q1 << 4) | (R0 / c);
195 R0 = (R0 % c) << 4;
196 }
197 /* rounding */
198 if ((R0 >> 3) >= c)
199 Q1++;
200
201 return Q1;
202 }
203
204 static u32 Log10Times100(u32 x)
205 {
206 static const u8 scale = 15;
207 static const u8 indexWidth = 5;
208 u8 i = 0;
209 u32 y = 0;
210 u32 d = 0;
211 u32 k = 0;
212 u32 r = 0;
213 /*
214 log2lut[n] = (1<<scale) * 200 * log2(1.0 + ((1.0/(1<<INDEXWIDTH)) * n))
215 0 <= n < ((1<<INDEXWIDTH)+1)
216 */
217
218 static const u32 log2lut[] = {
219 0, /* 0.000000 */
220 290941, /* 290941.300628 */
221 573196, /* 573196.476418 */
222 847269, /* 847269.179851 */
223 1113620, /* 1113620.489452 */
224 1372674, /* 1372673.576986 */
225 1624818, /* 1624817.752104 */
226 1870412, /* 1870411.981536 */
227 2109788, /* 2109787.962654 */
228 2343253, /* 2343252.817465 */
229 2571091, /* 2571091.461923 */
230 2793569, /* 2793568.696416 */
231 3010931, /* 3010931.055901 */
232 3223408, /* 3223408.452106 */
233 3431216, /* 3431215.635215 */
234 3634553, /* 3634553.498355 */
235 3833610, /* 3833610.244726 */
236 4028562, /* 4028562.434393 */
237 4219576, /* 4219575.925308 */
238 4406807, /* 4406806.721144 */
239 4590402, /* 4590401.736809 */
240 4770499, /* 4770499.491025 */
241 4947231, /* 4947230.734179 */
242 5120719, /* 5120719.018555 */
243 5291081, /* 5291081.217197 */
244 5458428, /* 5458427.996830 */
245 5622864, /* 5622864.249668 */
246 5784489, /* 5784489.488298 */
247 5943398, /* 5943398.207380 */
248 6099680, /* 6099680.215452 */
249 6253421, /* 6253420.939751 */
250 6404702, /* 6404701.706649 */
251 6553600, /* 6553600.000000 */
252 };
253
254
255 if (x == 0)
256 return 0;
257
258 /* Scale x (normalize) */
259 /* computing y in log(x/y) = log(x) - log(y) */
260 if ((x & ((0xffffffff) << (scale + 1))) == 0) {
261 for (k = scale; k > 0; k--) {
262 if (x & (((u32) 1) << scale))
263 break;
264 x <<= 1;
265 }
266 } else {
267 for (k = scale; k < 31; k++) {
268 if ((x & (((u32) (-1)) << (scale + 1))) == 0)
269 break;
270 x >>= 1;
271 }
272 }
273 /*
274 Now x has binary point between bit[scale] and bit[scale-1]
275 and 1.0 <= x < 2.0 */
276
277 /* correction for divison: log(x) = log(x/y)+log(y) */
278 y = k * ((((u32) 1) << scale) * 200);
279
280 /* remove integer part */
281 x &= ((((u32) 1) << scale) - 1);
282 /* get index */
283 i = (u8) (x >> (scale - indexWidth));
284 /* compute delta (x - a) */
285 d = x & ((((u32) 1) << (scale - indexWidth)) - 1);
286 /* compute log, multiplication (d* (..)) must be within range ! */
287 y += log2lut[i] +
288 ((d * (log2lut[i + 1] - log2lut[i])) >> (scale - indexWidth));
289 /* Conver to log10() */
290 y /= 108853; /* (log2(10) << scale) */
291 r = (y >> 1);
292 /* rounding */
293 if (y & ((u32) 1))
294 r++;
295 return r;
296 }
297
298 /****************************************************************************/
299 /* I2C **********************************************************************/
300 /****************************************************************************/
301
302 static int drxk_i2c_lock(struct drxk_state *state)
303 {
304 i2c_lock_adapter(state->i2c);
305 state->drxk_i2c_exclusive_lock = true;
306
307 return 0;
308 }
309
310 static void drxk_i2c_unlock(struct drxk_state *state)
311 {
312 if (!state->drxk_i2c_exclusive_lock)
313 return;
314
315 i2c_unlock_adapter(state->i2c);
316 state->drxk_i2c_exclusive_lock = false;
317 }
318
319 static int drxk_i2c_transfer(struct drxk_state *state, struct i2c_msg *msgs,
320 unsigned len)
321 {
322 if (state->drxk_i2c_exclusive_lock)
323 return __i2c_transfer(state->i2c, msgs, len);
324 else
325 return i2c_transfer(state->i2c, msgs, len);
326 }
327
328 static int i2c_read1(struct drxk_state *state, u8 adr, u8 *val)
329 {
330 struct i2c_msg msgs[1] = { {.addr = adr, .flags = I2C_M_RD,
331 .buf = val, .len = 1}
332 };
333
334 return drxk_i2c_transfer(state, msgs, 1);
335 }
336
337 static int i2c_write(struct drxk_state *state, u8 adr, u8 *data, int len)
338 {
339 int status;
340 struct i2c_msg msg = {
341 .addr = adr, .flags = 0, .buf = data, .len = len };
342
343 dprintk(3, ":");
344 if (debug > 2) {
345 int i;
346 for (i = 0; i < len; i++)
347 printk(KERN_CONT " %02x", data[i]);
348 printk(KERN_CONT "\n");
349 }
350 status = drxk_i2c_transfer(state, &msg, 1);
351 if (status >= 0 && status != 1)
352 status = -EIO;
353
354 if (status < 0)
355 printk(KERN_ERR "drxk: i2c write error at addr 0x%02x\n", adr);
356
357 return status;
358 }
359
360 static int i2c_read(struct drxk_state *state,
361 u8 adr, u8 *msg, int len, u8 *answ, int alen)
362 {
363 int status;
364 struct i2c_msg msgs[2] = {
365 {.addr = adr, .flags = 0,
366 .buf = msg, .len = len},
367 {.addr = adr, .flags = I2C_M_RD,
368 .buf = answ, .len = alen}
369 };
370
371 status = drxk_i2c_transfer(state, msgs, 2);
372 if (status != 2) {
373 if (debug > 2)
374 printk(KERN_CONT ": ERROR!\n");
375 if (status >= 0)
376 status = -EIO;
377
378 printk(KERN_ERR "drxk: i2c read error at addr 0x%02x\n", adr);
379 return status;
380 }
381 if (debug > 2) {
382 int i;
383 dprintk(2, ": read from");
384 for (i = 0; i < len; i++)
385 printk(KERN_CONT " %02x", msg[i]);
386 printk(KERN_CONT ", value = ");
387 for (i = 0; i < alen; i++)
388 printk(KERN_CONT " %02x", answ[i]);
389 printk(KERN_CONT "\n");
390 }
391 return 0;
392 }
393
394 static int read16_flags(struct drxk_state *state, u32 reg, u16 *data, u8 flags)
395 {
396 int status;
397 u8 adr = state->demod_address, mm1[4], mm2[2], len;
398
399 if (state->single_master)
400 flags |= 0xC0;
401
402 if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
403 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
404 mm1[1] = ((reg >> 16) & 0xFF);
405 mm1[2] = ((reg >> 24) & 0xFF) | flags;
406 mm1[3] = ((reg >> 7) & 0xFF);
407 len = 4;
408 } else {
409 mm1[0] = ((reg << 1) & 0xFF);
410 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
411 len = 2;
412 }
413 dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
414 status = i2c_read(state, adr, mm1, len, mm2, 2);
415 if (status < 0)
416 return status;
417 if (data)
418 *data = mm2[0] | (mm2[1] << 8);
419
420 return 0;
421 }
422
423 static int read16(struct drxk_state *state, u32 reg, u16 *data)
424 {
425 return read16_flags(state, reg, data, 0);
426 }
427
428 static int read32_flags(struct drxk_state *state, u32 reg, u32 *data, u8 flags)
429 {
430 int status;
431 u8 adr = state->demod_address, mm1[4], mm2[4], len;
432
433 if (state->single_master)
434 flags |= 0xC0;
435
436 if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
437 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
438 mm1[1] = ((reg >> 16) & 0xFF);
439 mm1[2] = ((reg >> 24) & 0xFF) | flags;
440 mm1[3] = ((reg >> 7) & 0xFF);
441 len = 4;
442 } else {
443 mm1[0] = ((reg << 1) & 0xFF);
444 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
445 len = 2;
446 }
447 dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
448 status = i2c_read(state, adr, mm1, len, mm2, 4);
449 if (status < 0)
450 return status;
451 if (data)
452 *data = mm2[0] | (mm2[1] << 8) |
453 (mm2[2] << 16) | (mm2[3] << 24);
454
455 return 0;
456 }
457
458 static int read32(struct drxk_state *state, u32 reg, u32 *data)
459 {
460 return read32_flags(state, reg, data, 0);
461 }
462
463 static int write16_flags(struct drxk_state *state, u32 reg, u16 data, u8 flags)
464 {
465 u8 adr = state->demod_address, mm[6], len;
466
467 if (state->single_master)
468 flags |= 0xC0;
469 if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
470 mm[0] = (((reg << 1) & 0xFF) | 0x01);
471 mm[1] = ((reg >> 16) & 0xFF);
472 mm[2] = ((reg >> 24) & 0xFF) | flags;
473 mm[3] = ((reg >> 7) & 0xFF);
474 len = 4;
475 } else {
476 mm[0] = ((reg << 1) & 0xFF);
477 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
478 len = 2;
479 }
480 mm[len] = data & 0xff;
481 mm[len + 1] = (data >> 8) & 0xff;
482
483 dprintk(2, "(0x%08x, 0x%04x, 0x%02x)\n", reg, data, flags);
484 return i2c_write(state, adr, mm, len + 2);
485 }
486
487 static int write16(struct drxk_state *state, u32 reg, u16 data)
488 {
489 return write16_flags(state, reg, data, 0);
490 }
491
492 static int write32_flags(struct drxk_state *state, u32 reg, u32 data, u8 flags)
493 {
494 u8 adr = state->demod_address, mm[8], len;
495
496 if (state->single_master)
497 flags |= 0xC0;
498 if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
499 mm[0] = (((reg << 1) & 0xFF) | 0x01);
500 mm[1] = ((reg >> 16) & 0xFF);
501 mm[2] = ((reg >> 24) & 0xFF) | flags;
502 mm[3] = ((reg >> 7) & 0xFF);
503 len = 4;
504 } else {
505 mm[0] = ((reg << 1) & 0xFF);
506 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
507 len = 2;
508 }
509 mm[len] = data & 0xff;
510 mm[len + 1] = (data >> 8) & 0xff;
511 mm[len + 2] = (data >> 16) & 0xff;
512 mm[len + 3] = (data >> 24) & 0xff;
513 dprintk(2, "(0x%08x, 0x%08x, 0x%02x)\n", reg, data, flags);
514
515 return i2c_write(state, adr, mm, len + 4);
516 }
517
518 static int write32(struct drxk_state *state, u32 reg, u32 data)
519 {
520 return write32_flags(state, reg, data, 0);
521 }
522
523 static int write_block(struct drxk_state *state, u32 Address,
524 const int BlockSize, const u8 pBlock[])
525 {
526 int status = 0, BlkSize = BlockSize;
527 u8 Flags = 0;
528
529 if (state->single_master)
530 Flags |= 0xC0;
531
532 while (BlkSize > 0) {
533 int Chunk = BlkSize > state->m_ChunkSize ?
534 state->m_ChunkSize : BlkSize;
535 u8 *AdrBuf = &state->Chunk[0];
536 u32 AdrLength = 0;
537
538 if (DRXDAP_FASI_LONG_FORMAT(Address) || (Flags != 0)) {
539 AdrBuf[0] = (((Address << 1) & 0xFF) | 0x01);
540 AdrBuf[1] = ((Address >> 16) & 0xFF);
541 AdrBuf[2] = ((Address >> 24) & 0xFF);
542 AdrBuf[3] = ((Address >> 7) & 0xFF);
543 AdrBuf[2] |= Flags;
544 AdrLength = 4;
545 if (Chunk == state->m_ChunkSize)
546 Chunk -= 2;
547 } else {
548 AdrBuf[0] = ((Address << 1) & 0xFF);
549 AdrBuf[1] = (((Address >> 16) & 0x0F) |
550 ((Address >> 18) & 0xF0));
551 AdrLength = 2;
552 }
553 memcpy(&state->Chunk[AdrLength], pBlock, Chunk);
554 dprintk(2, "(0x%08x, 0x%02x)\n", Address, Flags);
555 if (debug > 1) {
556 int i;
557 if (pBlock)
558 for (i = 0; i < Chunk; i++)
559 printk(KERN_CONT " %02x", pBlock[i]);
560 printk(KERN_CONT "\n");
561 }
562 status = i2c_write(state, state->demod_address,
563 &state->Chunk[0], Chunk + AdrLength);
564 if (status < 0) {
565 printk(KERN_ERR "drxk: %s: i2c write error at addr 0x%02x\n",
566 __func__, Address);
567 break;
568 }
569 pBlock += Chunk;
570 Address += (Chunk >> 1);
571 BlkSize -= Chunk;
572 }
573 return status;
574 }
575
576 #ifndef DRXK_MAX_RETRIES_POWERUP
577 #define DRXK_MAX_RETRIES_POWERUP 20
578 #endif
579
580 static int PowerUpDevice(struct drxk_state *state)
581 {
582 int status;
583 u8 data = 0;
584 u16 retryCount = 0;
585
586 dprintk(1, "\n");
587
588 status = i2c_read1(state, state->demod_address, &data);
589 if (status < 0) {
590 do {
591 data = 0;
592 status = i2c_write(state, state->demod_address,
593 &data, 1);
594 msleep(10);
595 retryCount++;
596 if (status < 0)
597 continue;
598 status = i2c_read1(state, state->demod_address,
599 &data);
600 } while (status < 0 &&
601 (retryCount < DRXK_MAX_RETRIES_POWERUP));
602 if (status < 0 && retryCount >= DRXK_MAX_RETRIES_POWERUP)
603 goto error;
604 }
605
606 /* Make sure all clk domains are active */
607 status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_NONE);
608 if (status < 0)
609 goto error;
610 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
611 if (status < 0)
612 goto error;
613 /* Enable pll lock tests */
614 status = write16(state, SIO_CC_PLL_LOCK__A, 1);
615 if (status < 0)
616 goto error;
617
618 state->m_currentPowerMode = DRX_POWER_UP;
619
620 error:
621 if (status < 0)
622 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
623
624 return status;
625 }
626
627
628 static int init_state(struct drxk_state *state)
629 {
630 /*
631 * FIXME: most (all?) of the values bellow should be moved into
632 * struct drxk_config, as they are probably board-specific
633 */
634 u32 ulVSBIfAgcMode = DRXK_AGC_CTRL_AUTO;
635 u32 ulVSBIfAgcOutputLevel = 0;
636 u32 ulVSBIfAgcMinLevel = 0;
637 u32 ulVSBIfAgcMaxLevel = 0x7FFF;
638 u32 ulVSBIfAgcSpeed = 3;
639
640 u32 ulVSBRfAgcMode = DRXK_AGC_CTRL_AUTO;
641 u32 ulVSBRfAgcOutputLevel = 0;
642 u32 ulVSBRfAgcMinLevel = 0;
643 u32 ulVSBRfAgcMaxLevel = 0x7FFF;
644 u32 ulVSBRfAgcSpeed = 3;
645 u32 ulVSBRfAgcTop = 9500;
646 u32 ulVSBRfAgcCutOffCurrent = 4000;
647
648 u32 ulATVIfAgcMode = DRXK_AGC_CTRL_AUTO;
649 u32 ulATVIfAgcOutputLevel = 0;
650 u32 ulATVIfAgcMinLevel = 0;
651 u32 ulATVIfAgcMaxLevel = 0;
652 u32 ulATVIfAgcSpeed = 3;
653
654 u32 ulATVRfAgcMode = DRXK_AGC_CTRL_OFF;
655 u32 ulATVRfAgcOutputLevel = 0;
656 u32 ulATVRfAgcMinLevel = 0;
657 u32 ulATVRfAgcMaxLevel = 0;
658 u32 ulATVRfAgcTop = 9500;
659 u32 ulATVRfAgcCutOffCurrent = 4000;
660 u32 ulATVRfAgcSpeed = 3;
661
662 u32 ulQual83 = DEFAULT_MER_83;
663 u32 ulQual93 = DEFAULT_MER_93;
664
665 u32 ulMpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
666 u32 ulDemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
667
668 /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
669 /* io_pad_cfg_mode output mode is drive always */
670 /* io_pad_cfg_drive is set to power 2 (23 mA) */
671 u32 ulGPIOCfg = 0x0113;
672 u32 ulInvertTSClock = 0;
673 u32 ulTSDataStrength = DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH;
674 u32 ulDVBTBitrate = 50000000;
675 u32 ulDVBCBitrate = DRXK_QAM_SYMBOLRATE_MAX * 8;
676
677 u32 ulInsertRSByte = 0;
678
679 u32 ulRfMirror = 1;
680 u32 ulPowerDown = 0;
681
682 dprintk(1, "\n");
683
684 state->m_hasLNA = false;
685 state->m_hasDVBT = false;
686 state->m_hasDVBC = false;
687 state->m_hasATV = false;
688 state->m_hasOOB = false;
689 state->m_hasAudio = false;
690
691 if (!state->m_ChunkSize)
692 state->m_ChunkSize = 124;
693
694 state->m_oscClockFreq = 0;
695 state->m_smartAntInverted = false;
696 state->m_bPDownOpenBridge = false;
697
698 /* real system clock frequency in kHz */
699 state->m_sysClockFreq = 151875;
700 /* Timing div, 250ns/Psys */
701 /* Timing div, = (delay (nano seconds) * sysclk (kHz))/ 1000 */
702 state->m_HICfgTimingDiv = ((state->m_sysClockFreq / 1000) *
703 HI_I2C_DELAY) / 1000;
704 /* Clipping */
705 if (state->m_HICfgTimingDiv > SIO_HI_RA_RAM_PAR_2_CFG_DIV__M)
706 state->m_HICfgTimingDiv = SIO_HI_RA_RAM_PAR_2_CFG_DIV__M;
707 state->m_HICfgWakeUpKey = (state->demod_address << 1);
708 /* port/bridge/power down ctrl */
709 state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
710
711 state->m_bPowerDown = (ulPowerDown != 0);
712
713 state->m_DRXK_A3_PATCH_CODE = false;
714
715 /* Init AGC and PGA parameters */
716 /* VSB IF */
717 state->m_vsbIfAgcCfg.ctrlMode = (ulVSBIfAgcMode);
718 state->m_vsbIfAgcCfg.outputLevel = (ulVSBIfAgcOutputLevel);
719 state->m_vsbIfAgcCfg.minOutputLevel = (ulVSBIfAgcMinLevel);
720 state->m_vsbIfAgcCfg.maxOutputLevel = (ulVSBIfAgcMaxLevel);
721 state->m_vsbIfAgcCfg.speed = (ulVSBIfAgcSpeed);
722 state->m_vsbPgaCfg = 140;
723
724 /* VSB RF */
725 state->m_vsbRfAgcCfg.ctrlMode = (ulVSBRfAgcMode);
726 state->m_vsbRfAgcCfg.outputLevel = (ulVSBRfAgcOutputLevel);
727 state->m_vsbRfAgcCfg.minOutputLevel = (ulVSBRfAgcMinLevel);
728 state->m_vsbRfAgcCfg.maxOutputLevel = (ulVSBRfAgcMaxLevel);
729 state->m_vsbRfAgcCfg.speed = (ulVSBRfAgcSpeed);
730 state->m_vsbRfAgcCfg.top = (ulVSBRfAgcTop);
731 state->m_vsbRfAgcCfg.cutOffCurrent = (ulVSBRfAgcCutOffCurrent);
732 state->m_vsbPreSawCfg.reference = 0x07;
733 state->m_vsbPreSawCfg.usePreSaw = true;
734
735 state->m_Quality83percent = DEFAULT_MER_83;
736 state->m_Quality93percent = DEFAULT_MER_93;
737 if (ulQual93 <= 500 && ulQual83 < ulQual93) {
738 state->m_Quality83percent = ulQual83;
739 state->m_Quality93percent = ulQual93;
740 }
741
742 /* ATV IF */
743 state->m_atvIfAgcCfg.ctrlMode = (ulATVIfAgcMode);
744 state->m_atvIfAgcCfg.outputLevel = (ulATVIfAgcOutputLevel);
745 state->m_atvIfAgcCfg.minOutputLevel = (ulATVIfAgcMinLevel);
746 state->m_atvIfAgcCfg.maxOutputLevel = (ulATVIfAgcMaxLevel);
747 state->m_atvIfAgcCfg.speed = (ulATVIfAgcSpeed);
748
749 /* ATV RF */
750 state->m_atvRfAgcCfg.ctrlMode = (ulATVRfAgcMode);
751 state->m_atvRfAgcCfg.outputLevel = (ulATVRfAgcOutputLevel);
752 state->m_atvRfAgcCfg.minOutputLevel = (ulATVRfAgcMinLevel);
753 state->m_atvRfAgcCfg.maxOutputLevel = (ulATVRfAgcMaxLevel);
754 state->m_atvRfAgcCfg.speed = (ulATVRfAgcSpeed);
755 state->m_atvRfAgcCfg.top = (ulATVRfAgcTop);
756 state->m_atvRfAgcCfg.cutOffCurrent = (ulATVRfAgcCutOffCurrent);
757 state->m_atvPreSawCfg.reference = 0x04;
758 state->m_atvPreSawCfg.usePreSaw = true;
759
760
761 /* DVBT RF */
762 state->m_dvbtRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
763 state->m_dvbtRfAgcCfg.outputLevel = 0;
764 state->m_dvbtRfAgcCfg.minOutputLevel = 0;
765 state->m_dvbtRfAgcCfg.maxOutputLevel = 0xFFFF;
766 state->m_dvbtRfAgcCfg.top = 0x2100;
767 state->m_dvbtRfAgcCfg.cutOffCurrent = 4000;
768 state->m_dvbtRfAgcCfg.speed = 1;
769
770
771 /* DVBT IF */
772 state->m_dvbtIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
773 state->m_dvbtIfAgcCfg.outputLevel = 0;
774 state->m_dvbtIfAgcCfg.minOutputLevel = 0;
775 state->m_dvbtIfAgcCfg.maxOutputLevel = 9000;
776 state->m_dvbtIfAgcCfg.top = 13424;
777 state->m_dvbtIfAgcCfg.cutOffCurrent = 0;
778 state->m_dvbtIfAgcCfg.speed = 3;
779 state->m_dvbtIfAgcCfg.FastClipCtrlDelay = 30;
780 state->m_dvbtIfAgcCfg.IngainTgtMax = 30000;
781 /* state->m_dvbtPgaCfg = 140; */
782
783 state->m_dvbtPreSawCfg.reference = 4;
784 state->m_dvbtPreSawCfg.usePreSaw = false;
785
786 /* QAM RF */
787 state->m_qamRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
788 state->m_qamRfAgcCfg.outputLevel = 0;
789 state->m_qamRfAgcCfg.minOutputLevel = 6023;
790 state->m_qamRfAgcCfg.maxOutputLevel = 27000;
791 state->m_qamRfAgcCfg.top = 0x2380;
792 state->m_qamRfAgcCfg.cutOffCurrent = 4000;
793 state->m_qamRfAgcCfg.speed = 3;
794
795 /* QAM IF */
796 state->m_qamIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
797 state->m_qamIfAgcCfg.outputLevel = 0;
798 state->m_qamIfAgcCfg.minOutputLevel = 0;
799 state->m_qamIfAgcCfg.maxOutputLevel = 9000;
800 state->m_qamIfAgcCfg.top = 0x0511;
801 state->m_qamIfAgcCfg.cutOffCurrent = 0;
802 state->m_qamIfAgcCfg.speed = 3;
803 state->m_qamIfAgcCfg.IngainTgtMax = 5119;
804 state->m_qamIfAgcCfg.FastClipCtrlDelay = 50;
805
806 state->m_qamPgaCfg = 140;
807 state->m_qamPreSawCfg.reference = 4;
808 state->m_qamPreSawCfg.usePreSaw = false;
809
810 state->m_OperationMode = OM_NONE;
811 state->m_DrxkState = DRXK_UNINITIALIZED;
812
813 /* MPEG output configuration */
814 state->m_enableMPEGOutput = true; /* If TRUE; enable MPEG ouput */
815 state->m_insertRSByte = false; /* If TRUE; insert RS byte */
816 state->m_invertDATA = false; /* If TRUE; invert DATA signals */
817 state->m_invertERR = false; /* If TRUE; invert ERR signal */
818 state->m_invertSTR = false; /* If TRUE; invert STR signals */
819 state->m_invertVAL = false; /* If TRUE; invert VAL signals */
820 state->m_invertCLK = (ulInvertTSClock != 0); /* If TRUE; invert CLK signals */
821
822 /* If TRUE; static MPEG clockrate will be used;
823 otherwise clockrate will adapt to the bitrate of the TS */
824
825 state->m_DVBTBitrate = ulDVBTBitrate;
826 state->m_DVBCBitrate = ulDVBCBitrate;
827
828 state->m_TSDataStrength = (ulTSDataStrength & 0x07);
829
830 /* Maximum bitrate in b/s in case static clockrate is selected */
831 state->m_mpegTsStaticBitrate = 19392658;
832 state->m_disableTEIhandling = false;
833
834 if (ulInsertRSByte)
835 state->m_insertRSByte = true;
836
837 state->m_MpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
838 if (ulMpegLockTimeOut < 10000)
839 state->m_MpegLockTimeOut = ulMpegLockTimeOut;
840 state->m_DemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
841 if (ulDemodLockTimeOut < 10000)
842 state->m_DemodLockTimeOut = ulDemodLockTimeOut;
843
844 /* QAM defaults */
845 state->m_Constellation = DRX_CONSTELLATION_AUTO;
846 state->m_qamInterleaveMode = DRXK_QAM_I12_J17;
847 state->m_fecRsPlen = 204 * 8; /* fecRsPlen annex A */
848 state->m_fecRsPrescale = 1;
849
850 state->m_sqiSpeed = DRXK_DVBT_SQI_SPEED_MEDIUM;
851 state->m_agcFastClipCtrlDelay = 0;
852
853 state->m_GPIOCfg = (ulGPIOCfg);
854
855 state->m_bPowerDown = false;
856 state->m_currentPowerMode = DRX_POWER_DOWN;
857
858 state->m_rfmirror = (ulRfMirror == 0);
859 state->m_IfAgcPol = false;
860 return 0;
861 }
862
863 static int DRXX_Open(struct drxk_state *state)
864 {
865 int status = 0;
866 u32 jtag = 0;
867 u16 bid = 0;
868 u16 key = 0;
869
870 dprintk(1, "\n");
871 /* stop lock indicator process */
872 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
873 if (status < 0)
874 goto error;
875 /* Check device id */
876 status = read16(state, SIO_TOP_COMM_KEY__A, &key);
877 if (status < 0)
878 goto error;
879 status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
880 if (status < 0)
881 goto error;
882 status = read32(state, SIO_TOP_JTAGID_LO__A, &jtag);
883 if (status < 0)
884 goto error;
885 status = read16(state, SIO_PDR_UIO_IN_HI__A, &bid);
886 if (status < 0)
887 goto error;
888 status = write16(state, SIO_TOP_COMM_KEY__A, key);
889 error:
890 if (status < 0)
891 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
892 return status;
893 }
894
895 static int GetDeviceCapabilities(struct drxk_state *state)
896 {
897 u16 sioPdrOhwCfg = 0;
898 u32 sioTopJtagidLo = 0;
899 int status;
900 const char *spin = "";
901
902 dprintk(1, "\n");
903
904 /* driver 0.9.0 */
905 /* stop lock indicator process */
906 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
907 if (status < 0)
908 goto error;
909 status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
910 if (status < 0)
911 goto error;
912 status = read16(state, SIO_PDR_OHW_CFG__A, &sioPdrOhwCfg);
913 if (status < 0)
914 goto error;
915 status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
916 if (status < 0)
917 goto error;
918
919 switch ((sioPdrOhwCfg & SIO_PDR_OHW_CFG_FREF_SEL__M)) {
920 case 0:
921 /* ignore (bypass ?) */
922 break;
923 case 1:
924 /* 27 MHz */
925 state->m_oscClockFreq = 27000;
926 break;
927 case 2:
928 /* 20.25 MHz */
929 state->m_oscClockFreq = 20250;
930 break;
931 case 3:
932 /* 4 MHz */
933 state->m_oscClockFreq = 20250;
934 break;
935 default:
936 printk(KERN_ERR "drxk: Clock Frequency is unknown\n");
937 return -EINVAL;
938 }
939 /*
940 Determine device capabilities
941 Based on pinning v14
942 */
943 status = read32(state, SIO_TOP_JTAGID_LO__A, &sioTopJtagidLo);
944 if (status < 0)
945 goto error;
946
947 printk(KERN_INFO "drxk: status = 0x%08x\n", sioTopJtagidLo);
948
949 /* driver 0.9.0 */
950 switch ((sioTopJtagidLo >> 29) & 0xF) {
951 case 0:
952 state->m_deviceSpin = DRXK_SPIN_A1;
953 spin = "A1";
954 break;
955 case 2:
956 state->m_deviceSpin = DRXK_SPIN_A2;
957 spin = "A2";
958 break;
959 case 3:
960 state->m_deviceSpin = DRXK_SPIN_A3;
961 spin = "A3";
962 break;
963 default:
964 state->m_deviceSpin = DRXK_SPIN_UNKNOWN;
965 status = -EINVAL;
966 printk(KERN_ERR "drxk: Spin %d unknown\n",
967 (sioTopJtagidLo >> 29) & 0xF);
968 goto error2;
969 }
970 switch ((sioTopJtagidLo >> 12) & 0xFF) {
971 case 0x13:
972 /* typeId = DRX3913K_TYPE_ID */
973 state->m_hasLNA = false;
974 state->m_hasOOB = false;
975 state->m_hasATV = false;
976 state->m_hasAudio = false;
977 state->m_hasDVBT = true;
978 state->m_hasDVBC = true;
979 state->m_hasSAWSW = true;
980 state->m_hasGPIO2 = false;
981 state->m_hasGPIO1 = false;
982 state->m_hasIRQN = false;
983 break;
984 case 0x15:
985 /* typeId = DRX3915K_TYPE_ID */
986 state->m_hasLNA = false;
987 state->m_hasOOB = false;
988 state->m_hasATV = true;
989 state->m_hasAudio = false;
990 state->m_hasDVBT = true;
991 state->m_hasDVBC = false;
992 state->m_hasSAWSW = true;
993 state->m_hasGPIO2 = true;
994 state->m_hasGPIO1 = true;
995 state->m_hasIRQN = false;
996 break;
997 case 0x16:
998 /* typeId = DRX3916K_TYPE_ID */
999 state->m_hasLNA = false;
1000 state->m_hasOOB = false;
1001 state->m_hasATV = true;
1002 state->m_hasAudio = false;
1003 state->m_hasDVBT = true;
1004 state->m_hasDVBC = false;
1005 state->m_hasSAWSW = true;
1006 state->m_hasGPIO2 = true;
1007 state->m_hasGPIO1 = true;
1008 state->m_hasIRQN = false;
1009 break;
1010 case 0x18:
1011 /* typeId = DRX3918K_TYPE_ID */
1012 state->m_hasLNA = false;
1013 state->m_hasOOB = false;
1014 state->m_hasATV = true;
1015 state->m_hasAudio = true;
1016 state->m_hasDVBT = true;
1017 state->m_hasDVBC = false;
1018 state->m_hasSAWSW = true;
1019 state->m_hasGPIO2 = true;
1020 state->m_hasGPIO1 = true;
1021 state->m_hasIRQN = false;
1022 break;
1023 case 0x21:
1024 /* typeId = DRX3921K_TYPE_ID */
1025 state->m_hasLNA = false;
1026 state->m_hasOOB = false;
1027 state->m_hasATV = true;
1028 state->m_hasAudio = true;
1029 state->m_hasDVBT = true;
1030 state->m_hasDVBC = true;
1031 state->m_hasSAWSW = true;
1032 state->m_hasGPIO2 = true;
1033 state->m_hasGPIO1 = true;
1034 state->m_hasIRQN = false;
1035 break;
1036 case 0x23:
1037 /* typeId = DRX3923K_TYPE_ID */
1038 state->m_hasLNA = false;
1039 state->m_hasOOB = false;
1040 state->m_hasATV = true;
1041 state->m_hasAudio = true;
1042 state->m_hasDVBT = true;
1043 state->m_hasDVBC = true;
1044 state->m_hasSAWSW = true;
1045 state->m_hasGPIO2 = true;
1046 state->m_hasGPIO1 = true;
1047 state->m_hasIRQN = false;
1048 break;
1049 case 0x25:
1050 /* typeId = DRX3925K_TYPE_ID */
1051 state->m_hasLNA = false;
1052 state->m_hasOOB = false;
1053 state->m_hasATV = true;
1054 state->m_hasAudio = true;
1055 state->m_hasDVBT = true;
1056 state->m_hasDVBC = true;
1057 state->m_hasSAWSW = true;
1058 state->m_hasGPIO2 = true;
1059 state->m_hasGPIO1 = true;
1060 state->m_hasIRQN = false;
1061 break;
1062 case 0x26:
1063 /* typeId = DRX3926K_TYPE_ID */
1064 state->m_hasLNA = false;
1065 state->m_hasOOB = false;
1066 state->m_hasATV = true;
1067 state->m_hasAudio = false;
1068 state->m_hasDVBT = true;
1069 state->m_hasDVBC = true;
1070 state->m_hasSAWSW = true;
1071 state->m_hasGPIO2 = true;
1072 state->m_hasGPIO1 = true;
1073 state->m_hasIRQN = false;
1074 break;
1075 default:
1076 printk(KERN_ERR "drxk: DeviceID 0x%02x not supported\n",
1077 ((sioTopJtagidLo >> 12) & 0xFF));
1078 status = -EINVAL;
1079 goto error2;
1080 }
1081
1082 printk(KERN_INFO
1083 "drxk: detected a drx-39%02xk, spin %s, xtal %d.%03d MHz\n",
1084 ((sioTopJtagidLo >> 12) & 0xFF), spin,
1085 state->m_oscClockFreq / 1000,
1086 state->m_oscClockFreq % 1000);
1087
1088 error:
1089 if (status < 0)
1090 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1091
1092 error2:
1093 return status;
1094 }
1095
1096 static int HI_Command(struct drxk_state *state, u16 cmd, u16 *pResult)
1097 {
1098 int status;
1099 bool powerdown_cmd;
1100
1101 dprintk(1, "\n");
1102
1103 /* Write command */
1104 status = write16(state, SIO_HI_RA_RAM_CMD__A, cmd);
1105 if (status < 0)
1106 goto error;
1107 if (cmd == SIO_HI_RA_RAM_CMD_RESET)
1108 msleep(1);
1109
1110 powerdown_cmd =
1111 (bool) ((cmd == SIO_HI_RA_RAM_CMD_CONFIG) &&
1112 ((state->m_HICfgCtrl) &
1113 SIO_HI_RA_RAM_PAR_5_CFG_SLEEP__M) ==
1114 SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ);
1115 if (powerdown_cmd == false) {
1116 /* Wait until command rdy */
1117 u32 retryCount = 0;
1118 u16 waitCmd;
1119
1120 do {
1121 msleep(1);
1122 retryCount += 1;
1123 status = read16(state, SIO_HI_RA_RAM_CMD__A,
1124 &waitCmd);
1125 } while ((status < 0) && (retryCount < DRXK_MAX_RETRIES)
1126 && (waitCmd != 0));
1127 if (status < 0)
1128 goto error;
1129 status = read16(state, SIO_HI_RA_RAM_RES__A, pResult);
1130 }
1131 error:
1132 if (status < 0)
1133 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1134
1135 return status;
1136 }
1137
1138 static int HI_CfgCommand(struct drxk_state *state)
1139 {
1140 int status;
1141
1142 dprintk(1, "\n");
1143
1144 mutex_lock(&state->mutex);
1145
1146 status = write16(state, SIO_HI_RA_RAM_PAR_6__A, state->m_HICfgTimeout);
1147 if (status < 0)
1148 goto error;
1149 status = write16(state, SIO_HI_RA_RAM_PAR_5__A, state->m_HICfgCtrl);
1150 if (status < 0)
1151 goto error;
1152 status = write16(state, SIO_HI_RA_RAM_PAR_4__A, state->m_HICfgWakeUpKey);
1153 if (status < 0)
1154 goto error;
1155 status = write16(state, SIO_HI_RA_RAM_PAR_3__A, state->m_HICfgBridgeDelay);
1156 if (status < 0)
1157 goto error;
1158 status = write16(state, SIO_HI_RA_RAM_PAR_2__A, state->m_HICfgTimingDiv);
1159 if (status < 0)
1160 goto error;
1161 status = write16(state, SIO_HI_RA_RAM_PAR_1__A, SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY);
1162 if (status < 0)
1163 goto error;
1164 status = HI_Command(state, SIO_HI_RA_RAM_CMD_CONFIG, 0);
1165 if (status < 0)
1166 goto error;
1167
1168 state->m_HICfgCtrl &= ~SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
1169 error:
1170 mutex_unlock(&state->mutex);
1171 if (status < 0)
1172 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1173 return status;
1174 }
1175
1176 static int InitHI(struct drxk_state *state)
1177 {
1178 dprintk(1, "\n");
1179
1180 state->m_HICfgWakeUpKey = (state->demod_address << 1);
1181 state->m_HICfgTimeout = 0x96FF;
1182 /* port/bridge/power down ctrl */
1183 state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
1184
1185 return HI_CfgCommand(state);
1186 }
1187
1188 static int MPEGTSConfigurePins(struct drxk_state *state, bool mpegEnable)
1189 {
1190 int status = -1;
1191 u16 sioPdrMclkCfg = 0;
1192 u16 sioPdrMdxCfg = 0;
1193 u16 err_cfg = 0;
1194
1195 dprintk(1, ": mpeg %s, %s mode\n",
1196 mpegEnable ? "enable" : "disable",
1197 state->m_enableParallel ? "parallel" : "serial");
1198
1199 /* stop lock indicator process */
1200 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
1201 if (status < 0)
1202 goto error;
1203
1204 /* MPEG TS pad configuration */
1205 status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
1206 if (status < 0)
1207 goto error;
1208
1209 if (mpegEnable == false) {
1210 /* Set MPEG TS pads to inputmode */
1211 status = write16(state, SIO_PDR_MSTRT_CFG__A, 0x0000);
1212 if (status < 0)
1213 goto error;
1214 status = write16(state, SIO_PDR_MERR_CFG__A, 0x0000);
1215 if (status < 0)
1216 goto error;
1217 status = write16(state, SIO_PDR_MCLK_CFG__A, 0x0000);
1218 if (status < 0)
1219 goto error;
1220 status = write16(state, SIO_PDR_MVAL_CFG__A, 0x0000);
1221 if (status < 0)
1222 goto error;
1223 status = write16(state, SIO_PDR_MD0_CFG__A, 0x0000);
1224 if (status < 0)
1225 goto error;
1226 status = write16(state, SIO_PDR_MD1_CFG__A, 0x0000);
1227 if (status < 0)
1228 goto error;
1229 status = write16(state, SIO_PDR_MD2_CFG__A, 0x0000);
1230 if (status < 0)
1231 goto error;
1232 status = write16(state, SIO_PDR_MD3_CFG__A, 0x0000);
1233 if (status < 0)
1234 goto error;
1235 status = write16(state, SIO_PDR_MD4_CFG__A, 0x0000);
1236 if (status < 0)
1237 goto error;
1238 status = write16(state, SIO_PDR_MD5_CFG__A, 0x0000);
1239 if (status < 0)
1240 goto error;
1241 status = write16(state, SIO_PDR_MD6_CFG__A, 0x0000);
1242 if (status < 0)
1243 goto error;
1244 status = write16(state, SIO_PDR_MD7_CFG__A, 0x0000);
1245 if (status < 0)
1246 goto error;
1247 } else {
1248 /* Enable MPEG output */
1249 sioPdrMdxCfg =
1250 ((state->m_TSDataStrength <<
1251 SIO_PDR_MD0_CFG_DRIVE__B) | 0x0003);
1252 sioPdrMclkCfg = ((state->m_TSClockkStrength <<
1253 SIO_PDR_MCLK_CFG_DRIVE__B) |
1254 0x0003);
1255
1256 status = write16(state, SIO_PDR_MSTRT_CFG__A, sioPdrMdxCfg);
1257 if (status < 0)
1258 goto error;
1259
1260 if (state->enable_merr_cfg)
1261 err_cfg = sioPdrMdxCfg;
1262
1263 status = write16(state, SIO_PDR_MERR_CFG__A, err_cfg);
1264 if (status < 0)
1265 goto error;
1266 status = write16(state, SIO_PDR_MVAL_CFG__A, err_cfg);
1267 if (status < 0)
1268 goto error;
1269
1270 if (state->m_enableParallel == true) {
1271 /* paralel -> enable MD1 to MD7 */
1272 status = write16(state, SIO_PDR_MD1_CFG__A, sioPdrMdxCfg);
1273 if (status < 0)
1274 goto error;
1275 status = write16(state, SIO_PDR_MD2_CFG__A, sioPdrMdxCfg);
1276 if (status < 0)
1277 goto error;
1278 status = write16(state, SIO_PDR_MD3_CFG__A, sioPdrMdxCfg);
1279 if (status < 0)
1280 goto error;
1281 status = write16(state, SIO_PDR_MD4_CFG__A, sioPdrMdxCfg);
1282 if (status < 0)
1283 goto error;
1284 status = write16(state, SIO_PDR_MD5_CFG__A, sioPdrMdxCfg);
1285 if (status < 0)
1286 goto error;
1287 status = write16(state, SIO_PDR_MD6_CFG__A, sioPdrMdxCfg);
1288 if (status < 0)
1289 goto error;
1290 status = write16(state, SIO_PDR_MD7_CFG__A, sioPdrMdxCfg);
1291 if (status < 0)
1292 goto error;
1293 } else {
1294 sioPdrMdxCfg = ((state->m_TSDataStrength <<
1295 SIO_PDR_MD0_CFG_DRIVE__B)
1296 | 0x0003);
1297 /* serial -> disable MD1 to MD7 */
1298 status = write16(state, SIO_PDR_MD1_CFG__A, 0x0000);
1299 if (status < 0)
1300 goto error;
1301 status = write16(state, SIO_PDR_MD2_CFG__A, 0x0000);
1302 if (status < 0)
1303 goto error;
1304 status = write16(state, SIO_PDR_MD3_CFG__A, 0x0000);
1305 if (status < 0)
1306 goto error;
1307 status = write16(state, SIO_PDR_MD4_CFG__A, 0x0000);
1308 if (status < 0)
1309 goto error;
1310 status = write16(state, SIO_PDR_MD5_CFG__A, 0x0000);
1311 if (status < 0)
1312 goto error;
1313 status = write16(state, SIO_PDR_MD6_CFG__A, 0x0000);
1314 if (status < 0)
1315 goto error;
1316 status = write16(state, SIO_PDR_MD7_CFG__A, 0x0000);
1317 if (status < 0)
1318 goto error;
1319 }
1320 status = write16(state, SIO_PDR_MCLK_CFG__A, sioPdrMclkCfg);
1321 if (status < 0)
1322 goto error;
1323 status = write16(state, SIO_PDR_MD0_CFG__A, sioPdrMdxCfg);
1324 if (status < 0)
1325 goto error;
1326 }
1327 /* Enable MB output over MPEG pads and ctl input */
1328 status = write16(state, SIO_PDR_MON_CFG__A, 0x0000);
1329 if (status < 0)
1330 goto error;
1331 /* Write nomagic word to enable pdr reg write */
1332 status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
1333 error:
1334 if (status < 0)
1335 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1336 return status;
1337 }
1338
1339 static int MPEGTSDisable(struct drxk_state *state)
1340 {
1341 dprintk(1, "\n");
1342
1343 return MPEGTSConfigurePins(state, false);
1344 }
1345
1346 static int BLChainCmd(struct drxk_state *state,
1347 u16 romOffset, u16 nrOfElements, u32 timeOut)
1348 {
1349 u16 blStatus = 0;
1350 int status;
1351 unsigned long end;
1352
1353 dprintk(1, "\n");
1354 mutex_lock(&state->mutex);
1355 status = write16(state, SIO_BL_MODE__A, SIO_BL_MODE_CHAIN);
1356 if (status < 0)
1357 goto error;
1358 status = write16(state, SIO_BL_CHAIN_ADDR__A, romOffset);
1359 if (status < 0)
1360 goto error;
1361 status = write16(state, SIO_BL_CHAIN_LEN__A, nrOfElements);
1362 if (status < 0)
1363 goto error;
1364 status = write16(state, SIO_BL_ENABLE__A, SIO_BL_ENABLE_ON);
1365 if (status < 0)
1366 goto error;
1367
1368 end = jiffies + msecs_to_jiffies(timeOut);
1369 do {
1370 msleep(1);
1371 status = read16(state, SIO_BL_STATUS__A, &blStatus);
1372 if (status < 0)
1373 goto error;
1374 } while ((blStatus == 0x1) &&
1375 ((time_is_after_jiffies(end))));
1376
1377 if (blStatus == 0x1) {
1378 printk(KERN_ERR "drxk: SIO not ready\n");
1379 status = -EINVAL;
1380 goto error2;
1381 }
1382 error:
1383 if (status < 0)
1384 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1385 error2:
1386 mutex_unlock(&state->mutex);
1387 return status;
1388 }
1389
1390
1391 static int DownloadMicrocode(struct drxk_state *state,
1392 const u8 pMCImage[], u32 Length)
1393 {
1394 const u8 *pSrc = pMCImage;
1395 u32 Address;
1396 u16 nBlocks;
1397 u16 BlockSize;
1398 u32 offset = 0;
1399 u32 i;
1400 int status = 0;
1401
1402 dprintk(1, "\n");
1403
1404 /* down the drain (we don't care about MAGIC_WORD) */
1405 #if 0
1406 /* For future reference */
1407 Drain = (pSrc[0] << 8) | pSrc[1];
1408 #endif
1409 pSrc += sizeof(u16);
1410 offset += sizeof(u16);
1411 nBlocks = (pSrc[0] << 8) | pSrc[1];
1412 pSrc += sizeof(u16);
1413 offset += sizeof(u16);
1414
1415 for (i = 0; i < nBlocks; i += 1) {
1416 Address = (pSrc[0] << 24) | (pSrc[1] << 16) |
1417 (pSrc[2] << 8) | pSrc[3];
1418 pSrc += sizeof(u32);
1419 offset += sizeof(u32);
1420
1421 BlockSize = ((pSrc[0] << 8) | pSrc[1]) * sizeof(u16);
1422 pSrc += sizeof(u16);
1423 offset += sizeof(u16);
1424
1425 #if 0
1426 /* For future reference */
1427 Flags = (pSrc[0] << 8) | pSrc[1];
1428 #endif
1429 pSrc += sizeof(u16);
1430 offset += sizeof(u16);
1431
1432 #if 0
1433 /* For future reference */
1434 BlockCRC = (pSrc[0] << 8) | pSrc[1];
1435 #endif
1436 pSrc += sizeof(u16);
1437 offset += sizeof(u16);
1438
1439 if (offset + BlockSize > Length) {
1440 printk(KERN_ERR "drxk: Firmware is corrupted.\n");
1441 return -EINVAL;
1442 }
1443
1444 status = write_block(state, Address, BlockSize, pSrc);
1445 if (status < 0) {
1446 printk(KERN_ERR "drxk: Error %d while loading firmware\n", status);
1447 break;
1448 }
1449 pSrc += BlockSize;
1450 offset += BlockSize;
1451 }
1452 return status;
1453 }
1454
1455 static int DVBTEnableOFDMTokenRing(struct drxk_state *state, bool enable)
1456 {
1457 int status;
1458 u16 data = 0;
1459 u16 desiredCtrl = SIO_OFDM_SH_OFDM_RING_ENABLE_ON;
1460 u16 desiredStatus = SIO_OFDM_SH_OFDM_RING_STATUS_ENABLED;
1461 unsigned long end;
1462
1463 dprintk(1, "\n");
1464
1465 if (enable == false) {
1466 desiredCtrl = SIO_OFDM_SH_OFDM_RING_ENABLE_OFF;
1467 desiredStatus = SIO_OFDM_SH_OFDM_RING_STATUS_DOWN;
1468 }
1469
1470 status = read16(state, SIO_OFDM_SH_OFDM_RING_STATUS__A, &data);
1471 if (status >= 0 && data == desiredStatus) {
1472 /* tokenring already has correct status */
1473 return status;
1474 }
1475 /* Disable/enable dvbt tokenring bridge */
1476 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, desiredCtrl);
1477
1478 end = jiffies + msecs_to_jiffies(DRXK_OFDM_TR_SHUTDOWN_TIMEOUT);
1479 do {
1480 status = read16(state, SIO_OFDM_SH_OFDM_RING_STATUS__A, &data);
1481 if ((status >= 0 && data == desiredStatus) || time_is_after_jiffies(end))
1482 break;
1483 msleep(1);
1484 } while (1);
1485 if (data != desiredStatus) {
1486 printk(KERN_ERR "drxk: SIO not ready\n");
1487 return -EINVAL;
1488 }
1489 return status;
1490 }
1491
1492 static int MPEGTSStop(struct drxk_state *state)
1493 {
1494 int status = 0;
1495 u16 fecOcSncMode = 0;
1496 u16 fecOcIprMode = 0;
1497
1498 dprintk(1, "\n");
1499
1500 /* Gracefull shutdown (byte boundaries) */
1501 status = read16(state, FEC_OC_SNC_MODE__A, &fecOcSncMode);
1502 if (status < 0)
1503 goto error;
1504 fecOcSncMode |= FEC_OC_SNC_MODE_SHUTDOWN__M;
1505 status = write16(state, FEC_OC_SNC_MODE__A, fecOcSncMode);
1506 if (status < 0)
1507 goto error;
1508
1509 /* Suppress MCLK during absence of data */
1510 status = read16(state, FEC_OC_IPR_MODE__A, &fecOcIprMode);
1511 if (status < 0)
1512 goto error;
1513 fecOcIprMode |= FEC_OC_IPR_MODE_MCLK_DIS_DAT_ABS__M;
1514 status = write16(state, FEC_OC_IPR_MODE__A, fecOcIprMode);
1515
1516 error:
1517 if (status < 0)
1518 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1519
1520 return status;
1521 }
1522
1523 static int scu_command(struct drxk_state *state,
1524 u16 cmd, u8 parameterLen,
1525 u16 *parameter, u8 resultLen, u16 *result)
1526 {
1527 #if (SCU_RAM_PARAM_0__A - SCU_RAM_PARAM_15__A) != 15
1528 #error DRXK register mapping no longer compatible with this routine!
1529 #endif
1530 u16 curCmd = 0;
1531 int status = -EINVAL;
1532 unsigned long end;
1533 u8 buffer[34];
1534 int cnt = 0, ii;
1535 const char *p;
1536 char errname[30];
1537
1538 dprintk(1, "\n");
1539
1540 if ((cmd == 0) || ((parameterLen > 0) && (parameter == NULL)) ||
1541 ((resultLen > 0) && (result == NULL))) {
1542 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1543 return status;
1544 }
1545
1546 mutex_lock(&state->mutex);
1547
1548 /* assume that the command register is ready
1549 since it is checked afterwards */
1550 for (ii = parameterLen - 1; ii >= 0; ii -= 1) {
1551 buffer[cnt++] = (parameter[ii] & 0xFF);
1552 buffer[cnt++] = ((parameter[ii] >> 8) & 0xFF);
1553 }
1554 buffer[cnt++] = (cmd & 0xFF);
1555 buffer[cnt++] = ((cmd >> 8) & 0xFF);
1556
1557 write_block(state, SCU_RAM_PARAM_0__A -
1558 (parameterLen - 1), cnt, buffer);
1559 /* Wait until SCU has processed command */
1560 end = jiffies + msecs_to_jiffies(DRXK_MAX_WAITTIME);
1561 do {
1562 msleep(1);
1563 status = read16(state, SCU_RAM_COMMAND__A, &curCmd);
1564 if (status < 0)
1565 goto error;
1566 } while (!(curCmd == DRX_SCU_READY) && (time_is_after_jiffies(end)));
1567 if (curCmd != DRX_SCU_READY) {
1568 printk(KERN_ERR "drxk: SCU not ready\n");
1569 status = -EIO;
1570 goto error2;
1571 }
1572 /* read results */
1573 if ((resultLen > 0) && (result != NULL)) {
1574 s16 err;
1575 int ii;
1576
1577 for (ii = resultLen - 1; ii >= 0; ii -= 1) {
1578 status = read16(state, SCU_RAM_PARAM_0__A - ii, &result[ii]);
1579 if (status < 0)
1580 goto error;
1581 }
1582
1583 /* Check if an error was reported by SCU */
1584 err = (s16)result[0];
1585 if (err >= 0)
1586 goto error;
1587
1588 /* check for the known error codes */
1589 switch (err) {
1590 case SCU_RESULT_UNKCMD:
1591 p = "SCU_RESULT_UNKCMD";
1592 break;
1593 case SCU_RESULT_UNKSTD:
1594 p = "SCU_RESULT_UNKSTD";
1595 break;
1596 case SCU_RESULT_SIZE:
1597 p = "SCU_RESULT_SIZE";
1598 break;
1599 case SCU_RESULT_INVPAR:
1600 p = "SCU_RESULT_INVPAR";
1601 break;
1602 default: /* Other negative values are errors */
1603 sprintf(errname, "ERROR: %d\n", err);
1604 p = errname;
1605 }
1606 printk(KERN_ERR "drxk: %s while sending cmd 0x%04x with params:", p, cmd);
1607 print_hex_dump_bytes("drxk: ", DUMP_PREFIX_NONE, buffer, cnt);
1608 status = -EINVAL;
1609 goto error2;
1610 }
1611
1612 error:
1613 if (status < 0)
1614 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1615 error2:
1616 mutex_unlock(&state->mutex);
1617 return status;
1618 }
1619
1620 static int SetIqmAf(struct drxk_state *state, bool active)
1621 {
1622 u16 data = 0;
1623 int status;
1624
1625 dprintk(1, "\n");
1626
1627 /* Configure IQM */
1628 status = read16(state, IQM_AF_STDBY__A, &data);
1629 if (status < 0)
1630 goto error;
1631
1632 if (!active) {
1633 data |= (IQM_AF_STDBY_STDBY_ADC_STANDBY
1634 | IQM_AF_STDBY_STDBY_AMP_STANDBY
1635 | IQM_AF_STDBY_STDBY_PD_STANDBY
1636 | IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY
1637 | IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY);
1638 } else {
1639 data &= ((~IQM_AF_STDBY_STDBY_ADC_STANDBY)
1640 & (~IQM_AF_STDBY_STDBY_AMP_STANDBY)
1641 & (~IQM_AF_STDBY_STDBY_PD_STANDBY)
1642 & (~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY)
1643 & (~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY)
1644 );
1645 }
1646 status = write16(state, IQM_AF_STDBY__A, data);
1647
1648 error:
1649 if (status < 0)
1650 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1651 return status;
1652 }
1653
1654 static int CtrlPowerMode(struct drxk_state *state, enum DRXPowerMode *mode)
1655 {
1656 int status = 0;
1657 u16 sioCcPwdMode = 0;
1658
1659 dprintk(1, "\n");
1660
1661 /* Check arguments */
1662 if (mode == NULL)
1663 return -EINVAL;
1664
1665 switch (*mode) {
1666 case DRX_POWER_UP:
1667 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_NONE;
1668 break;
1669 case DRXK_POWER_DOWN_OFDM:
1670 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_OFDM;
1671 break;
1672 case DRXK_POWER_DOWN_CORE:
1673 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_CLOCK;
1674 break;
1675 case DRXK_POWER_DOWN_PLL:
1676 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_PLL;
1677 break;
1678 case DRX_POWER_DOWN:
1679 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_OSC;
1680 break;
1681 default:
1682 /* Unknow sleep mode */
1683 return -EINVAL;
1684 }
1685
1686 /* If already in requested power mode, do nothing */
1687 if (state->m_currentPowerMode == *mode)
1688 return 0;
1689
1690 /* For next steps make sure to start from DRX_POWER_UP mode */
1691 if (state->m_currentPowerMode != DRX_POWER_UP) {
1692 status = PowerUpDevice(state);
1693 if (status < 0)
1694 goto error;
1695 status = DVBTEnableOFDMTokenRing(state, true);
1696 if (status < 0)
1697 goto error;
1698 }
1699
1700 if (*mode == DRX_POWER_UP) {
1701 /* Restore analog & pin configuartion */
1702 } else {
1703 /* Power down to requested mode */
1704 /* Backup some register settings */
1705 /* Set pins with possible pull-ups connected
1706 to them in input mode */
1707 /* Analog power down */
1708 /* ADC power down */
1709 /* Power down device */
1710 /* stop all comm_exec */
1711 /* Stop and power down previous standard */
1712 switch (state->m_OperationMode) {
1713 case OM_DVBT:
1714 status = MPEGTSStop(state);
1715 if (status < 0)
1716 goto error;
1717 status = PowerDownDVBT(state, false);
1718 if (status < 0)
1719 goto error;
1720 break;
1721 case OM_QAM_ITU_A:
1722 case OM_QAM_ITU_C:
1723 status = MPEGTSStop(state);
1724 if (status < 0)
1725 goto error;
1726 status = PowerDownQAM(state);
1727 if (status < 0)
1728 goto error;
1729 break;
1730 default:
1731 break;
1732 }
1733 status = DVBTEnableOFDMTokenRing(state, false);
1734 if (status < 0)
1735 goto error;
1736 status = write16(state, SIO_CC_PWD_MODE__A, sioCcPwdMode);
1737 if (status < 0)
1738 goto error;
1739 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
1740 if (status < 0)
1741 goto error;
1742
1743 if (*mode != DRXK_POWER_DOWN_OFDM) {
1744 state->m_HICfgCtrl |=
1745 SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
1746 status = HI_CfgCommand(state);
1747 if (status < 0)
1748 goto error;
1749 }
1750 }
1751 state->m_currentPowerMode = *mode;
1752
1753 error:
1754 if (status < 0)
1755 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1756
1757 return status;
1758 }
1759
1760 static int PowerDownDVBT(struct drxk_state *state, bool setPowerMode)
1761 {
1762 enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
1763 u16 cmdResult = 0;
1764 u16 data = 0;
1765 int status;
1766
1767 dprintk(1, "\n");
1768
1769 status = read16(state, SCU_COMM_EXEC__A, &data);
1770 if (status < 0)
1771 goto error;
1772 if (data == SCU_COMM_EXEC_ACTIVE) {
1773 /* Send OFDM stop command */
1774 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
1775 if (status < 0)
1776 goto error;
1777 /* Send OFDM reset command */
1778 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
1779 if (status < 0)
1780 goto error;
1781 }
1782
1783 /* Reset datapath for OFDM, processors first */
1784 status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
1785 if (status < 0)
1786 goto error;
1787 status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
1788 if (status < 0)
1789 goto error;
1790 status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
1791 if (status < 0)
1792 goto error;
1793
1794 /* powerdown AFE */
1795 status = SetIqmAf(state, false);
1796 if (status < 0)
1797 goto error;
1798
1799 /* powerdown to OFDM mode */
1800 if (setPowerMode) {
1801 status = CtrlPowerMode(state, &powerMode);
1802 if (status < 0)
1803 goto error;
1804 }
1805 error:
1806 if (status < 0)
1807 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1808 return status;
1809 }
1810
1811 static int SetOperationMode(struct drxk_state *state,
1812 enum OperationMode oMode)
1813 {
1814 int status = 0;
1815
1816 dprintk(1, "\n");
1817 /*
1818 Stop and power down previous standard
1819 TODO investigate total power down instead of partial
1820 power down depending on "previous" standard.
1821 */
1822
1823 /* disable HW lock indicator */
1824 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
1825 if (status < 0)
1826 goto error;
1827
1828 /* Device is already at the required mode */
1829 if (state->m_OperationMode == oMode)
1830 return 0;
1831
1832 switch (state->m_OperationMode) {
1833 /* OM_NONE was added for start up */
1834 case OM_NONE:
1835 break;
1836 case OM_DVBT:
1837 status = MPEGTSStop(state);
1838 if (status < 0)
1839 goto error;
1840 status = PowerDownDVBT(state, true);
1841 if (status < 0)
1842 goto error;
1843 state->m_OperationMode = OM_NONE;
1844 break;
1845 case OM_QAM_ITU_A: /* fallthrough */
1846 case OM_QAM_ITU_C:
1847 status = MPEGTSStop(state);
1848 if (status < 0)
1849 goto error;
1850 status = PowerDownQAM(state);
1851 if (status < 0)
1852 goto error;
1853 state->m_OperationMode = OM_NONE;
1854 break;
1855 case OM_QAM_ITU_B:
1856 default:
1857 status = -EINVAL;
1858 goto error;
1859 }
1860
1861 /*
1862 Power up new standard
1863 */
1864 switch (oMode) {
1865 case OM_DVBT:
1866 dprintk(1, ": DVB-T\n");
1867 state->m_OperationMode = oMode;
1868 status = SetDVBTStandard(state, oMode);
1869 if (status < 0)
1870 goto error;
1871 break;
1872 case OM_QAM_ITU_A: /* fallthrough */
1873 case OM_QAM_ITU_C:
1874 dprintk(1, ": DVB-C Annex %c\n",
1875 (state->m_OperationMode == OM_QAM_ITU_A) ? 'A' : 'C');
1876 state->m_OperationMode = oMode;
1877 status = SetQAMStandard(state, oMode);
1878 if (status < 0)
1879 goto error;
1880 break;
1881 case OM_QAM_ITU_B:
1882 default:
1883 status = -EINVAL;
1884 }
1885 error:
1886 if (status < 0)
1887 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1888 return status;
1889 }
1890
1891 static int Start(struct drxk_state *state, s32 offsetFreq,
1892 s32 IntermediateFrequency)
1893 {
1894 int status = -EINVAL;
1895
1896 u16 IFreqkHz;
1897 s32 OffsetkHz = offsetFreq / 1000;
1898
1899 dprintk(1, "\n");
1900 if (state->m_DrxkState != DRXK_STOPPED &&
1901 state->m_DrxkState != DRXK_DTV_STARTED)
1902 goto error;
1903
1904 state->m_bMirrorFreqSpect = (state->props.inversion == INVERSION_ON);
1905
1906 if (IntermediateFrequency < 0) {
1907 state->m_bMirrorFreqSpect = !state->m_bMirrorFreqSpect;
1908 IntermediateFrequency = -IntermediateFrequency;
1909 }
1910
1911 switch (state->m_OperationMode) {
1912 case OM_QAM_ITU_A:
1913 case OM_QAM_ITU_C:
1914 IFreqkHz = (IntermediateFrequency / 1000);
1915 status = SetQAM(state, IFreqkHz, OffsetkHz);
1916 if (status < 0)
1917 goto error;
1918 state->m_DrxkState = DRXK_DTV_STARTED;
1919 break;
1920 case OM_DVBT:
1921 IFreqkHz = (IntermediateFrequency / 1000);
1922 status = MPEGTSStop(state);
1923 if (status < 0)
1924 goto error;
1925 status = SetDVBT(state, IFreqkHz, OffsetkHz);
1926 if (status < 0)
1927 goto error;
1928 status = DVBTStart(state);
1929 if (status < 0)
1930 goto error;
1931 state->m_DrxkState = DRXK_DTV_STARTED;
1932 break;
1933 default:
1934 break;
1935 }
1936 error:
1937 if (status < 0)
1938 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1939 return status;
1940 }
1941
1942 static int ShutDown(struct drxk_state *state)
1943 {
1944 dprintk(1, "\n");
1945
1946 MPEGTSStop(state);
1947 return 0;
1948 }
1949
1950 static int GetLockStatus(struct drxk_state *state, u32 *pLockStatus,
1951 u32 Time)
1952 {
1953 int status = -EINVAL;
1954
1955 dprintk(1, "\n");
1956
1957 if (pLockStatus == NULL)
1958 goto error;
1959
1960 *pLockStatus = NOT_LOCKED;
1961
1962 /* define the SCU command code */
1963 switch (state->m_OperationMode) {
1964 case OM_QAM_ITU_A:
1965 case OM_QAM_ITU_B:
1966 case OM_QAM_ITU_C:
1967 status = GetQAMLockStatus(state, pLockStatus);
1968 break;
1969 case OM_DVBT:
1970 status = GetDVBTLockStatus(state, pLockStatus);
1971 break;
1972 default:
1973 break;
1974 }
1975 error:
1976 if (status < 0)
1977 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1978 return status;
1979 }
1980
1981 static int MPEGTSStart(struct drxk_state *state)
1982 {
1983 int status;
1984
1985 u16 fecOcSncMode = 0;
1986
1987 /* Allow OC to sync again */
1988 status = read16(state, FEC_OC_SNC_MODE__A, &fecOcSncMode);
1989 if (status < 0)
1990 goto error;
1991 fecOcSncMode &= ~FEC_OC_SNC_MODE_SHUTDOWN__M;
1992 status = write16(state, FEC_OC_SNC_MODE__A, fecOcSncMode);
1993 if (status < 0)
1994 goto error;
1995 status = write16(state, FEC_OC_SNC_UNLOCK__A, 1);
1996 error:
1997 if (status < 0)
1998 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1999 return status;
2000 }
2001
2002 static int MPEGTSDtoInit(struct drxk_state *state)
2003 {
2004 int status;
2005
2006 dprintk(1, "\n");
2007
2008 /* Rate integration settings */
2009 status = write16(state, FEC_OC_RCN_CTL_STEP_LO__A, 0x0000);
2010 if (status < 0)
2011 goto error;
2012 status = write16(state, FEC_OC_RCN_CTL_STEP_HI__A, 0x000C);
2013 if (status < 0)
2014 goto error;
2015 status = write16(state, FEC_OC_RCN_GAIN__A, 0x000A);
2016 if (status < 0)
2017 goto error;
2018 status = write16(state, FEC_OC_AVR_PARM_A__A, 0x0008);
2019 if (status < 0)
2020 goto error;
2021 status = write16(state, FEC_OC_AVR_PARM_B__A, 0x0006);
2022 if (status < 0)
2023 goto error;
2024 status = write16(state, FEC_OC_TMD_HI_MARGIN__A, 0x0680);
2025 if (status < 0)
2026 goto error;
2027 status = write16(state, FEC_OC_TMD_LO_MARGIN__A, 0x0080);
2028 if (status < 0)
2029 goto error;
2030 status = write16(state, FEC_OC_TMD_COUNT__A, 0x03F4);
2031 if (status < 0)
2032 goto error;
2033
2034 /* Additional configuration */
2035 status = write16(state, FEC_OC_OCR_INVERT__A, 0);
2036 if (status < 0)
2037 goto error;
2038 status = write16(state, FEC_OC_SNC_LWM__A, 2);
2039 if (status < 0)
2040 goto error;
2041 status = write16(state, FEC_OC_SNC_HWM__A, 12);
2042 error:
2043 if (status < 0)
2044 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2045
2046 return status;
2047 }
2048
2049 static int MPEGTSDtoSetup(struct drxk_state *state,
2050 enum OperationMode oMode)
2051 {
2052 int status;
2053
2054 u16 fecOcRegMode = 0; /* FEC_OC_MODE register value */
2055 u16 fecOcRegIprMode = 0; /* FEC_OC_IPR_MODE register value */
2056 u16 fecOcDtoMode = 0; /* FEC_OC_IPR_INVERT register value */
2057 u16 fecOcFctMode = 0; /* FEC_OC_IPR_INVERT register value */
2058 u16 fecOcDtoPeriod = 2; /* FEC_OC_IPR_INVERT register value */
2059 u16 fecOcDtoBurstLen = 188; /* FEC_OC_IPR_INVERT register value */
2060 u32 fecOcRcnCtlRate = 0; /* FEC_OC_IPR_INVERT register value */
2061 u16 fecOcTmdMode = 0;
2062 u16 fecOcTmdIntUpdRate = 0;
2063 u32 maxBitRate = 0;
2064 bool staticCLK = false;
2065
2066 dprintk(1, "\n");
2067
2068 /* Check insertion of the Reed-Solomon parity bytes */
2069 status = read16(state, FEC_OC_MODE__A, &fecOcRegMode);
2070 if (status < 0)
2071 goto error;
2072 status = read16(state, FEC_OC_IPR_MODE__A, &fecOcRegIprMode);
2073 if (status < 0)
2074 goto error;
2075 fecOcRegMode &= (~FEC_OC_MODE_PARITY__M);
2076 fecOcRegIprMode &= (~FEC_OC_IPR_MODE_MVAL_DIS_PAR__M);
2077 if (state->m_insertRSByte == true) {
2078 /* enable parity symbol forward */
2079 fecOcRegMode |= FEC_OC_MODE_PARITY__M;
2080 /* MVAL disable during parity bytes */
2081 fecOcRegIprMode |= FEC_OC_IPR_MODE_MVAL_DIS_PAR__M;
2082 /* TS burst length to 204 */
2083 fecOcDtoBurstLen = 204;
2084 }
2085
2086 /* Check serial or parrallel output */
2087 fecOcRegIprMode &= (~(FEC_OC_IPR_MODE_SERIAL__M));
2088 if (state->m_enableParallel == false) {
2089 /* MPEG data output is serial -> set ipr_mode[0] */
2090 fecOcRegIprMode |= FEC_OC_IPR_MODE_SERIAL__M;
2091 }
2092
2093 switch (oMode) {
2094 case OM_DVBT:
2095 maxBitRate = state->m_DVBTBitrate;
2096 fecOcTmdMode = 3;
2097 fecOcRcnCtlRate = 0xC00000;
2098 staticCLK = state->m_DVBTStaticCLK;
2099 break;
2100 case OM_QAM_ITU_A: /* fallthrough */
2101 case OM_QAM_ITU_C:
2102 fecOcTmdMode = 0x0004;
2103 fecOcRcnCtlRate = 0xD2B4EE; /* good for >63 Mb/s */
2104 maxBitRate = state->m_DVBCBitrate;
2105 staticCLK = state->m_DVBCStaticCLK;
2106 break;
2107 default:
2108 status = -EINVAL;
2109 } /* switch (standard) */
2110 if (status < 0)
2111 goto error;
2112
2113 /* Configure DTO's */
2114 if (staticCLK) {
2115 u32 bitRate = 0;
2116
2117 /* Rational DTO for MCLK source (static MCLK rate),
2118 Dynamic DTO for optimal grouping
2119 (avoid intra-packet gaps),
2120 DTO offset enable to sync TS burst with MSTRT */
2121 fecOcDtoMode = (FEC_OC_DTO_MODE_DYNAMIC__M |
2122 FEC_OC_DTO_MODE_OFFSET_ENABLE__M);
2123 fecOcFctMode = (FEC_OC_FCT_MODE_RAT_ENA__M |
2124 FEC_OC_FCT_MODE_VIRT_ENA__M);
2125
2126 /* Check user defined bitrate */
2127 bitRate = maxBitRate;
2128 if (bitRate > 75900000UL) { /* max is 75.9 Mb/s */
2129 bitRate = 75900000UL;
2130 }
2131 /* Rational DTO period:
2132 dto_period = (Fsys / bitrate) - 2
2133
2134 Result should be floored,
2135 to make sure >= requested bitrate
2136 */
2137 fecOcDtoPeriod = (u16) (((state->m_sysClockFreq)
2138 * 1000) / bitRate);
2139 if (fecOcDtoPeriod <= 2)
2140 fecOcDtoPeriod = 0;
2141 else
2142 fecOcDtoPeriod -= 2;
2143 fecOcTmdIntUpdRate = 8;
2144 } else {
2145 /* (commonAttr->staticCLK == false) => dynamic mode */
2146 fecOcDtoMode = FEC_OC_DTO_MODE_DYNAMIC__M;
2147 fecOcFctMode = FEC_OC_FCT_MODE__PRE;
2148 fecOcTmdIntUpdRate = 5;
2149 }
2150
2151 /* Write appropriate registers with requested configuration */
2152 status = write16(state, FEC_OC_DTO_BURST_LEN__A, fecOcDtoBurstLen);
2153 if (status < 0)
2154 goto error;
2155 status = write16(state, FEC_OC_DTO_PERIOD__A, fecOcDtoPeriod);
2156 if (status < 0)
2157 goto error;
2158 status = write16(state, FEC_OC_DTO_MODE__A, fecOcDtoMode);
2159 if (status < 0)
2160 goto error;
2161 status = write16(state, FEC_OC_FCT_MODE__A, fecOcFctMode);
2162 if (status < 0)
2163 goto error;
2164 status = write16(state, FEC_OC_MODE__A, fecOcRegMode);
2165 if (status < 0)
2166 goto error;
2167 status = write16(state, FEC_OC_IPR_MODE__A, fecOcRegIprMode);
2168 if (status < 0)
2169 goto error;
2170
2171 /* Rate integration settings */
2172 status = write32(state, FEC_OC_RCN_CTL_RATE_LO__A, fecOcRcnCtlRate);
2173 if (status < 0)
2174 goto error;
2175 status = write16(state, FEC_OC_TMD_INT_UPD_RATE__A, fecOcTmdIntUpdRate);
2176 if (status < 0)
2177 goto error;
2178 status = write16(state, FEC_OC_TMD_MODE__A, fecOcTmdMode);
2179 error:
2180 if (status < 0)
2181 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2182 return status;
2183 }
2184
2185 static int MPEGTSConfigurePolarity(struct drxk_state *state)
2186 {
2187 u16 fecOcRegIprInvert = 0;
2188
2189 /* Data mask for the output data byte */
2190 u16 InvertDataMask =
2191 FEC_OC_IPR_INVERT_MD7__M | FEC_OC_IPR_INVERT_MD6__M |
2192 FEC_OC_IPR_INVERT_MD5__M | FEC_OC_IPR_INVERT_MD4__M |
2193 FEC_OC_IPR_INVERT_MD3__M | FEC_OC_IPR_INVERT_MD2__M |
2194 FEC_OC_IPR_INVERT_MD1__M | FEC_OC_IPR_INVERT_MD0__M;
2195
2196 dprintk(1, "\n");
2197
2198 /* Control selective inversion of output bits */
2199 fecOcRegIprInvert &= (~(InvertDataMask));
2200 if (state->m_invertDATA == true)
2201 fecOcRegIprInvert |= InvertDataMask;
2202 fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MERR__M));
2203 if (state->m_invertERR == true)
2204 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MERR__M;
2205 fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MSTRT__M));
2206 if (state->m_invertSTR == true)
2207 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MSTRT__M;
2208 fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MVAL__M));
2209 if (state->m_invertVAL == true)
2210 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MVAL__M;
2211 fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MCLK__M));
2212 if (state->m_invertCLK == true)
2213 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MCLK__M;
2214
2215 return write16(state, FEC_OC_IPR_INVERT__A, fecOcRegIprInvert);
2216 }
2217
2218 #define SCU_RAM_AGC_KI_INV_RF_POL__M 0x4000
2219
2220 static int SetAgcRf(struct drxk_state *state,
2221 struct SCfgAgc *pAgcCfg, bool isDTV)
2222 {
2223 int status = -EINVAL;
2224 u16 data = 0;
2225 struct SCfgAgc *pIfAgcSettings;
2226
2227 dprintk(1, "\n");
2228
2229 if (pAgcCfg == NULL)
2230 goto error;
2231
2232 switch (pAgcCfg->ctrlMode) {
2233 case DRXK_AGC_CTRL_AUTO:
2234 /* Enable RF AGC DAC */
2235 status = read16(state, IQM_AF_STDBY__A, &data);
2236 if (status < 0)
2237 goto error;
2238 data &= ~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2239 status = write16(state, IQM_AF_STDBY__A, data);
2240 if (status < 0)
2241 goto error;
2242 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2243 if (status < 0)
2244 goto error;
2245
2246 /* Enable SCU RF AGC loop */
2247 data &= ~SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2248
2249 /* Polarity */
2250 if (state->m_RfAgcPol)
2251 data |= SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2252 else
2253 data &= ~SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2254 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2255 if (status < 0)
2256 goto error;
2257
2258 /* Set speed (using complementary reduction value) */
2259 status = read16(state, SCU_RAM_AGC_KI_RED__A, &data);
2260 if (status < 0)
2261 goto error;
2262
2263 data &= ~SCU_RAM_AGC_KI_RED_RAGC_RED__M;
2264 data |= (~(pAgcCfg->speed <<
2265 SCU_RAM_AGC_KI_RED_RAGC_RED__B)
2266 & SCU_RAM_AGC_KI_RED_RAGC_RED__M);
2267
2268 status = write16(state, SCU_RAM_AGC_KI_RED__A, data);
2269 if (status < 0)
2270 goto error;
2271
2272 if (IsDVBT(state))
2273 pIfAgcSettings = &state->m_dvbtIfAgcCfg;
2274 else if (IsQAM(state))
2275 pIfAgcSettings = &state->m_qamIfAgcCfg;
2276 else
2277 pIfAgcSettings = &state->m_atvIfAgcCfg;
2278 if (pIfAgcSettings == NULL) {
2279 status = -EINVAL;
2280 goto error;
2281 }
2282
2283 /* Set TOP, only if IF-AGC is in AUTO mode */
2284 if (pIfAgcSettings->ctrlMode == DRXK_AGC_CTRL_AUTO)
2285 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pAgcCfg->top);
2286 if (status < 0)
2287 goto error;
2288
2289 /* Cut-Off current */
2290 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI_CO__A, pAgcCfg->cutOffCurrent);
2291 if (status < 0)
2292 goto error;
2293
2294 /* Max. output level */
2295 status = write16(state, SCU_RAM_AGC_RF_MAX__A, pAgcCfg->maxOutputLevel);
2296 if (status < 0)
2297 goto error;
2298
2299 break;
2300
2301 case DRXK_AGC_CTRL_USER:
2302 /* Enable RF AGC DAC */
2303 status = read16(state, IQM_AF_STDBY__A, &data);
2304 if (status < 0)
2305 goto error;
2306 data &= ~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2307 status = write16(state, IQM_AF_STDBY__A, data);
2308 if (status < 0)
2309 goto error;
2310
2311 /* Disable SCU RF AGC loop */
2312 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2313 if (status < 0)
2314 goto error;
2315 data |= SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2316 if (state->m_RfAgcPol)
2317 data |= SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2318 else
2319 data &= ~SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2320 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2321 if (status < 0)
2322 goto error;
2323
2324 /* SCU c.o.c. to 0, enabling full control range */
2325 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI_CO__A, 0);
2326 if (status < 0)
2327 goto error;
2328
2329 /* Write value to output pin */
2330 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI__A, pAgcCfg->outputLevel);
2331 if (status < 0)
2332 goto error;
2333 break;
2334
2335 case DRXK_AGC_CTRL_OFF:
2336 /* Disable RF AGC DAC */
2337 status = read16(state, IQM_AF_STDBY__A, &data);
2338 if (status < 0)
2339 goto error;
2340 data |= IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2341 status = write16(state, IQM_AF_STDBY__A, data);
2342 if (status < 0)
2343 goto error;
2344
2345 /* Disable SCU RF AGC loop */
2346 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2347 if (status < 0)
2348 goto error;
2349 data |= SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2350 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2351 if (status < 0)
2352 goto error;
2353 break;
2354
2355 default:
2356 status = -EINVAL;
2357
2358 }
2359 error:
2360 if (status < 0)
2361 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2362 return status;
2363 }
2364
2365 #define SCU_RAM_AGC_KI_INV_IF_POL__M 0x2000
2366
2367 static int SetAgcIf(struct drxk_state *state,
2368 struct SCfgAgc *pAgcCfg, bool isDTV)
2369 {
2370 u16 data = 0;
2371 int status = 0;
2372 struct SCfgAgc *pRfAgcSettings;
2373
2374 dprintk(1, "\n");
2375
2376 switch (pAgcCfg->ctrlMode) {
2377 case DRXK_AGC_CTRL_AUTO:
2378
2379 /* Enable IF AGC DAC */
2380 status = read16(state, IQM_AF_STDBY__A, &data);
2381 if (status < 0)
2382 goto error;
2383 data &= ~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2384 status = write16(state, IQM_AF_STDBY__A, data);
2385 if (status < 0)
2386 goto error;
2387
2388 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2389 if (status < 0)
2390 goto error;
2391
2392 /* Enable SCU IF AGC loop */
2393 data &= ~SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2394
2395 /* Polarity */
2396 if (state->m_IfAgcPol)
2397 data |= SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2398 else
2399 data &= ~SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2400 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2401 if (status < 0)
2402 goto error;
2403
2404 /* Set speed (using complementary reduction value) */
2405 status = read16(state, SCU_RAM_AGC_KI_RED__A, &data);
2406 if (status < 0)
2407 goto error;
2408 data &= ~SCU_RAM_AGC_KI_RED_IAGC_RED__M;
2409 data |= (~(pAgcCfg->speed <<
2410 SCU_RAM_AGC_KI_RED_IAGC_RED__B)
2411 & SCU_RAM_AGC_KI_RED_IAGC_RED__M);
2412
2413 status = write16(state, SCU_RAM_AGC_KI_RED__A, data);
2414 if (status < 0)
2415 goto error;
2416
2417 if (IsQAM(state))
2418 pRfAgcSettings = &state->m_qamRfAgcCfg;
2419 else
2420 pRfAgcSettings = &state->m_atvRfAgcCfg;
2421 if (pRfAgcSettings == NULL)
2422 return -1;
2423 /* Restore TOP */
2424 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pRfAgcSettings->top);
2425 if (status < 0)
2426 goto error;
2427 break;
2428
2429 case DRXK_AGC_CTRL_USER:
2430
2431 /* Enable IF AGC DAC */
2432 status = read16(state, IQM_AF_STDBY__A, &data);
2433 if (status < 0)
2434 goto error;
2435 data &= ~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2436 status = write16(state, IQM_AF_STDBY__A, data);
2437 if (status < 0)
2438 goto error;
2439
2440 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2441 if (status < 0)
2442 goto error;
2443
2444 /* Disable SCU IF AGC loop */
2445 data |= SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2446
2447 /* Polarity */
2448 if (state->m_IfAgcPol)
2449 data |= SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2450 else
2451 data &= ~SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2452 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2453 if (status < 0)
2454 goto error;
2455
2456 /* Write value to output pin */
2457 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pAgcCfg->outputLevel);
2458 if (status < 0)
2459 goto error;
2460 break;
2461
2462 case DRXK_AGC_CTRL_OFF:
2463
2464 /* Disable If AGC DAC */
2465 status = read16(state, IQM_AF_STDBY__A, &data);
2466 if (status < 0)
2467 goto error;
2468 data |= IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2469 status = write16(state, IQM_AF_STDBY__A, data);
2470 if (status < 0)
2471 goto error;
2472
2473 /* Disable SCU IF AGC loop */
2474 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2475 if (status < 0)
2476 goto error;
2477 data |= SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2478 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2479 if (status < 0)
2480 goto error;
2481 break;
2482 } /* switch (agcSettingsIf->ctrlMode) */
2483
2484 /* always set the top to support
2485 configurations without if-loop */
2486 status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MIN__A, pAgcCfg->top);
2487 error:
2488 if (status < 0)
2489 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2490 return status;
2491 }
2492
2493 static int ReadIFAgc(struct drxk_state *state, u32 *pValue)
2494 {
2495 u16 agcDacLvl;
2496 int status;
2497 u16 Level = 0;
2498
2499 dprintk(1, "\n");
2500
2501 status = read16(state, IQM_AF_AGC_IF__A, &agcDacLvl);
2502 if (status < 0) {
2503 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2504 return status;
2505 }
2506
2507 *pValue = 0;
2508
2509 if (agcDacLvl > DRXK_AGC_DAC_OFFSET)
2510 Level = agcDacLvl - DRXK_AGC_DAC_OFFSET;
2511 if (Level < 14000)
2512 *pValue = (14000 - Level) / 4;
2513 else
2514 *pValue = 0;
2515
2516 return status;
2517 }
2518
2519 static int GetQAMSignalToNoise(struct drxk_state *state,
2520 s32 *pSignalToNoise)
2521 {
2522 int status = 0;
2523 u16 qamSlErrPower = 0; /* accum. error between
2524 raw and sliced symbols */
2525 u32 qamSlSigPower = 0; /* used for MER, depends of
2526 QAM modulation */
2527 u32 qamSlMer = 0; /* QAM MER */
2528
2529 dprintk(1, "\n");
2530
2531 /* MER calculation */
2532
2533 /* get the register value needed for MER */
2534 status = read16(state, QAM_SL_ERR_POWER__A, &qamSlErrPower);
2535 if (status < 0) {
2536 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2537 return -EINVAL;
2538 }
2539
2540 switch (state->props.modulation) {
2541 case QAM_16:
2542 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM16 << 2;
2543 break;
2544 case QAM_32:
2545 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM32 << 2;
2546 break;
2547 case QAM_64:
2548 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM64 << 2;
2549 break;
2550 case QAM_128:
2551 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM128 << 2;
2552 break;
2553 default:
2554 case QAM_256:
2555 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM256 << 2;
2556 break;
2557 }
2558
2559 if (qamSlErrPower > 0) {
2560 qamSlMer = Log10Times100(qamSlSigPower) -
2561 Log10Times100((u32) qamSlErrPower);
2562 }
2563 *pSignalToNoise = qamSlMer;
2564
2565 return status;
2566 }
2567
2568 static int GetDVBTSignalToNoise(struct drxk_state *state,
2569 s32 *pSignalToNoise)
2570 {
2571 int status;
2572 u16 regData = 0;
2573 u32 EqRegTdSqrErrI = 0;
2574 u32 EqRegTdSqrErrQ = 0;
2575 u16 EqRegTdSqrErrExp = 0;
2576 u16 EqRegTdTpsPwrOfs = 0;
2577 u16 EqRegTdReqSmbCnt = 0;
2578 u32 tpsCnt = 0;
2579 u32 SqrErrIQ = 0;
2580 u32 a = 0;
2581 u32 b = 0;
2582 u32 c = 0;
2583 u32 iMER = 0;
2584 u16 transmissionParams = 0;
2585
2586 dprintk(1, "\n");
2587
2588 status = read16(state, OFDM_EQ_TOP_TD_TPS_PWR_OFS__A, &EqRegTdTpsPwrOfs);
2589 if (status < 0)
2590 goto error;
2591 status = read16(state, OFDM_EQ_TOP_TD_REQ_SMB_CNT__A, &EqRegTdReqSmbCnt);
2592 if (status < 0)
2593 goto error;
2594 status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_EXP__A, &EqRegTdSqrErrExp);
2595 if (status < 0)
2596 goto error;
2597 status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_I__A, &regData);
2598 if (status < 0)
2599 goto error;
2600 /* Extend SQR_ERR_I operational range */
2601 EqRegTdSqrErrI = (u32) regData;
2602 if ((EqRegTdSqrErrExp > 11) &&
2603 (EqRegTdSqrErrI < 0x00000FFFUL)) {
2604 EqRegTdSqrErrI += 0x00010000UL;
2605 }
2606 status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_Q__A, &regData);
2607 if (status < 0)
2608 goto error;
2609 /* Extend SQR_ERR_Q operational range */
2610 EqRegTdSqrErrQ = (u32) regData;
2611 if ((EqRegTdSqrErrExp > 11) &&
2612 (EqRegTdSqrErrQ < 0x00000FFFUL))
2613 EqRegTdSqrErrQ += 0x00010000UL;
2614
2615 status = read16(state, OFDM_SC_RA_RAM_OP_PARAM__A, &transmissionParams);
2616 if (status < 0)
2617 goto error;
2618
2619 /* Check input data for MER */
2620
2621 /* MER calculation (in 0.1 dB) without math.h */
2622 if ((EqRegTdTpsPwrOfs == 0) || (EqRegTdReqSmbCnt == 0))
2623 iMER = 0;
2624 else if ((EqRegTdSqrErrI + EqRegTdSqrErrQ) == 0) {
2625 /* No error at all, this must be the HW reset value
2626 * Apparently no first measurement yet
2627 * Set MER to 0.0 */
2628 iMER = 0;
2629 } else {
2630 SqrErrIQ = (EqRegTdSqrErrI + EqRegTdSqrErrQ) <<
2631 EqRegTdSqrErrExp;
2632 if ((transmissionParams &
2633 OFDM_SC_RA_RAM_OP_PARAM_MODE__M)
2634 == OFDM_SC_RA_RAM_OP_PARAM_MODE_2K)
2635 tpsCnt = 17;
2636 else
2637 tpsCnt = 68;
2638
2639 /* IMER = 100 * log10 (x)
2640 where x = (EqRegTdTpsPwrOfs^2 *
2641 EqRegTdReqSmbCnt * tpsCnt)/SqrErrIQ
2642
2643 => IMER = a + b -c
2644 where a = 100 * log10 (EqRegTdTpsPwrOfs^2)
2645 b = 100 * log10 (EqRegTdReqSmbCnt * tpsCnt)
2646 c = 100 * log10 (SqrErrIQ)
2647 */
2648
2649 /* log(x) x = 9bits * 9bits->18 bits */
2650 a = Log10Times100(EqRegTdTpsPwrOfs *
2651 EqRegTdTpsPwrOfs);
2652 /* log(x) x = 16bits * 7bits->23 bits */
2653 b = Log10Times100(EqRegTdReqSmbCnt * tpsCnt);
2654 /* log(x) x = (16bits + 16bits) << 15 ->32 bits */
2655 c = Log10Times100(SqrErrIQ);
2656
2657 iMER = a + b;
2658 /* No negative MER, clip to zero */
2659 if (iMER > c)
2660 iMER -= c;
2661 else
2662 iMER = 0;
2663 }
2664 *pSignalToNoise = iMER;
2665
2666 error:
2667 if (status < 0)
2668 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2669 return status;
2670 }
2671
2672 static int GetSignalToNoise(struct drxk_state *state, s32 *pSignalToNoise)
2673 {
2674 dprintk(1, "\n");
2675
2676 *pSignalToNoise = 0;
2677 switch (state->m_OperationMode) {
2678 case OM_DVBT:
2679 return GetDVBTSignalToNoise(state, pSignalToNoise);
2680 case OM_QAM_ITU_A:
2681 case OM_QAM_ITU_C:
2682 return GetQAMSignalToNoise(state, pSignalToNoise);
2683 default:
2684 break;
2685 }
2686 return 0;
2687 }
2688
2689 #if 0
2690 static int GetDVBTQuality(struct drxk_state *state, s32 *pQuality)
2691 {
2692 /* SNR Values for quasi errorfree reception rom Nordig 2.2 */
2693 int status = 0;
2694
2695 dprintk(1, "\n");
2696
2697 static s32 QE_SN[] = {
2698 51, /* QPSK 1/2 */
2699 69, /* QPSK 2/3 */
2700 79, /* QPSK 3/4 */
2701 89, /* QPSK 5/6 */
2702 97, /* QPSK 7/8 */
2703 108, /* 16-QAM 1/2 */
2704 131, /* 16-QAM 2/3 */
2705 146, /* 16-QAM 3/4 */
2706 156, /* 16-QAM 5/6 */
2707 160, /* 16-QAM 7/8 */
2708 165, /* 64-QAM 1/2 */
2709 187, /* 64-QAM 2/3 */
2710 202, /* 64-QAM 3/4 */
2711 216, /* 64-QAM 5/6 */
2712 225, /* 64-QAM 7/8 */
2713 };
2714
2715 *pQuality = 0;
2716
2717 do {
2718 s32 SignalToNoise = 0;
2719 u16 Constellation = 0;
2720 u16 CodeRate = 0;
2721 u32 SignalToNoiseRel;
2722 u32 BERQuality;
2723
2724 status = GetDVBTSignalToNoise(state, &SignalToNoise);
2725 if (status < 0)
2726 break;
2727 status = read16(state, OFDM_EQ_TOP_TD_TPS_CONST__A, &Constellation);
2728 if (status < 0)
2729 break;
2730 Constellation &= OFDM_EQ_TOP_TD_TPS_CONST__M;
2731
2732 status = read16(state, OFDM_EQ_TOP_TD_TPS_CODE_HP__A, &CodeRate);
2733 if (status < 0)
2734 break;
2735 CodeRate &= OFDM_EQ_TOP_TD_TPS_CODE_HP__M;
2736
2737 if (Constellation > OFDM_EQ_TOP_TD_TPS_CONST_64QAM ||
2738 CodeRate > OFDM_EQ_TOP_TD_TPS_CODE_LP_7_8)
2739 break;
2740 SignalToNoiseRel = SignalToNoise -
2741 QE_SN[Constellation * 5 + CodeRate];
2742 BERQuality = 100;
2743
2744 if (SignalToNoiseRel < -70)
2745 *pQuality = 0;
2746 else if (SignalToNoiseRel < 30)
2747 *pQuality = ((SignalToNoiseRel + 70) *
2748 BERQuality) / 100;
2749 else
2750 *pQuality = BERQuality;
2751 } while (0);
2752 return 0;
2753 };
2754
2755 static int GetDVBCQuality(struct drxk_state *state, s32 *pQuality)
2756 {
2757 int status = 0;
2758 *pQuality = 0;
2759
2760 dprintk(1, "\n");
2761
2762 do {
2763 u32 SignalToNoise = 0;
2764 u32 BERQuality = 100;
2765 u32 SignalToNoiseRel = 0;
2766
2767 status = GetQAMSignalToNoise(state, &SignalToNoise);
2768 if (status < 0)
2769 break;
2770
2771 switch (state->props.modulation) {
2772 case QAM_16:
2773 SignalToNoiseRel = SignalToNoise - 200;
2774 break;
2775 case QAM_32:
2776 SignalToNoiseRel = SignalToNoise - 230;
2777 break; /* Not in NorDig */
2778 case QAM_64:
2779 SignalToNoiseRel = SignalToNoise - 260;
2780 break;
2781 case QAM_128:
2782 SignalToNoiseRel = SignalToNoise - 290;
2783 break;
2784 default:
2785 case QAM_256:
2786 SignalToNoiseRel = SignalToNoise - 320;
2787 break;
2788 }
2789
2790 if (SignalToNoiseRel < -70)
2791 *pQuality = 0;
2792 else if (SignalToNoiseRel < 30)
2793 *pQuality = ((SignalToNoiseRel + 70) *
2794 BERQuality) / 100;
2795 else
2796 *pQuality = BERQuality;
2797 } while (0);
2798
2799 return status;
2800 }
2801
2802 static int GetQuality(struct drxk_state *state, s32 *pQuality)
2803 {
2804 dprintk(1, "\n");
2805
2806 switch (state->m_OperationMode) {
2807 case OM_DVBT:
2808 return GetDVBTQuality(state, pQuality);
2809 case OM_QAM_ITU_A:
2810 return GetDVBCQuality(state, pQuality);
2811 default:
2812 break;
2813 }
2814
2815 return 0;
2816 }
2817 #endif
2818
2819 /* Free data ram in SIO HI */
2820 #define SIO_HI_RA_RAM_USR_BEGIN__A 0x420040
2821 #define SIO_HI_RA_RAM_USR_END__A 0x420060
2822
2823 #define DRXK_HI_ATOMIC_BUF_START (SIO_HI_RA_RAM_USR_BEGIN__A)
2824 #define DRXK_HI_ATOMIC_BUF_END (SIO_HI_RA_RAM_USR_BEGIN__A + 7)
2825 #define DRXK_HI_ATOMIC_READ SIO_HI_RA_RAM_PAR_3_ACP_RW_READ
2826 #define DRXK_HI_ATOMIC_WRITE SIO_HI_RA_RAM_PAR_3_ACP_RW_WRITE
2827
2828 #define DRXDAP_FASI_ADDR2BLOCK(addr) (((addr) >> 22) & 0x3F)
2829 #define DRXDAP_FASI_ADDR2BANK(addr) (((addr) >> 16) & 0x3F)
2830 #define DRXDAP_FASI_ADDR2OFFSET(addr) ((addr) & 0x7FFF)
2831
2832 static int ConfigureI2CBridge(struct drxk_state *state, bool bEnableBridge)
2833 {
2834 int status = -EINVAL;
2835
2836 dprintk(1, "\n");
2837
2838 if (state->m_DrxkState == DRXK_UNINITIALIZED)
2839 return 0;
2840 if (state->m_DrxkState == DRXK_POWERED_DOWN)
2841 goto error;
2842
2843 if (state->no_i2c_bridge)
2844 return 0;
2845
2846 status = write16(state, SIO_HI_RA_RAM_PAR_1__A, SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY);
2847 if (status < 0)
2848 goto error;
2849 if (bEnableBridge) {
2850 status = write16(state, SIO_HI_RA_RAM_PAR_2__A, SIO_HI_RA_RAM_PAR_2_BRD_CFG_CLOSED);
2851 if (status < 0)
2852 goto error;
2853 } else {
2854 status = write16(state, SIO_HI_RA_RAM_PAR_2__A, SIO_HI_RA_RAM_PAR_2_BRD_CFG_OPEN);
2855 if (status < 0)
2856 goto error;
2857 }
2858
2859 status = HI_Command(state, SIO_HI_RA_RAM_CMD_BRDCTRL, 0);
2860
2861 error:
2862 if (status < 0)
2863 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2864 return status;
2865 }
2866
2867 static int SetPreSaw(struct drxk_state *state,
2868 struct SCfgPreSaw *pPreSawCfg)
2869 {
2870 int status = -EINVAL;
2871
2872 dprintk(1, "\n");
2873
2874 if ((pPreSawCfg == NULL)
2875 || (pPreSawCfg->reference > IQM_AF_PDREF__M))
2876 goto error;
2877
2878 status = write16(state, IQM_AF_PDREF__A, pPreSawCfg->reference);
2879 error:
2880 if (status < 0)
2881 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2882 return status;
2883 }
2884
2885 static int BLDirectCmd(struct drxk_state *state, u32 targetAddr,
2886 u16 romOffset, u16 nrOfElements, u32 timeOut)
2887 {
2888 u16 blStatus = 0;
2889 u16 offset = (u16) ((targetAddr >> 0) & 0x00FFFF);
2890 u16 blockbank = (u16) ((targetAddr >> 16) & 0x000FFF);
2891 int status;
2892 unsigned long end;
2893
2894 dprintk(1, "\n");
2895
2896 mutex_lock(&state->mutex);
2897 status = write16(state, SIO_BL_MODE__A, SIO_BL_MODE_DIRECT);
2898 if (status < 0)
2899 goto error;
2900 status = write16(state, SIO_BL_TGT_HDR__A, blockbank);
2901 if (status < 0)
2902 goto error;
2903 status = write16(state, SIO_BL_TGT_ADDR__A, offset);
2904 if (status < 0)
2905 goto error;
2906 status = write16(state, SIO_BL_SRC_ADDR__A, romOffset);
2907 if (status < 0)
2908 goto error;
2909 status = write16(state, SIO_BL_SRC_LEN__A, nrOfElements);
2910 if (status < 0)
2911 goto error;
2912 status = write16(state, SIO_BL_ENABLE__A, SIO_BL_ENABLE_ON);
2913 if (status < 0)
2914 goto error;
2915
2916 end = jiffies + msecs_to_jiffies(timeOut);
2917 do {
2918 status = read16(state, SIO_BL_STATUS__A, &blStatus);
2919 if (status < 0)
2920 goto error;
2921 } while ((blStatus == 0x1) && time_is_after_jiffies(end));
2922 if (blStatus == 0x1) {
2923 printk(KERN_ERR "drxk: SIO not ready\n");
2924 status = -EINVAL;
2925 goto error2;
2926 }
2927 error:
2928 if (status < 0)
2929 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2930 error2:
2931 mutex_unlock(&state->mutex);
2932 return status;
2933
2934 }
2935
2936 static int ADCSyncMeasurement(struct drxk_state *state, u16 *count)
2937 {
2938 u16 data = 0;
2939 int status;
2940
2941 dprintk(1, "\n");
2942
2943 /* Start measurement */
2944 status = write16(state, IQM_AF_COMM_EXEC__A, IQM_AF_COMM_EXEC_ACTIVE);
2945 if (status < 0)
2946 goto error;
2947 status = write16(state, IQM_AF_START_LOCK__A, 1);
2948 if (status < 0)
2949 goto error;
2950
2951 *count = 0;
2952 status = read16(state, IQM_AF_PHASE0__A, &data);
2953 if (status < 0)
2954 goto error;
2955 if (data == 127)
2956 *count = *count + 1;
2957 status = read16(state, IQM_AF_PHASE1__A, &data);
2958 if (status < 0)
2959 goto error;
2960 if (data == 127)
2961 *count = *count + 1;
2962 status = read16(state, IQM_AF_PHASE2__A, &data);
2963 if (status < 0)
2964 goto error;
2965 if (data == 127)
2966 *count = *count + 1;
2967
2968 error:
2969 if (status < 0)
2970 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2971 return status;
2972 }
2973
2974 static int ADCSynchronization(struct drxk_state *state)
2975 {
2976 u16 count = 0;
2977 int status;
2978
2979 dprintk(1, "\n");
2980
2981 status = ADCSyncMeasurement(state, &count);
2982 if (status < 0)
2983 goto error;
2984
2985 if (count == 1) {
2986 /* Try sampling on a diffrent edge */
2987 u16 clkNeg = 0;
2988
2989 status = read16(state, IQM_AF_CLKNEG__A, &clkNeg);
2990 if (status < 0)
2991 goto error;
2992 if ((clkNeg & IQM_AF_CLKNEG_CLKNEGDATA__M) ==
2993 IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_POS) {
2994 clkNeg &= (~(IQM_AF_CLKNEG_CLKNEGDATA__M));
2995 clkNeg |=
2996 IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_NEG;
2997 } else {
2998 clkNeg &= (~(IQM_AF_CLKNEG_CLKNEGDATA__M));
2999 clkNeg |=
3000 IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_POS;
3001 }
3002 status = write16(state, IQM_AF_CLKNEG__A, clkNeg);
3003 if (status < 0)
3004 goto error;
3005 status = ADCSyncMeasurement(state, &count);
3006 if (status < 0)
3007 goto error;
3008 }
3009
3010 if (count < 2)
3011 status = -EINVAL;
3012 error:
3013 if (status < 0)
3014 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3015 return status;
3016 }
3017
3018 static int SetFrequencyShifter(struct drxk_state *state,
3019 u16 intermediateFreqkHz,
3020 s32 tunerFreqOffset, bool isDTV)
3021 {
3022 bool selectPosImage = false;
3023 u32 rfFreqResidual = tunerFreqOffset;
3024 u32 fmFrequencyShift = 0;
3025 bool tunerMirror = !state->m_bMirrorFreqSpect;
3026 u32 adcFreq;
3027 bool adcFlip;
3028 int status;
3029 u32 ifFreqActual;
3030 u32 samplingFrequency = (u32) (state->m_sysClockFreq / 3);
3031 u32 frequencyShift;
3032 bool imageToSelect;
3033
3034 dprintk(1, "\n");
3035
3036 /*
3037 Program frequency shifter
3038 No need to account for mirroring on RF
3039 */
3040 if (isDTV) {
3041 if ((state->m_OperationMode == OM_QAM_ITU_A) ||
3042 (state->m_OperationMode == OM_QAM_ITU_C) ||
3043 (state->m_OperationMode == OM_DVBT))
3044 selectPosImage = true;
3045 else
3046 selectPosImage = false;
3047 }
3048 if (tunerMirror)
3049 /* tuner doesn't mirror */
3050 ifFreqActual = intermediateFreqkHz +
3051 rfFreqResidual + fmFrequencyShift;
3052 else
3053 /* tuner mirrors */
3054 ifFreqActual = intermediateFreqkHz -
3055 rfFreqResidual - fmFrequencyShift;
3056 if (ifFreqActual > samplingFrequency / 2) {
3057 /* adc mirrors */
3058 adcFreq = samplingFrequency - ifFreqActual;
3059 adcFlip = true;
3060 } else {
3061 /* adc doesn't mirror */
3062 adcFreq = ifFreqActual;
3063 adcFlip = false;
3064 }
3065
3066 frequencyShift = adcFreq;
3067 imageToSelect = state->m_rfmirror ^ tunerMirror ^
3068 adcFlip ^ selectPosImage;
3069 state->m_IqmFsRateOfs =
3070 Frac28a((frequencyShift), samplingFrequency);
3071
3072 if (imageToSelect)
3073 state->m_IqmFsRateOfs = ~state->m_IqmFsRateOfs + 1;
3074
3075 /* Program frequency shifter with tuner offset compensation */
3076 /* frequencyShift += tunerFreqOffset; TODO */
3077 status = write32(state, IQM_FS_RATE_OFS_LO__A,
3078 state->m_IqmFsRateOfs);
3079 if (status < 0)
3080 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3081 return status;
3082 }
3083
3084 static int InitAGC(struct drxk_state *state, bool isDTV)
3085 {
3086 u16 ingainTgt = 0;
3087 u16 ingainTgtMin = 0;
3088 u16 ingainTgtMax = 0;
3089 u16 clpCyclen = 0;
3090 u16 clpSumMin = 0;
3091 u16 clpDirTo = 0;
3092 u16 snsSumMin = 0;
3093 u16 snsSumMax = 0;
3094 u16 clpSumMax = 0;
3095 u16 snsDirTo = 0;
3096 u16 kiInnergainMin = 0;
3097 u16 ifIaccuHiTgt = 0;
3098 u16 ifIaccuHiTgtMin = 0;
3099 u16 ifIaccuHiTgtMax = 0;
3100 u16 data = 0;
3101 u16 fastClpCtrlDelay = 0;
3102 u16 clpCtrlMode = 0;
3103 int status = 0;
3104
3105 dprintk(1, "\n");
3106
3107 /* Common settings */
3108 snsSumMax = 1023;
3109 ifIaccuHiTgtMin = 2047;
3110 clpCyclen = 500;
3111 clpSumMax = 1023;
3112
3113 /* AGCInit() not available for DVBT; init done in microcode */
3114 if (!IsQAM(state)) {
3115 printk(KERN_ERR "drxk: %s: mode %d is not DVB-C\n", __func__, state->m_OperationMode);
3116 return -EINVAL;
3117 }
3118
3119 /* FIXME: Analog TV AGC require different settings */
3120
3121 /* Standard specific settings */
3122 clpSumMin = 8;
3123 clpDirTo = (u16) -9;
3124 clpCtrlMode = 0;
3125 snsSumMin = 8;
3126 snsDirTo = (u16) -9;
3127 kiInnergainMin = (u16) -1030;
3128 ifIaccuHiTgtMax = 0x2380;
3129 ifIaccuHiTgt = 0x2380;
3130 ingainTgtMin = 0x0511;
3131 ingainTgt = 0x0511;
3132 ingainTgtMax = 5119;
3133 fastClpCtrlDelay = state->m_qamIfAgcCfg.FastClipCtrlDelay;
3134
3135 status = write16(state, SCU_RAM_AGC_FAST_CLP_CTRL_DELAY__A, fastClpCtrlDelay);
3136 if (status < 0)
3137 goto error;
3138
3139 status = write16(state, SCU_RAM_AGC_CLP_CTRL_MODE__A, clpCtrlMode);
3140 if (status < 0)
3141 goto error;
3142 status = write16(state, SCU_RAM_AGC_INGAIN_TGT__A, ingainTgt);
3143 if (status < 0)
3144 goto error;
3145 status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MIN__A, ingainTgtMin);
3146 if (status < 0)
3147 goto error;
3148 status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MAX__A, ingainTgtMax);
3149 if (status < 0)
3150 goto error;
3151 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MIN__A, ifIaccuHiTgtMin);
3152 if (status < 0)
3153 goto error;
3154 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, ifIaccuHiTgtMax);
3155 if (status < 0)
3156 goto error;
3157 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI__A, 0);
3158 if (status < 0)
3159 goto error;
3160 status = write16(state, SCU_RAM_AGC_IF_IACCU_LO__A, 0);
3161 if (status < 0)
3162 goto error;
3163 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI__A, 0);
3164 if (status < 0)
3165 goto error;
3166 status = write16(state, SCU_RAM_AGC_RF_IACCU_LO__A, 0);
3167 if (status < 0)
3168 goto error;
3169 status = write16(state, SCU_RAM_AGC_CLP_SUM_MAX__A, clpSumMax);
3170 if (status < 0)
3171 goto error;
3172 status = write16(state, SCU_RAM_AGC_SNS_SUM_MAX__A, snsSumMax);
3173 if (status < 0)
3174 goto error;
3175
3176 status = write16(state, SCU_RAM_AGC_KI_INNERGAIN_MIN__A, kiInnergainMin);
3177 if (status < 0)
3178 goto error;
3179 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT__A, ifIaccuHiTgt);
3180 if (status < 0)
3181 goto error;
3182 status = write16(state, SCU_RAM_AGC_CLP_CYCLEN__A, clpCyclen);
3183 if (status < 0)
3184 goto error;
3185
3186 status = write16(state, SCU_RAM_AGC_RF_SNS_DEV_MAX__A, 1023);
3187 if (status < 0)
3188 goto error;
3189 status = write16(state, SCU_RAM_AGC_RF_SNS_DEV_MIN__A, (u16) -1023);
3190 if (status < 0)
3191 goto error;
3192 status = write16(state, SCU_RAM_AGC_FAST_SNS_CTRL_DELAY__A, 50);
3193 if (status < 0)
3194 goto error;
3195
3196 status = write16(state, SCU_RAM_AGC_KI_MAXMINGAIN_TH__A, 20);
3197 if (status < 0)
3198 goto error;
3199 status = write16(state, SCU_RAM_AGC_CLP_SUM_MIN__A, clpSumMin);
3200 if (status < 0)
3201 goto error;
3202 status = write16(state, SCU_RAM_AGC_SNS_SUM_MIN__A, snsSumMin);
3203 if (status < 0)
3204 goto error;
3205 status = write16(state, SCU_RAM_AGC_CLP_DIR_TO__A, clpDirTo);
3206 if (status < 0)
3207 goto error;
3208 status = write16(state, SCU_RAM_AGC_SNS_DIR_TO__A, snsDirTo);
3209 if (status < 0)
3210 goto error;
3211 status = write16(state, SCU_RAM_AGC_KI_MINGAIN__A, 0x7fff);
3212 if (status < 0)
3213 goto error;
3214 status = write16(state, SCU_RAM_AGC_KI_MAXGAIN__A, 0x0);
3215 if (status < 0)
3216 goto error;
3217 status = write16(state, SCU_RAM_AGC_KI_MIN__A, 0x0117);
3218 if (status < 0)
3219 goto error;
3220 status = write16(state, SCU_RAM_AGC_KI_MAX__A, 0x0657);
3221 if (status < 0)
3222 goto error;
3223 status = write16(state, SCU_RAM_AGC_CLP_SUM__A, 0);
3224 if (status < 0)
3225 goto error;
3226 status = write16(state, SCU_RAM_AGC_CLP_CYCCNT__A, 0);
3227 if (status < 0)
3228 goto error;
3229 status = write16(state, SCU_RAM_AGC_CLP_DIR_WD__A, 0);
3230 if (status < 0)
3231 goto error;
3232 status = write16(state, SCU_RAM_AGC_CLP_DIR_STP__A, 1);
3233 if (status < 0)
3234 goto error;
3235 status = write16(state, SCU_RAM_AGC_SNS_SUM__A, 0);
3236 if (status < 0)
3237 goto error;
3238 status = write16(state, SCU_RAM_AGC_SNS_CYCCNT__A, 0);
3239 if (status < 0)
3240 goto error;
3241 status = write16(state, SCU_RAM_AGC_SNS_DIR_WD__A, 0);
3242 if (status < 0)
3243 goto error;
3244 status = write16(state, SCU_RAM_AGC_SNS_DIR_STP__A, 1);
3245 if (status < 0)
3246 goto error;
3247 status = write16(state, SCU_RAM_AGC_SNS_CYCLEN__A, 500);
3248 if (status < 0)
3249 goto error;
3250 status = write16(state, SCU_RAM_AGC_KI_CYCLEN__A, 500);
3251 if (status < 0)
3252 goto error;
3253
3254 /* Initialize inner-loop KI gain factors */
3255 status = read16(state, SCU_RAM_AGC_KI__A, &data);
3256 if (status < 0)
3257 goto error;
3258
3259 data = 0x0657;
3260 data &= ~SCU_RAM_AGC_KI_RF__M;
3261 data |= (DRXK_KI_RAGC_QAM << SCU_RAM_AGC_KI_RF__B);
3262 data &= ~SCU_RAM_AGC_KI_IF__M;
3263 data |= (DRXK_KI_IAGC_QAM << SCU_RAM_AGC_KI_IF__B);
3264
3265 status = write16(state, SCU_RAM_AGC_KI__A, data);
3266 error:
3267 if (status < 0)
3268 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3269 return status;
3270 }
3271
3272 static int DVBTQAMGetAccPktErr(struct drxk_state *state, u16 *packetErr)
3273 {
3274 int status;
3275
3276 dprintk(1, "\n");
3277 if (packetErr == NULL)
3278 status = write16(state, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, 0);
3279 else
3280 status = read16(state, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, packetErr);
3281 if (status < 0)
3282 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3283 return status;
3284 }
3285
3286 static int DVBTScCommand(struct drxk_state *state,
3287 u16 cmd, u16 subcmd,
3288 u16 param0, u16 param1, u16 param2,
3289 u16 param3, u16 param4)
3290 {
3291 u16 curCmd = 0;
3292 u16 errCode = 0;
3293 u16 retryCnt = 0;
3294 u16 scExec = 0;
3295 int status;
3296
3297 dprintk(1, "\n");
3298 status = read16(state, OFDM_SC_COMM_EXEC__A, &scExec);
3299 if (scExec != 1) {
3300 /* SC is not running */
3301 status = -EINVAL;
3302 }
3303 if (status < 0)
3304 goto error;
3305
3306 /* Wait until sc is ready to receive command */
3307 retryCnt = 0;
3308 do {
3309 msleep(1);
3310 status = read16(state, OFDM_SC_RA_RAM_CMD__A, &curCmd);
3311 retryCnt++;
3312 } while ((curCmd != 0) && (retryCnt < DRXK_MAX_RETRIES));
3313 if (retryCnt >= DRXK_MAX_RETRIES && (status < 0))
3314 goto error;
3315
3316 /* Write sub-command */
3317 switch (cmd) {
3318 /* All commands using sub-cmd */
3319 case OFDM_SC_RA_RAM_CMD_PROC_START:
3320 case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3321 case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3322 status = write16(state, OFDM_SC_RA_RAM_CMD_ADDR__A, subcmd);
3323 if (status < 0)
3324 goto error;
3325 break;
3326 default:
3327 /* Do nothing */
3328 break;
3329 }
3330
3331 /* Write needed parameters and the command */
3332 switch (cmd) {
3333 /* All commands using 5 parameters */
3334 /* All commands using 4 parameters */
3335 /* All commands using 3 parameters */
3336 /* All commands using 2 parameters */
3337 case OFDM_SC_RA_RAM_CMD_PROC_START:
3338 case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3339 case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3340 status = write16(state, OFDM_SC_RA_RAM_PARAM1__A, param1);
3341 /* All commands using 1 parameters */
3342 case OFDM_SC_RA_RAM_CMD_SET_ECHO_TIMING:
3343 case OFDM_SC_RA_RAM_CMD_USER_IO:
3344 status = write16(state, OFDM_SC_RA_RAM_PARAM0__A, param0);
3345 /* All commands using 0 parameters */
3346 case OFDM_SC_RA_RAM_CMD_GET_OP_PARAM:
3347 case OFDM_SC_RA_RAM_CMD_NULL:
3348 /* Write command */
3349 status = write16(state, OFDM_SC_RA_RAM_CMD__A, cmd);
3350 break;
3351 default:
3352 /* Unknown command */
3353 status = -EINVAL;
3354 }
3355 if (status < 0)
3356 goto error;
3357
3358 /* Wait until sc is ready processing command */
3359 retryCnt = 0;
3360 do {
3361 msleep(1);
3362 status = read16(state, OFDM_SC_RA_RAM_CMD__A, &curCmd);
3363 retryCnt++;
3364 } while ((curCmd != 0) && (retryCnt < DRXK_MAX_RETRIES));
3365 if (retryCnt >= DRXK_MAX_RETRIES && (status < 0))
3366 goto error;
3367
3368 /* Check for illegal cmd */
3369 status = read16(state, OFDM_SC_RA_RAM_CMD_ADDR__A, &errCode);
3370 if (errCode == 0xFFFF) {
3371 /* illegal command */
3372 status = -EINVAL;
3373 }
3374 if (status < 0)
3375 goto error;
3376
3377 /* Retreive results parameters from SC */
3378 switch (cmd) {
3379 /* All commands yielding 5 results */
3380 /* All commands yielding 4 results */
3381 /* All commands yielding 3 results */
3382 /* All commands yielding 2 results */
3383 /* All commands yielding 1 result */
3384 case OFDM_SC_RA_RAM_CMD_USER_IO:
3385 case OFDM_SC_RA_RAM_CMD_GET_OP_PARAM:
3386 status = read16(state, OFDM_SC_RA_RAM_PARAM0__A, &(param0));
3387 /* All commands yielding 0 results */
3388 case OFDM_SC_RA_RAM_CMD_SET_ECHO_TIMING:
3389 case OFDM_SC_RA_RAM_CMD_SET_TIMER:
3390 case OFDM_SC_RA_RAM_CMD_PROC_START:
3391 case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3392 case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3393 case OFDM_SC_RA_RAM_CMD_NULL:
3394 break;
3395 default:
3396 /* Unknown command */
3397 status = -EINVAL;
3398 break;
3399 } /* switch (cmd->cmd) */
3400 error:
3401 if (status < 0)
3402 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3403 return status;
3404 }
3405
3406 static int PowerUpDVBT(struct drxk_state *state)
3407 {
3408 enum DRXPowerMode powerMode = DRX_POWER_UP;
3409 int status;
3410
3411 dprintk(1, "\n");
3412 status = CtrlPowerMode(state, &powerMode);
3413 if (status < 0)
3414 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3415 return status;
3416 }
3417
3418 static int DVBTCtrlSetIncEnable(struct drxk_state *state, bool *enabled)
3419 {
3420 int status;
3421
3422 dprintk(1, "\n");
3423 if (*enabled == true)
3424 status = write16(state, IQM_CF_BYPASSDET__A, 0);
3425 else
3426 status = write16(state, IQM_CF_BYPASSDET__A, 1);
3427 if (status < 0)
3428 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3429 return status;
3430 }
3431
3432 #define DEFAULT_FR_THRES_8K 4000
3433 static int DVBTCtrlSetFrEnable(struct drxk_state *state, bool *enabled)
3434 {
3435
3436 int status;
3437
3438 dprintk(1, "\n");
3439 if (*enabled == true) {
3440 /* write mask to 1 */
3441 status = write16(state, OFDM_SC_RA_RAM_FR_THRES_8K__A,
3442 DEFAULT_FR_THRES_8K);
3443 } else {
3444 /* write mask to 0 */
3445 status = write16(state, OFDM_SC_RA_RAM_FR_THRES_8K__A, 0);
3446 }
3447 if (status < 0)
3448 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3449
3450 return status;
3451 }
3452
3453 static int DVBTCtrlSetEchoThreshold(struct drxk_state *state,
3454 struct DRXKCfgDvbtEchoThres_t *echoThres)
3455 {
3456 u16 data = 0;
3457 int status;
3458
3459 dprintk(1, "\n");
3460 status = read16(state, OFDM_SC_RA_RAM_ECHO_THRES__A, &data);
3461 if (status < 0)
3462 goto error;
3463
3464 switch (echoThres->fftMode) {
3465 case DRX_FFTMODE_2K:
3466 data &= ~OFDM_SC_RA_RAM_ECHO_THRES_2K__M;
3467 data |= ((echoThres->threshold <<
3468 OFDM_SC_RA_RAM_ECHO_THRES_2K__B)
3469 & (OFDM_SC_RA_RAM_ECHO_THRES_2K__M));
3470 break;
3471 case DRX_FFTMODE_8K:
3472 data &= ~OFDM_SC_RA_RAM_ECHO_THRES_8K__M;
3473 data |= ((echoThres->threshold <<
3474 OFDM_SC_RA_RAM_ECHO_THRES_8K__B)
3475 & (OFDM_SC_RA_RAM_ECHO_THRES_8K__M));
3476 break;
3477 default:
3478 return -EINVAL;
3479 }
3480
3481 status = write16(state, OFDM_SC_RA_RAM_ECHO_THRES__A, data);
3482 error:
3483 if (status < 0)
3484 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3485 return status;
3486 }
3487
3488 static int DVBTCtrlSetSqiSpeed(struct drxk_state *state,
3489 enum DRXKCfgDvbtSqiSpeed *speed)
3490 {
3491 int status = -EINVAL;
3492
3493 dprintk(1, "\n");
3494
3495 switch (*speed) {
3496 case DRXK_DVBT_SQI_SPEED_FAST:
3497 case DRXK_DVBT_SQI_SPEED_MEDIUM:
3498 case DRXK_DVBT_SQI_SPEED_SLOW:
3499 break;
3500 default:
3501 goto error;
3502 }
3503 status = write16(state, SCU_RAM_FEC_PRE_RS_BER_FILTER_SH__A,
3504 (u16) *speed);
3505 error:
3506 if (status < 0)
3507 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3508 return status;
3509 }
3510
3511 /*============================================================================*/
3512
3513 /**
3514 * \brief Activate DVBT specific presets
3515 * \param demod instance of demodulator.
3516 * \return DRXStatus_t.
3517 *
3518 * Called in DVBTSetStandard
3519 *
3520 */
3521 static int DVBTActivatePresets(struct drxk_state *state)
3522 {
3523 int status;
3524 bool setincenable = false;
3525 bool setfrenable = true;
3526
3527 struct DRXKCfgDvbtEchoThres_t echoThres2k = { 0, DRX_FFTMODE_2K };
3528 struct DRXKCfgDvbtEchoThres_t echoThres8k = { 0, DRX_FFTMODE_8K };
3529
3530 dprintk(1, "\n");
3531 status = DVBTCtrlSetIncEnable(state, &setincenable);
3532 if (status < 0)
3533 goto error;
3534 status = DVBTCtrlSetFrEnable(state, &setfrenable);
3535 if (status < 0)
3536 goto error;
3537 status = DVBTCtrlSetEchoThreshold(state, &echoThres2k);
3538 if (status < 0)
3539 goto error;
3540 status = DVBTCtrlSetEchoThreshold(state, &echoThres8k);
3541 if (status < 0)
3542 goto error;
3543 status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MAX__A, state->m_dvbtIfAgcCfg.IngainTgtMax);
3544 error:
3545 if (status < 0)
3546 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3547 return status;
3548 }
3549
3550 /*============================================================================*/
3551
3552 /**
3553 * \brief Initialize channelswitch-independent settings for DVBT.
3554 * \param demod instance of demodulator.
3555 * \return DRXStatus_t.
3556 *
3557 * For ROM code channel filter taps are loaded from the bootloader. For microcode
3558 * the DVB-T taps from the drxk_filters.h are used.
3559 */
3560 static int SetDVBTStandard(struct drxk_state *state,
3561 enum OperationMode oMode)
3562 {
3563 u16 cmdResult = 0;
3564 u16 data = 0;
3565 int status;
3566
3567 dprintk(1, "\n");
3568
3569 PowerUpDVBT(state);
3570 /* added antenna switch */
3571 SwitchAntennaToDVBT(state);
3572 /* send OFDM reset command */
3573 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
3574 if (status < 0)
3575 goto error;
3576
3577 /* send OFDM setenv command */
3578 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV, 0, NULL, 1, &cmdResult);
3579 if (status < 0)
3580 goto error;
3581
3582 /* reset datapath for OFDM, processors first */
3583 status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
3584 if (status < 0)
3585 goto error;
3586 status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
3587 if (status < 0)
3588 goto error;
3589 status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
3590 if (status < 0)
3591 goto error;
3592
3593 /* IQM setup */
3594 /* synchronize on ofdstate->m_festart */
3595 status = write16(state, IQM_AF_UPD_SEL__A, 1);
3596 if (status < 0)
3597 goto error;
3598 /* window size for clipping ADC detection */
3599 status = write16(state, IQM_AF_CLP_LEN__A, 0);
3600 if (status < 0)
3601 goto error;
3602 /* window size for for sense pre-SAW detection */
3603 status = write16(state, IQM_AF_SNS_LEN__A, 0);
3604 if (status < 0)
3605 goto error;
3606 /* sense threshold for sense pre-SAW detection */
3607 status = write16(state, IQM_AF_AMUX__A, IQM_AF_AMUX_SIGNAL2ADC);
3608 if (status < 0)
3609 goto error;
3610 status = SetIqmAf(state, true);
3611 if (status < 0)
3612 goto error;
3613
3614 status = write16(state, IQM_AF_AGC_RF__A, 0);
3615 if (status < 0)
3616 goto error;
3617
3618 /* Impulse noise cruncher setup */
3619 status = write16(state, IQM_AF_INC_LCT__A, 0); /* crunch in IQM_CF */
3620 if (status < 0)
3621 goto error;
3622 status = write16(state, IQM_CF_DET_LCT__A, 0); /* detect in IQM_CF */
3623 if (status < 0)
3624 goto error;
3625 status = write16(state, IQM_CF_WND_LEN__A, 3); /* peak detector window length */
3626 if (status < 0)
3627 goto error;
3628
3629 status = write16(state, IQM_RC_STRETCH__A, 16);
3630 if (status < 0)
3631 goto error;
3632 status = write16(state, IQM_CF_OUT_ENA__A, 0x4); /* enable output 2 */
3633 if (status < 0)
3634 goto error;
3635 status = write16(state, IQM_CF_DS_ENA__A, 0x4); /* decimate output 2 */
3636 if (status < 0)
3637 goto error;
3638 status = write16(state, IQM_CF_SCALE__A, 1600);
3639 if (status < 0)
3640 goto error;
3641 status = write16(state, IQM_CF_SCALE_SH__A, 0);
3642 if (status < 0)
3643 goto error;
3644
3645 /* virtual clipping threshold for clipping ADC detection */
3646 status = write16(state, IQM_AF_CLP_TH__A, 448);
3647 if (status < 0)
3648 goto error;
3649 status = write16(state, IQM_CF_DATATH__A, 495); /* crunching threshold */
3650 if (status < 0)
3651 goto error;
3652
3653 status = BLChainCmd(state, DRXK_BL_ROM_OFFSET_TAPS_DVBT, DRXK_BLCC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
3654 if (status < 0)
3655 goto error;
3656
3657 status = write16(state, IQM_CF_PKDTH__A, 2); /* peak detector threshold */
3658 if (status < 0)
3659 goto error;
3660 status = write16(state, IQM_CF_POW_MEAS_LEN__A, 2);
3661 if (status < 0)
3662 goto error;
3663 /* enable power measurement interrupt */
3664 status = write16(state, IQM_CF_COMM_INT_MSK__A, 1);
3665 if (status < 0)
3666 goto error;
3667 status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_ACTIVE);
3668 if (status < 0)
3669 goto error;
3670
3671 /* IQM will not be reset from here, sync ADC and update/init AGC */
3672 status = ADCSynchronization(state);
3673 if (status < 0)
3674 goto error;
3675 status = SetPreSaw(state, &state->m_dvbtPreSawCfg);
3676 if (status < 0)
3677 goto error;
3678
3679 /* Halt SCU to enable safe non-atomic accesses */
3680 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
3681 if (status < 0)
3682 goto error;
3683
3684 status = SetAgcRf(state, &state->m_dvbtRfAgcCfg, true);
3685 if (status < 0)
3686 goto error;
3687 status = SetAgcIf(state, &state->m_dvbtIfAgcCfg, true);
3688 if (status < 0)
3689 goto error;
3690
3691 /* Set Noise Estimation notch width and enable DC fix */
3692 status = read16(state, OFDM_SC_RA_RAM_CONFIG__A, &data);
3693 if (status < 0)
3694 goto error;
3695 data |= OFDM_SC_RA_RAM_CONFIG_NE_FIX_ENABLE__M;
3696 status = write16(state, OFDM_SC_RA_RAM_CONFIG__A, data);
3697 if (status < 0)
3698 goto error;
3699
3700 /* Activate SCU to enable SCU commands */
3701 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
3702 if (status < 0)
3703 goto error;
3704
3705 if (!state->m_DRXK_A3_ROM_CODE) {
3706 /* AGCInit() is not done for DVBT, so set agcFastClipCtrlDelay */
3707 status = write16(state, SCU_RAM_AGC_FAST_CLP_CTRL_DELAY__A, state->m_dvbtIfAgcCfg.FastClipCtrlDelay);
3708 if (status < 0)
3709 goto error;
3710 }
3711
3712 /* OFDM_SC setup */
3713 #ifdef COMPILE_FOR_NONRT
3714 status = write16(state, OFDM_SC_RA_RAM_BE_OPT_DELAY__A, 1);
3715 if (status < 0)
3716 goto error;
3717 status = write16(state, OFDM_SC_RA_RAM_BE_OPT_INIT_DELAY__A, 2);
3718 if (status < 0)
3719 goto error;
3720 #endif
3721
3722 /* FEC setup */
3723 status = write16(state, FEC_DI_INPUT_CTL__A, 1); /* OFDM input */
3724 if (status < 0)
3725 goto error;
3726
3727
3728 #ifdef COMPILE_FOR_NONRT
3729 status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, 0x400);
3730 if (status < 0)
3731 goto error;
3732 #else
3733 status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, 0x1000);
3734 if (status < 0)
3735 goto error;
3736 #endif
3737 status = write16(state, FEC_RS_MEASUREMENT_PRESCALE__A, 0x0001);
3738 if (status < 0)
3739 goto error;
3740
3741 /* Setup MPEG bus */
3742 status = MPEGTSDtoSetup(state, OM_DVBT);
3743 if (status < 0)
3744 goto error;
3745 /* Set DVBT Presets */
3746 status = DVBTActivatePresets(state);
3747 if (status < 0)
3748 goto error;
3749
3750 error:
3751 if (status < 0)
3752 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3753 return status;
3754 }
3755
3756 /*============================================================================*/
3757 /**
3758 * \brief Start dvbt demodulating for channel.
3759 * \param demod instance of demodulator.
3760 * \return DRXStatus_t.
3761 */
3762 static int DVBTStart(struct drxk_state *state)
3763 {
3764 u16 param1;
3765 int status;
3766 /* DRXKOfdmScCmd_t scCmd; */
3767
3768 dprintk(1, "\n");
3769 /* Start correct processes to get in lock */
3770 /* DRXK: OFDM_SC_RA_RAM_PROC_LOCKTRACK is no longer in mapfile! */
3771 param1 = OFDM_SC_RA_RAM_LOCKTRACK_MIN;
3772 status = DVBTScCommand(state, OFDM_SC_RA_RAM_CMD_PROC_START, 0, OFDM_SC_RA_RAM_SW_EVENT_RUN_NMASK__M, param1, 0, 0, 0);
3773 if (status < 0)
3774 goto error;
3775 /* Start FEC OC */
3776 status = MPEGTSStart(state);
3777 if (status < 0)
3778 goto error;
3779 status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE);
3780 if (status < 0)
3781 goto error;
3782 error:
3783 if (status < 0)
3784 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3785 return status;
3786 }
3787
3788
3789 /*============================================================================*/
3790
3791 /**
3792 * \brief Set up dvbt demodulator for channel.
3793 * \param demod instance of demodulator.
3794 * \return DRXStatus_t.
3795 * // original DVBTSetChannel()
3796 */
3797 static int SetDVBT(struct drxk_state *state, u16 IntermediateFreqkHz,
3798 s32 tunerFreqOffset)
3799 {
3800 u16 cmdResult = 0;
3801 u16 transmissionParams = 0;
3802 u16 operationMode = 0;
3803 u32 iqmRcRateOfs = 0;
3804 u32 bandwidth = 0;
3805 u16 param1;
3806 int status;
3807
3808 dprintk(1, "IF =%d, TFO = %d\n", IntermediateFreqkHz, tunerFreqOffset);
3809
3810 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
3811 if (status < 0)
3812 goto error;
3813
3814 /* Halt SCU to enable safe non-atomic accesses */
3815 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
3816 if (status < 0)
3817 goto error;
3818
3819 /* Stop processors */
3820 status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
3821 if (status < 0)
3822 goto error;
3823 status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
3824 if (status < 0)
3825 goto error;
3826
3827 /* Mandatory fix, always stop CP, required to set spl offset back to
3828 hardware default (is set to 0 by ucode during pilot detection */
3829 status = write16(state, OFDM_CP_COMM_EXEC__A, OFDM_CP_COMM_EXEC_STOP);
3830 if (status < 0)
3831 goto error;
3832
3833 /*== Write channel settings to device =====================================*/
3834
3835 /* mode */
3836 switch (state->props.transmission_mode) {
3837 case TRANSMISSION_MODE_AUTO:
3838 default:
3839 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_MODE__M;
3840 /* fall through , try first guess DRX_FFTMODE_8K */
3841 case TRANSMISSION_MODE_8K:
3842 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_MODE_8K;
3843 break;
3844 case TRANSMISSION_MODE_2K:
3845 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_MODE_2K;
3846 break;
3847 }
3848
3849 /* guard */
3850 switch (state->props.guard_interval) {
3851 default:
3852 case GUARD_INTERVAL_AUTO:
3853 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_GUARD__M;
3854 /* fall through , try first guess DRX_GUARD_1DIV4 */
3855 case GUARD_INTERVAL_1_4:
3856 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_4;
3857 break;
3858 case GUARD_INTERVAL_1_32:
3859 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_32;
3860 break;
3861 case GUARD_INTERVAL_1_16:
3862 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_16;
3863 break;
3864 case GUARD_INTERVAL_1_8:
3865 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_8;
3866 break;
3867 }
3868
3869 /* hierarchy */
3870 switch (state->props.hierarchy) {
3871 case HIERARCHY_AUTO:
3872 case HIERARCHY_NONE:
3873 default:
3874 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_HIER__M;
3875 /* fall through , try first guess SC_RA_RAM_OP_PARAM_HIER_NO */
3876 /* transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_NO; */
3877 /* break; */
3878 case HIERARCHY_1:
3879 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A1;
3880 break;
3881 case HIERARCHY_2:
3882 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A2;
3883 break;
3884 case HIERARCHY_4:
3885 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A4;
3886 break;
3887 }
3888
3889
3890 /* modulation */
3891 switch (state->props.modulation) {
3892 case QAM_AUTO:
3893 default:
3894 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_CONST__M;
3895 /* fall through , try first guess DRX_CONSTELLATION_QAM64 */
3896 case QAM_64:
3897 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QAM64;
3898 break;
3899 case QPSK:
3900 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QPSK;
3901 break;
3902 case QAM_16:
3903 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QAM16;
3904 break;
3905 }
3906 #if 0
3907 /* No hierachical channels support in BDA */
3908 /* Priority (only for hierarchical channels) */
3909 switch (channel->priority) {
3910 case DRX_PRIORITY_LOW:
3911 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_LO;
3912 WR16(devAddr, OFDM_EC_SB_PRIOR__A,
3913 OFDM_EC_SB_PRIOR_LO);
3914 break;
3915 case DRX_PRIORITY_HIGH:
3916 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_HI;
3917 WR16(devAddr, OFDM_EC_SB_PRIOR__A,
3918 OFDM_EC_SB_PRIOR_HI));
3919 break;
3920 case DRX_PRIORITY_UNKNOWN: /* fall through */
3921 default:
3922 status = -EINVAL;
3923 goto error;
3924 }
3925 #else
3926 /* Set Priorty high */
3927 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_HI;
3928 status = write16(state, OFDM_EC_SB_PRIOR__A, OFDM_EC_SB_PRIOR_HI);
3929 if (status < 0)
3930 goto error;
3931 #endif
3932
3933 /* coderate */
3934 switch (state->props.code_rate_HP) {
3935 case FEC_AUTO:
3936 default:
3937 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_RATE__M;
3938 /* fall through , try first guess DRX_CODERATE_2DIV3 */
3939 case FEC_2_3:
3940 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_2_3;
3941 break;
3942 case FEC_1_2:
3943 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_1_2;
3944 break;
3945 case FEC_3_4:
3946 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_3_4;
3947 break;
3948 case FEC_5_6:
3949 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_5_6;
3950 break;
3951 case FEC_7_8:
3952 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_7_8;
3953 break;
3954 }
3955
3956 /* SAW filter selection: normaly not necesarry, but if wanted
3957 the application can select a SAW filter via the driver by using UIOs */
3958 /* First determine real bandwidth (Hz) */
3959 /* Also set delay for impulse noise cruncher */
3960 /* Also set parameters for EC_OC fix, note EC_OC_REG_TMD_HIL_MAR is changed
3961 by SC for fix for some 8K,1/8 guard but is restored by InitEC and ResetEC
3962 functions */
3963 switch (state->props.bandwidth_hz) {
3964 case 0:
3965 state->props.bandwidth_hz = 8000000;
3966 /* fall though */
3967 case 8000000:
3968 bandwidth = DRXK_BANDWIDTH_8MHZ_IN_HZ;
3969 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3052);
3970 if (status < 0)
3971 goto error;
3972 /* cochannel protection for PAL 8 MHz */
3973 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 7);
3974 if (status < 0)
3975 goto error;
3976 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 7);
3977 if (status < 0)
3978 goto error;
3979 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 7);
3980 if (status < 0)
3981 goto error;
3982 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
3983 if (status < 0)
3984 goto error;
3985 break;
3986 case 7000000:
3987 bandwidth = DRXK_BANDWIDTH_7MHZ_IN_HZ;
3988 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3491);
3989 if (status < 0)
3990 goto error;
3991 /* cochannel protection for PAL 7 MHz */
3992 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 8);
3993 if (status < 0)
3994 goto error;
3995 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 8);
3996 if (status < 0)
3997 goto error;
3998 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 4);
3999 if (status < 0)
4000 goto error;
4001 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
4002 if (status < 0)
4003 goto error;
4004 break;
4005 case 6000000:
4006 bandwidth = DRXK_BANDWIDTH_6MHZ_IN_HZ;
4007 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 4073);
4008 if (status < 0)
4009 goto error;
4010 /* cochannel protection for NTSC 6 MHz */
4011 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 19);
4012 if (status < 0)
4013 goto error;
4014 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 19);
4015 if (status < 0)
4016 goto error;
4017 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 14);
4018 if (status < 0)
4019 goto error;
4020 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
4021 if (status < 0)
4022 goto error;
4023 break;
4024 default:
4025 status = -EINVAL;
4026 goto error;
4027 }
4028
4029 if (iqmRcRateOfs == 0) {
4030 /* Now compute IQM_RC_RATE_OFS
4031 (((SysFreq/BandWidth)/2)/2) -1) * 2^23)
4032 =>
4033 ((SysFreq / BandWidth) * (2^21)) - (2^23)
4034 */
4035 /* (SysFreq / BandWidth) * (2^28) */
4036 /* assert (MAX(sysClk)/MIN(bandwidth) < 16)
4037 => assert(MAX(sysClk) < 16*MIN(bandwidth))
4038 => assert(109714272 > 48000000) = true so Frac 28 can be used */
4039 iqmRcRateOfs = Frac28a((u32)
4040 ((state->m_sysClockFreq *
4041 1000) / 3), bandwidth);
4042 /* (SysFreq / BandWidth) * (2^21), rounding before truncating */
4043 if ((iqmRcRateOfs & 0x7fL) >= 0x40)
4044 iqmRcRateOfs += 0x80L;
4045 iqmRcRateOfs = iqmRcRateOfs >> 7;
4046 /* ((SysFreq / BandWidth) * (2^21)) - (2^23) */
4047 iqmRcRateOfs = iqmRcRateOfs - (1 << 23);
4048 }
4049
4050 iqmRcRateOfs &=
4051 ((((u32) IQM_RC_RATE_OFS_HI__M) <<
4052 IQM_RC_RATE_OFS_LO__W) | IQM_RC_RATE_OFS_LO__M);
4053 status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRateOfs);
4054 if (status < 0)
4055 goto error;
4056
4057 /* Bandwidth setting done */
4058
4059 #if 0
4060 status = DVBTSetFrequencyShift(demod, channel, tunerOffset);
4061 if (status < 0)
4062 goto error;
4063 #endif
4064 status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
4065 if (status < 0)
4066 goto error;
4067
4068 /*== Start SC, write channel settings to SC ===============================*/
4069
4070 /* Activate SCU to enable SCU commands */
4071 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
4072 if (status < 0)
4073 goto error;
4074
4075 /* Enable SC after setting all other parameters */
4076 status = write16(state, OFDM_SC_COMM_STATE__A, 0);
4077 if (status < 0)
4078 goto error;
4079 status = write16(state, OFDM_SC_COMM_EXEC__A, 1);
4080 if (status < 0)
4081 goto error;
4082
4083
4084 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
4085 if (status < 0)
4086 goto error;
4087
4088 /* Write SC parameter registers, set all AUTO flags in operation mode */
4089 param1 = (OFDM_SC_RA_RAM_OP_AUTO_MODE__M |
4090 OFDM_SC_RA_RAM_OP_AUTO_GUARD__M |
4091 OFDM_SC_RA_RAM_OP_AUTO_CONST__M |
4092 OFDM_SC_RA_RAM_OP_AUTO_HIER__M |
4093 OFDM_SC_RA_RAM_OP_AUTO_RATE__M);
4094 status = DVBTScCommand(state, OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM,
4095 0, transmissionParams, param1, 0, 0, 0);
4096 if (status < 0)
4097 goto error;
4098
4099 if (!state->m_DRXK_A3_ROM_CODE)
4100 status = DVBTCtrlSetSqiSpeed(state, &state->m_sqiSpeed);
4101 error:
4102 if (status < 0)
4103 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4104
4105 return status;
4106 }
4107
4108
4109 /*============================================================================*/
4110
4111 /**
4112 * \brief Retreive lock status .
4113 * \param demod Pointer to demodulator instance.
4114 * \param lockStat Pointer to lock status structure.
4115 * \return DRXStatus_t.
4116 *
4117 */
4118 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus)
4119 {
4120 int status;
4121 const u16 mpeg_lock_mask = (OFDM_SC_RA_RAM_LOCK_MPEG__M |
4122 OFDM_SC_RA_RAM_LOCK_FEC__M);
4123 const u16 fec_lock_mask = (OFDM_SC_RA_RAM_LOCK_FEC__M);
4124 const u16 demod_lock_mask = OFDM_SC_RA_RAM_LOCK_DEMOD__M;
4125
4126 u16 ScRaRamLock = 0;
4127 u16 ScCommExec = 0;
4128
4129 dprintk(1, "\n");
4130
4131 *pLockStatus = NOT_LOCKED;
4132 /* driver 0.9.0 */
4133 /* Check if SC is running */
4134 status = read16(state, OFDM_SC_COMM_EXEC__A, &ScCommExec);
4135 if (status < 0)
4136 goto end;
4137 if (ScCommExec == OFDM_SC_COMM_EXEC_STOP)
4138 goto end;
4139
4140 status = read16(state, OFDM_SC_RA_RAM_LOCK__A, &ScRaRamLock);
4141 if (status < 0)
4142 goto end;
4143
4144 if ((ScRaRamLock & mpeg_lock_mask) == mpeg_lock_mask)
4145 *pLockStatus = MPEG_LOCK;
4146 else if ((ScRaRamLock & fec_lock_mask) == fec_lock_mask)
4147 *pLockStatus = FEC_LOCK;
4148 else if ((ScRaRamLock & demod_lock_mask) == demod_lock_mask)
4149 *pLockStatus = DEMOD_LOCK;
4150 else if (ScRaRamLock & OFDM_SC_RA_RAM_LOCK_NODVBT__M)
4151 *pLockStatus = NEVER_LOCK;
4152 end:
4153 if (status < 0)
4154 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4155
4156 return status;
4157 }
4158
4159 static int PowerUpQAM(struct drxk_state *state)
4160 {
4161 enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
4162 int status;
4163
4164 dprintk(1, "\n");
4165 status = CtrlPowerMode(state, &powerMode);
4166 if (status < 0)
4167 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4168
4169 return status;
4170 }
4171
4172
4173 /** Power Down QAM */
4174 static int PowerDownQAM(struct drxk_state *state)
4175 {
4176 u16 data = 0;
4177 u16 cmdResult;
4178 int status = 0;
4179
4180 dprintk(1, "\n");
4181 status = read16(state, SCU_COMM_EXEC__A, &data);
4182 if (status < 0)
4183 goto error;
4184 if (data == SCU_COMM_EXEC_ACTIVE) {
4185 /*
4186 STOP demodulator
4187 QAM and HW blocks
4188 */
4189 /* stop all comstate->m_exec */
4190 status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
4191 if (status < 0)
4192 goto error;
4193 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
4194 if (status < 0)
4195 goto error;
4196 }
4197 /* powerdown AFE */
4198 status = SetIqmAf(state, false);
4199
4200 error:
4201 if (status < 0)
4202 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4203
4204 return status;
4205 }
4206
4207 /*============================================================================*/
4208
4209 /**
4210 * \brief Setup of the QAM Measurement intervals for signal quality
4211 * \param demod instance of demod.
4212 * \param modulation current modulation.
4213 * \return DRXStatus_t.
4214 *
4215 * NOTE:
4216 * Take into account that for certain settings the errorcounters can overflow.
4217 * The implementation does not check this.
4218 *
4219 */
4220 static int SetQAMMeasurement(struct drxk_state *state,
4221 enum EDrxkConstellation modulation,
4222 u32 symbolRate)
4223 {
4224 u32 fecBitsDesired = 0; /* BER accounting period */
4225 u32 fecRsPeriodTotal = 0; /* Total period */
4226 u16 fecRsPrescale = 0; /* ReedSolomon Measurement Prescale */
4227 u16 fecRsPeriod = 0; /* Value for corresponding I2C register */
4228 int status = 0;
4229
4230 dprintk(1, "\n");
4231
4232 fecRsPrescale = 1;
4233 /* fecBitsDesired = symbolRate [kHz] *
4234 FrameLenght [ms] *
4235 (modulation + 1) *
4236 SyncLoss (== 1) *
4237 ViterbiLoss (==1)
4238 */
4239 switch (modulation) {
4240 case DRX_CONSTELLATION_QAM16:
4241 fecBitsDesired = 4 * symbolRate;
4242 break;
4243 case DRX_CONSTELLATION_QAM32:
4244 fecBitsDesired = 5 * symbolRate;
4245 break;
4246 case DRX_CONSTELLATION_QAM64:
4247 fecBitsDesired = 6 * symbolRate;
4248 break;
4249 case DRX_CONSTELLATION_QAM128:
4250 fecBitsDesired = 7 * symbolRate;
4251 break;
4252 case DRX_CONSTELLATION_QAM256:
4253 fecBitsDesired = 8 * symbolRate;
4254 break;
4255 default:
4256 status = -EINVAL;
4257 }
4258 if (status < 0)
4259 goto error;
4260
4261 fecBitsDesired /= 1000; /* symbolRate [Hz] -> symbolRate [kHz] */
4262 fecBitsDesired *= 500; /* meas. period [ms] */
4263
4264 /* Annex A/C: bits/RsPeriod = 204 * 8 = 1632 */
4265 /* fecRsPeriodTotal = fecBitsDesired / 1632 */
4266 fecRsPeriodTotal = (fecBitsDesired / 1632UL) + 1; /* roughly ceil */
4267
4268 /* fecRsPeriodTotal = fecRsPrescale * fecRsPeriod */
4269 fecRsPrescale = 1 + (u16) (fecRsPeriodTotal >> 16);
4270 if (fecRsPrescale == 0) {
4271 /* Divide by zero (though impossible) */
4272 status = -EINVAL;
4273 if (status < 0)
4274 goto error;
4275 }
4276 fecRsPeriod =
4277 ((u16) fecRsPeriodTotal +
4278 (fecRsPrescale >> 1)) / fecRsPrescale;
4279
4280 /* write corresponding registers */
4281 status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, fecRsPeriod);
4282 if (status < 0)
4283 goto error;
4284 status = write16(state, FEC_RS_MEASUREMENT_PRESCALE__A, fecRsPrescale);
4285 if (status < 0)
4286 goto error;
4287 status = write16(state, FEC_OC_SNC_FAIL_PERIOD__A, fecRsPeriod);
4288 error:
4289 if (status < 0)
4290 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4291 return status;
4292 }
4293
4294 static int SetQAM16(struct drxk_state *state)
4295 {
4296 int status = 0;
4297
4298 dprintk(1, "\n");
4299 /* QAM Equalizer Setup */
4300 /* Equalizer */
4301 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13517);
4302 if (status < 0)
4303 goto error;
4304 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 13517);
4305 if (status < 0)
4306 goto error;
4307 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 13517);
4308 if (status < 0)
4309 goto error;
4310 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13517);
4311 if (status < 0)
4312 goto error;
4313 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13517);
4314 if (status < 0)
4315 goto error;
4316 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 13517);
4317 if (status < 0)
4318 goto error;
4319 /* Decision Feedback Equalizer */
4320 status = write16(state, QAM_DQ_QUAL_FUN0__A, 2);
4321 if (status < 0)
4322 goto error;
4323 status = write16(state, QAM_DQ_QUAL_FUN1__A, 2);
4324 if (status < 0)
4325 goto error;
4326 status = write16(state, QAM_DQ_QUAL_FUN2__A, 2);
4327 if (status < 0)
4328 goto error;
4329 status = write16(state, QAM_DQ_QUAL_FUN3__A, 2);
4330 if (status < 0)
4331 goto error;
4332 status = write16(state, QAM_DQ_QUAL_FUN4__A, 2);
4333 if (status < 0)
4334 goto error;
4335 status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4336 if (status < 0)
4337 goto error;
4338
4339 status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4340 if (status < 0)
4341 goto error;
4342 status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4343 if (status < 0)
4344 goto error;
4345 status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4346 if (status < 0)
4347 goto error;
4348
4349 /* QAM Slicer Settings */
4350 status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM16);
4351 if (status < 0)
4352 goto error;
4353
4354 /* QAM Loop Controller Coeficients */
4355 status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4356 if (status < 0)
4357 goto error;
4358 status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4359 if (status < 0)
4360 goto error;
4361 status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4362 if (status < 0)
4363 goto error;
4364 status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4365 if (status < 0)
4366 goto error;
4367 status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4368 if (status < 0)
4369 goto error;
4370 status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4371 if (status < 0)
4372 goto error;
4373 status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4374 if (status < 0)
4375 goto error;
4376 status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4377 if (status < 0)
4378 goto error;
4379
4380 status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4381 if (status < 0)
4382 goto error;
4383 status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4384 if (status < 0)
4385 goto error;
4386 status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4387 if (status < 0)
4388 goto error;
4389 status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4390 if (status < 0)
4391 goto error;
4392 status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4393 if (status < 0)
4394 goto error;
4395 status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4396 if (status < 0)
4397 goto error;
4398 status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4399 if (status < 0)
4400 goto error;
4401 status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4402 if (status < 0)
4403 goto error;
4404 status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 32);
4405 if (status < 0)
4406 goto error;
4407 status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4408 if (status < 0)
4409 goto error;
4410 status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4411 if (status < 0)
4412 goto error;
4413 status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4414 if (status < 0)
4415 goto error;
4416
4417
4418 /* QAM State Machine (FSM) Thresholds */
4419
4420 status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 140);
4421 if (status < 0)
4422 goto error;
4423 status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4424 if (status < 0)
4425 goto error;
4426 status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 95);
4427 if (status < 0)
4428 goto error;
4429 status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 120);
4430 if (status < 0)
4431 goto error;
4432 status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 230);
4433 if (status < 0)
4434 goto error;
4435 status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 105);
4436 if (status < 0)
4437 goto error;
4438
4439 status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4440 if (status < 0)
4441 goto error;
4442 status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4443 if (status < 0)
4444 goto error;
4445 status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 24);
4446 if (status < 0)
4447 goto error;
4448
4449
4450 /* QAM FSM Tracking Parameters */
4451
4452 status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 16);
4453 if (status < 0)
4454 goto error;
4455 status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 220);
4456 if (status < 0)
4457 goto error;
4458 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 25);
4459 if (status < 0)
4460 goto error;
4461 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 6);
4462 if (status < 0)
4463 goto error;
4464 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -24);
4465 if (status < 0)
4466 goto error;
4467 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -65);
4468 if (status < 0)
4469 goto error;
4470 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -127);
4471 if (status < 0)
4472 goto error;
4473
4474 error:
4475 if (status < 0)
4476 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4477 return status;
4478 }
4479
4480 /*============================================================================*/
4481
4482 /**
4483 * \brief QAM32 specific setup
4484 * \param demod instance of demod.
4485 * \return DRXStatus_t.
4486 */
4487 static int SetQAM32(struct drxk_state *state)
4488 {
4489 int status = 0;
4490
4491 dprintk(1, "\n");
4492
4493 /* QAM Equalizer Setup */
4494 /* Equalizer */
4495 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6707);
4496 if (status < 0)
4497 goto error;
4498 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6707);
4499 if (status < 0)
4500 goto error;
4501 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6707);
4502 if (status < 0)
4503 goto error;
4504 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6707);
4505 if (status < 0)
4506 goto error;
4507 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6707);
4508 if (status < 0)
4509 goto error;
4510 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 6707);
4511 if (status < 0)
4512 goto error;
4513
4514 /* Decision Feedback Equalizer */
4515 status = write16(state, QAM_DQ_QUAL_FUN0__A, 3);
4516 if (status < 0)
4517 goto error;
4518 status = write16(state, QAM_DQ_QUAL_FUN1__A, 3);
4519 if (status < 0)
4520 goto error;
4521 status = write16(state, QAM_DQ_QUAL_FUN2__A, 3);
4522 if (status < 0)
4523 goto error;
4524 status = write16(state, QAM_DQ_QUAL_FUN3__A, 3);
4525 if (status < 0)
4526 goto error;
4527 status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4528 if (status < 0)
4529 goto error;
4530 status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4531 if (status < 0)
4532 goto error;
4533
4534 status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4535 if (status < 0)
4536 goto error;
4537 status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4538 if (status < 0)
4539 goto error;
4540 status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4541 if (status < 0)
4542 goto error;
4543
4544 /* QAM Slicer Settings */
4545
4546 status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM32);
4547 if (status < 0)
4548 goto error;
4549
4550
4551 /* QAM Loop Controller Coeficients */
4552
4553 status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4554 if (status < 0)
4555 goto error;
4556 status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4557 if (status < 0)
4558 goto error;
4559 status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4560 if (status < 0)
4561 goto error;
4562 status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4563 if (status < 0)
4564 goto error;
4565 status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4566 if (status < 0)
4567 goto error;
4568 status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4569 if (status < 0)
4570 goto error;
4571 status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4572 if (status < 0)
4573 goto error;
4574 status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4575 if (status < 0)
4576 goto error;
4577
4578 status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4579 if (status < 0)
4580 goto error;
4581 status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4582 if (status < 0)
4583 goto error;
4584 status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4585 if (status < 0)
4586 goto error;
4587 status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4588 if (status < 0)
4589 goto error;
4590 status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4591 if (status < 0)
4592 goto error;
4593 status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4594 if (status < 0)
4595 goto error;
4596 status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4597 if (status < 0)
4598 goto error;
4599 status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4600 if (status < 0)
4601 goto error;
4602 status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 16);
4603 if (status < 0)
4604 goto error;
4605 status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4606 if (status < 0)
4607 goto error;
4608 status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4609 if (status < 0)
4610 goto error;
4611 status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
4612 if (status < 0)
4613 goto error;
4614
4615
4616 /* QAM State Machine (FSM) Thresholds */
4617
4618 status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 90);
4619 if (status < 0)
4620 goto error;
4621 status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4622 if (status < 0)
4623 goto error;
4624 status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4625 if (status < 0)
4626 goto error;
4627 status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
4628 if (status < 0)
4629 goto error;
4630 status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 170);
4631 if (status < 0)
4632 goto error;
4633 status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
4634 if (status < 0)
4635 goto error;
4636
4637 status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4638 if (status < 0)
4639 goto error;
4640 status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4641 if (status < 0)
4642 goto error;
4643 status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 10);
4644 if (status < 0)
4645 goto error;
4646
4647
4648 /* QAM FSM Tracking Parameters */
4649
4650 status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4651 if (status < 0)
4652 goto error;
4653 status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 140);
4654 if (status < 0)
4655 goto error;
4656 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) -8);
4657 if (status < 0)
4658 goto error;
4659 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) -16);
4660 if (status < 0)
4661 goto error;
4662 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -26);
4663 if (status < 0)
4664 goto error;
4665 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -56);
4666 if (status < 0)
4667 goto error;
4668 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -86);
4669 error:
4670 if (status < 0)
4671 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4672 return status;
4673 }
4674
4675 /*============================================================================*/
4676
4677 /**
4678 * \brief QAM64 specific setup
4679 * \param demod instance of demod.
4680 * \return DRXStatus_t.
4681 */
4682 static int SetQAM64(struct drxk_state *state)
4683 {
4684 int status = 0;
4685
4686 dprintk(1, "\n");
4687 /* QAM Equalizer Setup */
4688 /* Equalizer */
4689 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13336);
4690 if (status < 0)
4691 goto error;
4692 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12618);
4693 if (status < 0)
4694 goto error;
4695 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 11988);
4696 if (status < 0)
4697 goto error;
4698 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13809);
4699 if (status < 0)
4700 goto error;
4701 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13809);
4702 if (status < 0)
4703 goto error;
4704 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15609);
4705 if (status < 0)
4706 goto error;
4707
4708 /* Decision Feedback Equalizer */
4709 status = write16(state, QAM_DQ_QUAL_FUN0__A, 4);
4710 if (status < 0)
4711 goto error;
4712 status = write16(state, QAM_DQ_QUAL_FUN1__A, 4);
4713 if (status < 0)
4714 goto error;
4715 status = write16(state, QAM_DQ_QUAL_FUN2__A, 4);
4716 if (status < 0)
4717 goto error;
4718 status = write16(state, QAM_DQ_QUAL_FUN3__A, 4);
4719 if (status < 0)
4720 goto error;
4721 status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4722 if (status < 0)
4723 goto error;
4724 status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4725 if (status < 0)
4726 goto error;
4727
4728 status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4729 if (status < 0)
4730 goto error;
4731 status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4732 if (status < 0)
4733 goto error;
4734 status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4735 if (status < 0)
4736 goto error;
4737
4738 /* QAM Slicer Settings */
4739 status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM64);
4740 if (status < 0)
4741 goto error;
4742
4743
4744 /* QAM Loop Controller Coeficients */
4745
4746 status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4747 if (status < 0)
4748 goto error;
4749 status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4750 if (status < 0)
4751 goto error;
4752 status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4753 if (status < 0)
4754 goto error;
4755 status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4756 if (status < 0)
4757 goto error;
4758 status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4759 if (status < 0)
4760 goto error;
4761 status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4762 if (status < 0)
4763 goto error;
4764 status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4765 if (status < 0)
4766 goto error;
4767 status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4768 if (status < 0)
4769 goto error;
4770
4771 status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4772 if (status < 0)
4773 goto error;
4774 status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 30);
4775 if (status < 0)
4776 goto error;
4777 status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 100);
4778 if (status < 0)
4779 goto error;
4780 status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4781 if (status < 0)
4782 goto error;
4783 status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 30);
4784 if (status < 0)
4785 goto error;
4786 status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4787 if (status < 0)
4788 goto error;
4789 status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4790 if (status < 0)
4791 goto error;
4792 status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4793 if (status < 0)
4794 goto error;
4795 status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
4796 if (status < 0)
4797 goto error;
4798 status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4799 if (status < 0)
4800 goto error;
4801 status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4802 if (status < 0)
4803 goto error;
4804 status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4805 if (status < 0)
4806 goto error;
4807
4808
4809 /* QAM State Machine (FSM) Thresholds */
4810
4811 status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 100);
4812 if (status < 0)
4813 goto error;
4814 status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
4815 if (status < 0)
4816 goto error;
4817 status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4818 if (status < 0)
4819 goto error;
4820 status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 110);
4821 if (status < 0)
4822 goto error;
4823 status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 200);
4824 if (status < 0)
4825 goto error;
4826 status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 95);
4827 if (status < 0)
4828 goto error;
4829
4830 status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4831 if (status < 0)
4832 goto error;
4833 status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4834 if (status < 0)
4835 goto error;
4836 status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 15);
4837 if (status < 0)
4838 goto error;
4839
4840
4841 /* QAM FSM Tracking Parameters */
4842
4843 status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4844 if (status < 0)
4845 goto error;
4846 status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 141);
4847 if (status < 0)
4848 goto error;
4849 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 7);
4850 if (status < 0)
4851 goto error;
4852 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 0);
4853 if (status < 0)
4854 goto error;
4855 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -15);
4856 if (status < 0)
4857 goto error;
4858 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -45);
4859 if (status < 0)
4860 goto error;
4861 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -80);
4862 error:
4863 if (status < 0)
4864 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4865
4866 return status;
4867 }
4868
4869 /*============================================================================*/
4870
4871 /**
4872 * \brief QAM128 specific setup
4873 * \param demod: instance of demod.
4874 * \return DRXStatus_t.
4875 */
4876 static int SetQAM128(struct drxk_state *state)
4877 {
4878 int status = 0;
4879
4880 dprintk(1, "\n");
4881 /* QAM Equalizer Setup */
4882 /* Equalizer */
4883 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6564);
4884 if (status < 0)
4885 goto error;
4886 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6598);
4887 if (status < 0)
4888 goto error;
4889 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6394);
4890 if (status < 0)
4891 goto error;
4892 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6409);
4893 if (status < 0)
4894 goto error;
4895 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6656);
4896 if (status < 0)
4897 goto error;
4898 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 7238);
4899 if (status < 0)
4900 goto error;
4901
4902 /* Decision Feedback Equalizer */
4903 status = write16(state, QAM_DQ_QUAL_FUN0__A, 6);
4904 if (status < 0)
4905 goto error;
4906 status = write16(state, QAM_DQ_QUAL_FUN1__A, 6);
4907 if (status < 0)
4908 goto error;
4909 status = write16(state, QAM_DQ_QUAL_FUN2__A, 6);
4910 if (status < 0)
4911 goto error;
4912 status = write16(state, QAM_DQ_QUAL_FUN3__A, 6);
4913 if (status < 0)
4914 goto error;
4915 status = write16(state, QAM_DQ_QUAL_FUN4__A, 5);
4916 if (status < 0)
4917 goto error;
4918 status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4919 if (status < 0)
4920 goto error;
4921
4922 status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4923 if (status < 0)
4924 goto error;
4925 status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4926 if (status < 0)
4927 goto error;
4928 status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4929 if (status < 0)
4930 goto error;
4931
4932
4933 /* QAM Slicer Settings */
4934
4935 status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM128);
4936 if (status < 0)
4937 goto error;
4938
4939
4940 /* QAM Loop Controller Coeficients */
4941
4942 status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4943 if (status < 0)
4944 goto error;
4945 status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4946 if (status < 0)
4947 goto error;
4948 status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4949 if (status < 0)
4950 goto error;
4951 status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4952 if (status < 0)
4953 goto error;
4954 status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4955 if (status < 0)
4956 goto error;
4957 status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4958 if (status < 0)
4959 goto error;
4960 status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4961 if (status < 0)
4962 goto error;
4963 status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4964 if (status < 0)
4965 goto error;
4966
4967 status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4968 if (status < 0)
4969 goto error;
4970 status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 40);
4971 if (status < 0)
4972 goto error;
4973 status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 120);
4974 if (status < 0)
4975 goto error;
4976 status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4977 if (status < 0)
4978 goto error;
4979 status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 40);
4980 if (status < 0)
4981 goto error;
4982 status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 60);
4983 if (status < 0)
4984 goto error;
4985 status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4986 if (status < 0)
4987 goto error;
4988 status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4989 if (status < 0)
4990 goto error;
4991 status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 64);
4992 if (status < 0)
4993 goto error;
4994 status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4995 if (status < 0)
4996 goto error;
4997 status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4998 if (status < 0)
4999 goto error;
5000 status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
5001 if (status < 0)
5002 goto error;
5003
5004
5005 /* QAM State Machine (FSM) Thresholds */
5006
5007 status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
5008 if (status < 0)
5009 goto error;
5010 status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
5011 if (status < 0)
5012 goto error;
5013 status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
5014 if (status < 0)
5015 goto error;
5016 status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
5017 if (status < 0)
5018 goto error;
5019 status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 140);
5020 if (status < 0)
5021 goto error;
5022 status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
5023 if (status < 0)
5024 goto error;
5025
5026 status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5027 if (status < 0)
5028 goto error;
5029 status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 5);
5030 if (status < 0)
5031 goto error;
5032
5033 status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5034 if (status < 0)
5035 goto error;
5036
5037 /* QAM FSM Tracking Parameters */
5038
5039 status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5040 if (status < 0)
5041 goto error;
5042 status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 65);
5043 if (status < 0)
5044 goto error;
5045 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 5);
5046 if (status < 0)
5047 goto error;
5048 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 3);
5049 if (status < 0)
5050 goto error;
5051 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -1);
5052 if (status < 0)
5053 goto error;
5054 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -12);
5055 if (status < 0)
5056 goto error;
5057 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -23);
5058 error:
5059 if (status < 0)
5060 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5061
5062 return status;
5063 }
5064
5065 /*============================================================================*/
5066
5067 /**
5068 * \brief QAM256 specific setup
5069 * \param demod: instance of demod.
5070 * \return DRXStatus_t.
5071 */
5072 static int SetQAM256(struct drxk_state *state)
5073 {
5074 int status = 0;
5075
5076 dprintk(1, "\n");
5077 /* QAM Equalizer Setup */
5078 /* Equalizer */
5079 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 11502);
5080 if (status < 0)
5081 goto error;
5082 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12084);
5083 if (status < 0)
5084 goto error;
5085 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 12543);
5086 if (status < 0)
5087 goto error;
5088 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 12931);
5089 if (status < 0)
5090 goto error;
5091 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13629);
5092 if (status < 0)
5093 goto error;
5094 status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15385);
5095 if (status < 0)
5096 goto error;
5097
5098 /* Decision Feedback Equalizer */
5099 status = write16(state, QAM_DQ_QUAL_FUN0__A, 8);
5100 if (status < 0)
5101 goto error;
5102 status = write16(state, QAM_DQ_QUAL_FUN1__A, 8);
5103 if (status < 0)
5104 goto error;
5105 status = write16(state, QAM_DQ_QUAL_FUN2__A, 8);
5106 if (status < 0)
5107 goto error;
5108 status = write16(state, QAM_DQ_QUAL_FUN3__A, 8);
5109 if (status < 0)
5110 goto error;
5111 status = write16(state, QAM_DQ_QUAL_FUN4__A, 6);
5112 if (status < 0)
5113 goto error;
5114 status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
5115 if (status < 0)
5116 goto error;
5117
5118 status = write16(state, QAM_SY_SYNC_HWM__A, 5);
5119 if (status < 0)
5120 goto error;
5121 status = write16(state, QAM_SY_SYNC_AWM__A, 4);
5122 if (status < 0)
5123 goto error;
5124 status = write16(state, QAM_SY_SYNC_LWM__A, 3);
5125 if (status < 0)
5126 goto error;
5127
5128 /* QAM Slicer Settings */
5129
5130 status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM256);
5131 if (status < 0)
5132 goto error;
5133
5134
5135 /* QAM Loop Controller Coeficients */
5136
5137 status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
5138 if (status < 0)
5139 goto error;
5140 status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
5141 if (status < 0)
5142 goto error;
5143 status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
5144 if (status < 0)
5145 goto error;
5146 status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
5147 if (status < 0)
5148 goto error;
5149 status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
5150 if (status < 0)
5151 goto error;
5152 status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
5153 if (status < 0)
5154 goto error;
5155 status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
5156 if (status < 0)
5157 goto error;
5158 status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
5159 if (status < 0)
5160 goto error;
5161
5162 status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
5163 if (status < 0)
5164 goto error;
5165 status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 50);
5166 if (status < 0)
5167 goto error;
5168 status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 250);
5169 if (status < 0)
5170 goto error;
5171 status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
5172 if (status < 0)
5173 goto error;
5174 status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 50);
5175 if (status < 0)
5176 goto error;
5177 status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 125);
5178 if (status < 0)
5179 goto error;
5180 status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
5181 if (status < 0)
5182 goto error;
5183 status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
5184 if (status < 0)
5185 goto error;
5186 status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
5187 if (status < 0)
5188 goto error;
5189 status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
5190 if (status < 0)
5191 goto error;
5192 status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
5193 if (status < 0)
5194 goto error;
5195 status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
5196 if (status < 0)
5197 goto error;
5198
5199
5200 /* QAM State Machine (FSM) Thresholds */
5201
5202 status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
5203 if (status < 0)
5204 goto error;
5205 status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
5206 if (status < 0)
5207 goto error;
5208 status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
5209 if (status < 0)
5210 goto error;
5211 status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
5212 if (status < 0)
5213 goto error;
5214 status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 150);
5215 if (status < 0)
5216 goto error;
5217 status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 110);
5218 if (status < 0)
5219 goto error;
5220
5221 status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5222 if (status < 0)
5223 goto error;
5224 status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
5225 if (status < 0)
5226 goto error;
5227 status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5228 if (status < 0)
5229 goto error;
5230
5231
5232 /* QAM FSM Tracking Parameters */
5233
5234 status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5235 if (status < 0)
5236 goto error;
5237 status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 74);
5238 if (status < 0)
5239 goto error;
5240 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 18);
5241 if (status < 0)
5242 goto error;
5243 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 13);
5244 if (status < 0)
5245 goto error;
5246 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) 7);
5247 if (status < 0)
5248 goto error;
5249 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) 0);
5250 if (status < 0)
5251 goto error;
5252 status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -8);
5253 error:
5254 if (status < 0)
5255 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5256 return status;
5257 }
5258
5259
5260 /*============================================================================*/
5261 /**
5262 * \brief Reset QAM block.
5263 * \param demod: instance of demod.
5264 * \param channel: pointer to channel data.
5265 * \return DRXStatus_t.
5266 */
5267 static int QAMResetQAM(struct drxk_state *state)
5268 {
5269 int status;
5270 u16 cmdResult;
5271
5272 dprintk(1, "\n");
5273 /* Stop QAM comstate->m_exec */
5274 status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
5275 if (status < 0)
5276 goto error;
5277
5278 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
5279 error:
5280 if (status < 0)
5281 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5282 return status;
5283 }
5284
5285 /*============================================================================*/
5286
5287 /**
5288 * \brief Set QAM symbolrate.
5289 * \param demod: instance of demod.
5290 * \param channel: pointer to channel data.
5291 * \return DRXStatus_t.
5292 */
5293 static int QAMSetSymbolrate(struct drxk_state *state)
5294 {
5295 u32 adcFrequency = 0;
5296 u32 symbFreq = 0;
5297 u32 iqmRcRate = 0;
5298 u16 ratesel = 0;
5299 u32 lcSymbRate = 0;
5300 int status;
5301
5302 dprintk(1, "\n");
5303 /* Select & calculate correct IQM rate */
5304 adcFrequency = (state->m_sysClockFreq * 1000) / 3;
5305 ratesel = 0;
5306 /* printk(KERN_DEBUG "drxk: SR %d\n", state->props.symbol_rate); */
5307 if (state->props.symbol_rate <= 1188750)
5308 ratesel = 3;
5309 else if (state->props.symbol_rate <= 2377500)
5310 ratesel = 2;
5311 else if (state->props.symbol_rate <= 4755000)
5312 ratesel = 1;
5313 status = write16(state, IQM_FD_RATESEL__A, ratesel);
5314 if (status < 0)
5315 goto error;
5316
5317 /*
5318 IqmRcRate = ((Fadc / (symbolrate * (4<<ratesel))) - 1) * (1<<23)
5319 */
5320 symbFreq = state->props.symbol_rate * (1 << ratesel);
5321 if (symbFreq == 0) {
5322 /* Divide by zero */
5323 status = -EINVAL;
5324 goto error;
5325 }
5326 iqmRcRate = (adcFrequency / symbFreq) * (1 << 21) +
5327 (Frac28a((adcFrequency % symbFreq), symbFreq) >> 7) -
5328 (1 << 23);
5329 status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRate);
5330 if (status < 0)
5331 goto error;
5332 state->m_iqmRcRate = iqmRcRate;
5333 /*
5334 LcSymbFreq = round (.125 * symbolrate / adcFreq * (1<<15))
5335 */
5336 symbFreq = state->props.symbol_rate;
5337 if (adcFrequency == 0) {
5338 /* Divide by zero */
5339 status = -EINVAL;
5340 goto error;
5341 }
5342 lcSymbRate = (symbFreq / adcFrequency) * (1 << 12) +
5343 (Frac28a((symbFreq % adcFrequency), adcFrequency) >>
5344 16);
5345 if (lcSymbRate > 511)
5346 lcSymbRate = 511;
5347 status = write16(state, QAM_LC_SYMBOL_FREQ__A, (u16) lcSymbRate);
5348
5349 error:
5350 if (status < 0)
5351 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5352 return status;
5353 }
5354
5355 /*============================================================================*/
5356
5357 /**
5358 * \brief Get QAM lock status.
5359 * \param demod: instance of demod.
5360 * \param channel: pointer to channel data.
5361 * \return DRXStatus_t.
5362 */
5363
5364 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus)
5365 {
5366 int status;
5367 u16 Result[2] = { 0, 0 };
5368
5369 dprintk(1, "\n");
5370 *pLockStatus = NOT_LOCKED;
5371 status = scu_command(state,
5372 SCU_RAM_COMMAND_STANDARD_QAM |
5373 SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK, 0, NULL, 2,
5374 Result);
5375 if (status < 0)
5376 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5377
5378 if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_DEMOD_LOCKED) {
5379 /* 0x0000 NOT LOCKED */
5380 } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_LOCKED) {
5381 /* 0x4000 DEMOD LOCKED */
5382 *pLockStatus = DEMOD_LOCK;
5383 } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_NEVER_LOCK) {
5384 /* 0x8000 DEMOD + FEC LOCKED (system lock) */
5385 *pLockStatus = MPEG_LOCK;
5386 } else {
5387 /* 0xC000 NEVER LOCKED */
5388 /* (system will never be able to lock to the signal) */
5389 /* TODO: check this, intermediate & standard specific lock states are not
5390 taken into account here */
5391 *pLockStatus = NEVER_LOCK;
5392 }
5393 return status;
5394 }
5395
5396 #define QAM_MIRROR__M 0x03
5397 #define QAM_MIRROR_NORMAL 0x00
5398 #define QAM_MIRRORED 0x01
5399 #define QAM_MIRROR_AUTO_ON 0x02
5400 #define QAM_LOCKRANGE__M 0x10
5401 #define QAM_LOCKRANGE_NORMAL 0x10
5402
5403 static int QAMDemodulatorCommand(struct drxk_state *state,
5404 int numberOfParameters)
5405 {
5406 int status;
5407 u16 cmdResult;
5408 u16 setParamParameters[4] = { 0, 0, 0, 0 };
5409
5410 setParamParameters[0] = state->m_Constellation; /* modulation */
5411 setParamParameters[1] = DRXK_QAM_I12_J17; /* interleave mode */
5412
5413 if (numberOfParameters == 2) {
5414 u16 setEnvParameters[1] = { 0 };
5415
5416 if (state->m_OperationMode == OM_QAM_ITU_C)
5417 setEnvParameters[0] = QAM_TOP_ANNEX_C;
5418 else
5419 setEnvParameters[0] = QAM_TOP_ANNEX_A;
5420
5421 status = scu_command(state,
5422 SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV,
5423 1, setEnvParameters, 1, &cmdResult);
5424 if (status < 0)
5425 goto error;
5426
5427 status = scu_command(state,
5428 SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM,
5429 numberOfParameters, setParamParameters,
5430 1, &cmdResult);
5431 } else if (numberOfParameters == 4) {
5432 if (state->m_OperationMode == OM_QAM_ITU_C)
5433 setParamParameters[2] = QAM_TOP_ANNEX_C;
5434 else
5435 setParamParameters[2] = QAM_TOP_ANNEX_A;
5436
5437 setParamParameters[3] |= (QAM_MIRROR_AUTO_ON);
5438 /* Env parameters */
5439 /* check for LOCKRANGE Extented */
5440 /* setParamParameters[3] |= QAM_LOCKRANGE_NORMAL; */
5441
5442 status = scu_command(state,
5443 SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM,
5444 numberOfParameters, setParamParameters,
5445 1, &cmdResult);
5446 } else {
5447 printk(KERN_WARNING "drxk: Unknown QAM demodulator parameter "
5448 "count %d\n", numberOfParameters);
5449 status = -EINVAL;
5450 }
5451
5452 error:
5453 if (status < 0)
5454 printk(KERN_WARNING "drxk: Warning %d on %s\n",
5455 status, __func__);
5456 return status;
5457 }
5458
5459 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
5460 s32 tunerFreqOffset)
5461 {
5462 int status;
5463 u16 cmdResult;
5464 int qamDemodParamCount = state->qam_demod_parameter_count;
5465
5466 dprintk(1, "\n");
5467 /*
5468 * STEP 1: reset demodulator
5469 * resets FEC DI and FEC RS
5470 * resets QAM block
5471 * resets SCU variables
5472 */
5473 status = write16(state, FEC_DI_COMM_EXEC__A, FEC_DI_COMM_EXEC_STOP);
5474 if (status < 0)
5475 goto error;
5476 status = write16(state, FEC_RS_COMM_EXEC__A, FEC_RS_COMM_EXEC_STOP);
5477 if (status < 0)
5478 goto error;
5479 status = QAMResetQAM(state);
5480 if (status < 0)
5481 goto error;
5482
5483 /*
5484 * STEP 2: configure demodulator
5485 * -set params; resets IQM,QAM,FEC HW; initializes some
5486 * SCU variables
5487 */
5488 status = QAMSetSymbolrate(state);
5489 if (status < 0)
5490 goto error;
5491
5492 /* Set params */
5493 switch (state->props.modulation) {
5494 case QAM_256:
5495 state->m_Constellation = DRX_CONSTELLATION_QAM256;
5496 break;
5497 case QAM_AUTO:
5498 case QAM_64:
5499 state->m_Constellation = DRX_CONSTELLATION_QAM64;
5500 break;
5501 case QAM_16:
5502 state->m_Constellation = DRX_CONSTELLATION_QAM16;
5503 break;
5504 case QAM_32:
5505 state->m_Constellation = DRX_CONSTELLATION_QAM32;
5506 break;
5507 case QAM_128:
5508 state->m_Constellation = DRX_CONSTELLATION_QAM128;
5509 break;
5510 default:
5511 status = -EINVAL;
5512 break;
5513 }
5514 if (status < 0)
5515 goto error;
5516
5517 /* Use the 4-parameter if it's requested or we're probing for
5518 * the correct command. */
5519 if (state->qam_demod_parameter_count == 4
5520 || !state->qam_demod_parameter_count) {
5521 qamDemodParamCount = 4;
5522 status = QAMDemodulatorCommand(state, qamDemodParamCount);
5523 }
5524
5525 /* Use the 2-parameter command if it was requested or if we're
5526 * probing for the correct command and the 4-parameter command
5527 * failed. */
5528 if (state->qam_demod_parameter_count == 2
5529 || (!state->qam_demod_parameter_count && status < 0)) {
5530 qamDemodParamCount = 2;
5531 status = QAMDemodulatorCommand(state, qamDemodParamCount);
5532 }
5533
5534 if (status < 0) {
5535 dprintk(1, "Could not set demodulator parameters. Make "
5536 "sure qam_demod_parameter_count (%d) is correct for "
5537 "your firmware (%s).\n",
5538 state->qam_demod_parameter_count,
5539 state->microcode_name);
5540 goto error;
5541 } else if (!state->qam_demod_parameter_count) {
5542 dprintk(1, "Auto-probing the correct QAM demodulator command "
5543 "parameters was successful - using %d parameters.\n",
5544 qamDemodParamCount);
5545
5546 /*
5547 * One of our commands was successful. We don't need to
5548 * auto-probe anymore, now that we got the correct command.
5549 */
5550 state->qam_demod_parameter_count = qamDemodParamCount;
5551 }
5552
5553 /*
5554 * STEP 3: enable the system in a mode where the ADC provides valid
5555 * signal setup modulation independent registers
5556 */
5557 #if 0
5558 status = SetFrequency(channel, tunerFreqOffset));
5559 if (status < 0)
5560 goto error;
5561 #endif
5562 status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
5563 if (status < 0)
5564 goto error;
5565
5566 /* Setup BER measurement */
5567 status = SetQAMMeasurement(state, state->m_Constellation, state->props.symbol_rate);
5568 if (status < 0)
5569 goto error;
5570
5571 /* Reset default values */
5572 status = write16(state, IQM_CF_SCALE_SH__A, IQM_CF_SCALE_SH__PRE);
5573 if (status < 0)
5574 goto error;
5575 status = write16(state, QAM_SY_TIMEOUT__A, QAM_SY_TIMEOUT__PRE);
5576 if (status < 0)
5577 goto error;
5578
5579 /* Reset default LC values */
5580 status = write16(state, QAM_LC_RATE_LIMIT__A, 3);
5581 if (status < 0)
5582 goto error;
5583 status = write16(state, QAM_LC_LPF_FACTORP__A, 4);
5584 if (status < 0)
5585 goto error;
5586 status = write16(state, QAM_LC_LPF_FACTORI__A, 4);
5587 if (status < 0)
5588 goto error;
5589 status = write16(state, QAM_LC_MODE__A, 7);
5590 if (status < 0)
5591 goto error;
5592
5593 status = write16(state, QAM_LC_QUAL_TAB0__A, 1);
5594 if (status < 0)
5595 goto error;
5596 status = write16(state, QAM_LC_QUAL_TAB1__A, 1);
5597 if (status < 0)
5598 goto error;
5599 status = write16(state, QAM_LC_QUAL_TAB2__A, 1);
5600 if (status < 0)
5601 goto error;
5602 status = write16(state, QAM_LC_QUAL_TAB3__A, 1);
5603 if (status < 0)
5604 goto error;
5605 status = write16(state, QAM_LC_QUAL_TAB4__A, 2);
5606 if (status < 0)
5607 goto error;
5608 status = write16(state, QAM_LC_QUAL_TAB5__A, 2);
5609 if (status < 0)
5610 goto error;
5611 status = write16(state, QAM_LC_QUAL_TAB6__A, 2);
5612 if (status < 0)
5613 goto error;
5614 status = write16(state, QAM_LC_QUAL_TAB8__A, 2);
5615 if (status < 0)
5616 goto error;
5617 status = write16(state, QAM_LC_QUAL_TAB9__A, 2);
5618 if (status < 0)
5619 goto error;
5620 status = write16(state, QAM_LC_QUAL_TAB10__A, 2);
5621 if (status < 0)
5622 goto error;
5623 status = write16(state, QAM_LC_QUAL_TAB12__A, 2);
5624 if (status < 0)
5625 goto error;
5626 status = write16(state, QAM_LC_QUAL_TAB15__A, 3);
5627 if (status < 0)
5628 goto error;
5629 status = write16(state, QAM_LC_QUAL_TAB16__A, 3);
5630 if (status < 0)
5631 goto error;
5632 status = write16(state, QAM_LC_QUAL_TAB20__A, 4);
5633 if (status < 0)
5634 goto error;
5635 status = write16(state, QAM_LC_QUAL_TAB25__A, 4);
5636 if (status < 0)
5637 goto error;
5638
5639 /* Mirroring, QAM-block starting point not inverted */
5640 status = write16(state, QAM_SY_SP_INV__A, QAM_SY_SP_INV_SPECTRUM_INV_DIS);
5641 if (status < 0)
5642 goto error;
5643
5644 /* Halt SCU to enable safe non-atomic accesses */
5645 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5646 if (status < 0)
5647 goto error;
5648
5649 /* STEP 4: modulation specific setup */
5650 switch (state->props.modulation) {
5651 case QAM_16:
5652 status = SetQAM16(state);
5653 break;
5654 case QAM_32:
5655 status = SetQAM32(state);
5656 break;
5657 case QAM_AUTO:
5658 case QAM_64:
5659 status = SetQAM64(state);
5660 break;
5661 case QAM_128:
5662 status = SetQAM128(state);
5663 break;
5664 case QAM_256:
5665 status = SetQAM256(state);
5666 break;
5667 default:
5668 status = -EINVAL;
5669 break;
5670 }
5671 if (status < 0)
5672 goto error;
5673
5674 /* Activate SCU to enable SCU commands */
5675 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5676 if (status < 0)
5677 goto error;
5678
5679 /* Re-configure MPEG output, requires knowledge of channel bitrate */
5680 /* extAttr->currentChannel.modulation = channel->modulation; */
5681 /* extAttr->currentChannel.symbolrate = channel->symbolrate; */
5682 status = MPEGTSDtoSetup(state, state->m_OperationMode);
5683 if (status < 0)
5684 goto error;
5685
5686 /* Start processes */
5687 status = MPEGTSStart(state);
5688 if (status < 0)
5689 goto error;
5690 status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE);
5691 if (status < 0)
5692 goto error;
5693 status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_ACTIVE);
5694 if (status < 0)
5695 goto error;
5696 status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_ACTIVE);
5697 if (status < 0)
5698 goto error;
5699
5700 /* STEP 5: start QAM demodulator (starts FEC, QAM and IQM HW) */
5701 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
5702 if (status < 0)
5703 goto error;
5704
5705 /* update global DRXK data container */
5706 /*? extAttr->qamInterleaveMode = DRXK_QAM_I12_J17; */
5707
5708 error:
5709 if (status < 0)
5710 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5711 return status;
5712 }
5713
5714 static int SetQAMStandard(struct drxk_state *state,
5715 enum OperationMode oMode)
5716 {
5717 int status;
5718 #ifdef DRXK_QAM_TAPS
5719 #define DRXK_QAMA_TAPS_SELECT
5720 #include "drxk_filters.h"
5721 #undef DRXK_QAMA_TAPS_SELECT
5722 #endif
5723
5724 dprintk(1, "\n");
5725
5726 /* added antenna switch */
5727 SwitchAntennaToQAM(state);
5728
5729 /* Ensure correct power-up mode */
5730 status = PowerUpQAM(state);
5731 if (status < 0)
5732 goto error;
5733 /* Reset QAM block */
5734 status = QAMResetQAM(state);
5735 if (status < 0)
5736 goto error;
5737
5738 /* Setup IQM */
5739
5740 status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
5741 if (status < 0)
5742 goto error;
5743 status = write16(state, IQM_AF_AMUX__A, IQM_AF_AMUX_SIGNAL2ADC);
5744 if (status < 0)
5745 goto error;
5746
5747 /* Upload IQM Channel Filter settings by
5748 boot loader from ROM table */
5749 switch (oMode) {
5750 case OM_QAM_ITU_A:
5751 status = BLChainCmd(state, DRXK_BL_ROM_OFFSET_TAPS_ITU_A, DRXK_BLCC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5752 break;
5753 case OM_QAM_ITU_C:
5754 status = BLDirectCmd(state, IQM_CF_TAP_RE0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5755 if (status < 0)
5756 goto error;
5757 status = BLDirectCmd(state, IQM_CF_TAP_IM0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5758 break;
5759 default:
5760 status = -EINVAL;
5761 }
5762 if (status < 0)
5763 goto error;
5764
5765 status = write16(state, IQM_CF_OUT_ENA__A, (1 << IQM_CF_OUT_ENA_QAM__B));
5766 if (status < 0)
5767 goto error;
5768 status = write16(state, IQM_CF_SYMMETRIC__A, 0);
5769 if (status < 0)
5770 goto error;
5771 status = write16(state, IQM_CF_MIDTAP__A, ((1 << IQM_CF_MIDTAP_RE__B) | (1 << IQM_CF_MIDTAP_IM__B)));
5772 if (status < 0)
5773 goto error;
5774
5775 status = write16(state, IQM_RC_STRETCH__A, 21);
5776 if (status < 0)
5777 goto error;
5778 status = write16(state, IQM_AF_CLP_LEN__A, 0);
5779 if (status < 0)
5780 goto error;
5781 status = write16(state, IQM_AF_CLP_TH__A, 448);
5782 if (status < 0)
5783 goto error;
5784 status = write16(state, IQM_AF_SNS_LEN__A, 0);
5785 if (status < 0)
5786 goto error;
5787 status = write16(state, IQM_CF_POW_MEAS_LEN__A, 0);
5788 if (status < 0)
5789 goto error;
5790
5791 status = write16(state, IQM_FS_ADJ_SEL__A, 1);
5792 if (status < 0)
5793 goto error;
5794 status = write16(state, IQM_RC_ADJ_SEL__A, 1);
5795 if (status < 0)
5796 goto error;
5797 status = write16(state, IQM_CF_ADJ_SEL__A, 1);
5798 if (status < 0)
5799 goto error;
5800 status = write16(state, IQM_AF_UPD_SEL__A, 0);
5801 if (status < 0)
5802 goto error;
5803
5804 /* IQM Impulse Noise Processing Unit */
5805 status = write16(state, IQM_CF_CLP_VAL__A, 500);
5806 if (status < 0)
5807 goto error;
5808 status = write16(state, IQM_CF_DATATH__A, 1000);
5809 if (status < 0)
5810 goto error;
5811 status = write16(state, IQM_CF_BYPASSDET__A, 1);
5812 if (status < 0)
5813 goto error;
5814 status = write16(state, IQM_CF_DET_LCT__A, 0);
5815 if (status < 0)
5816 goto error;
5817 status = write16(state, IQM_CF_WND_LEN__A, 1);
5818 if (status < 0)
5819 goto error;
5820 status = write16(state, IQM_CF_PKDTH__A, 1);
5821 if (status < 0)
5822 goto error;
5823 status = write16(state, IQM_AF_INC_BYPASS__A, 1);
5824 if (status < 0)
5825 goto error;
5826
5827 /* turn on IQMAF. Must be done before setAgc**() */
5828 status = SetIqmAf(state, true);
5829 if (status < 0)
5830 goto error;
5831 status = write16(state, IQM_AF_START_LOCK__A, 0x01);
5832 if (status < 0)
5833 goto error;
5834
5835 /* IQM will not be reset from here, sync ADC and update/init AGC */
5836 status = ADCSynchronization(state);
5837 if (status < 0)
5838 goto error;
5839
5840 /* Set the FSM step period */
5841 status = write16(state, SCU_RAM_QAM_FSM_STEP_PERIOD__A, 2000);
5842 if (status < 0)
5843 goto error;
5844
5845 /* Halt SCU to enable safe non-atomic accesses */
5846 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5847 if (status < 0)
5848 goto error;
5849
5850 /* No more resets of the IQM, current standard correctly set =>
5851 now AGCs can be configured. */
5852
5853 status = InitAGC(state, true);
5854 if (status < 0)
5855 goto error;
5856 status = SetPreSaw(state, &(state->m_qamPreSawCfg));
5857 if (status < 0)
5858 goto error;
5859
5860 /* Configure AGC's */
5861 status = SetAgcRf(state, &(state->m_qamRfAgcCfg), true);
5862 if (status < 0)
5863 goto error;
5864 status = SetAgcIf(state, &(state->m_qamIfAgcCfg), true);
5865 if (status < 0)
5866 goto error;
5867
5868 /* Activate SCU to enable SCU commands */
5869 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5870 error:
5871 if (status < 0)
5872 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5873 return status;
5874 }
5875
5876 static int WriteGPIO(struct drxk_state *state)
5877 {
5878 int status;
5879 u16 value = 0;
5880
5881 dprintk(1, "\n");
5882 /* stop lock indicator process */
5883 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
5884 if (status < 0)
5885 goto error;
5886
5887 /* Write magic word to enable pdr reg write */
5888 status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
5889 if (status < 0)
5890 goto error;
5891
5892 if (state->m_hasSAWSW) {
5893 if (state->UIO_mask & 0x0001) { /* UIO-1 */
5894 /* write to io pad configuration register - output mode */
5895 status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5896 if (status < 0)
5897 goto error;
5898
5899 /* use corresponding bit in io data output registar */
5900 status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5901 if (status < 0)
5902 goto error;
5903 if ((state->m_GPIO & 0x0001) == 0)
5904 value &= 0x7FFF; /* write zero to 15th bit - 1st UIO */
5905 else
5906 value |= 0x8000; /* write one to 15th bit - 1st UIO */
5907 /* write back to io data output register */
5908 status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5909 if (status < 0)
5910 goto error;
5911 }
5912 if (state->UIO_mask & 0x0002) { /* UIO-2 */
5913 /* write to io pad configuration register - output mode */
5914 status = write16(state, SIO_PDR_SMA_RX_CFG__A, state->m_GPIOCfg);
5915 if (status < 0)
5916 goto error;
5917
5918 /* use corresponding bit in io data output registar */
5919 status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5920 if (status < 0)
5921 goto error;
5922 if ((state->m_GPIO & 0x0002) == 0)
5923 value &= 0xBFFF; /* write zero to 14th bit - 2st UIO */
5924 else
5925 value |= 0x4000; /* write one to 14th bit - 2st UIO */
5926 /* write back to io data output register */
5927 status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5928 if (status < 0)
5929 goto error;
5930 }
5931 if (state->UIO_mask & 0x0004) { /* UIO-3 */
5932 /* write to io pad configuration register - output mode */
5933 status = write16(state, SIO_PDR_GPIO_CFG__A, state->m_GPIOCfg);
5934 if (status < 0)
5935 goto error;
5936
5937 /* use corresponding bit in io data output registar */
5938 status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5939 if (status < 0)
5940 goto error;
5941 if ((state->m_GPIO & 0x0004) == 0)
5942 value &= 0xFFFB; /* write zero to 2nd bit - 3rd UIO */
5943 else
5944 value |= 0x0004; /* write one to 2nd bit - 3rd UIO */
5945 /* write back to io data output register */
5946 status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5947 if (status < 0)
5948 goto error;
5949 }
5950 }
5951 /* Write magic word to disable pdr reg write */
5952 status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
5953 error:
5954 if (status < 0)
5955 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5956 return status;
5957 }
5958
5959 static int SwitchAntennaToQAM(struct drxk_state *state)
5960 {
5961 int status = 0;
5962 bool gpio_state;
5963
5964 dprintk(1, "\n");
5965
5966 if (!state->antenna_gpio)
5967 return 0;
5968
5969 gpio_state = state->m_GPIO & state->antenna_gpio;
5970
5971 if (state->antenna_dvbt ^ gpio_state) {
5972 /* Antenna is on DVB-T mode. Switch */
5973 if (state->antenna_dvbt)
5974 state->m_GPIO &= ~state->antenna_gpio;
5975 else
5976 state->m_GPIO |= state->antenna_gpio;
5977 status = WriteGPIO(state);
5978 }
5979 if (status < 0)
5980 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5981 return status;
5982 }
5983
5984 static int SwitchAntennaToDVBT(struct drxk_state *state)
5985 {
5986 int status = 0;
5987 bool gpio_state;
5988
5989 dprintk(1, "\n");
5990
5991 if (!state->antenna_gpio)
5992 return 0;
5993
5994 gpio_state = state->m_GPIO & state->antenna_gpio;
5995
5996 if (!(state->antenna_dvbt ^ gpio_state)) {
5997 /* Antenna is on DVB-C mode. Switch */
5998 if (state->antenna_dvbt)
5999 state->m_GPIO |= state->antenna_gpio;
6000 else
6001 state->m_GPIO &= ~state->antenna_gpio;
6002 status = WriteGPIO(state);
6003 }
6004 if (status < 0)
6005 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
6006 return status;
6007 }
6008
6009
6010 static int PowerDownDevice(struct drxk_state *state)
6011 {
6012 /* Power down to requested mode */
6013 /* Backup some register settings */
6014 /* Set pins with possible pull-ups connected to them in input mode */
6015 /* Analog power down */
6016 /* ADC power down */
6017 /* Power down device */
6018 int status;
6019
6020 dprintk(1, "\n");
6021 if (state->m_bPDownOpenBridge) {
6022 /* Open I2C bridge before power down of DRXK */
6023 status = ConfigureI2CBridge(state, true);
6024 if (status < 0)
6025 goto error;
6026 }
6027 /* driver 0.9.0 */
6028 status = DVBTEnableOFDMTokenRing(state, false);
6029 if (status < 0)
6030 goto error;
6031
6032 status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_CLOCK);
6033 if (status < 0)
6034 goto error;
6035 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
6036 if (status < 0)
6037 goto error;
6038 state->m_HICfgCtrl |= SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
6039 status = HI_CfgCommand(state);
6040 error:
6041 if (status < 0)
6042 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
6043
6044 return status;
6045 }
6046
6047 static int init_drxk(struct drxk_state *state)
6048 {
6049 int status = 0, n = 0;
6050 enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
6051 u16 driverVersion;
6052
6053 dprintk(1, "\n");
6054 if ((state->m_DrxkState == DRXK_UNINITIALIZED)) {
6055 drxk_i2c_lock(state);
6056 status = PowerUpDevice(state);
6057 if (status < 0)
6058 goto error;
6059 status = DRXX_Open(state);
6060 if (status < 0)
6061 goto error;
6062 /* Soft reset of OFDM-, sys- and osc-clockdomain */
6063 status = write16(state, SIO_CC_SOFT_RST__A, SIO_CC_SOFT_RST_OFDM__M | SIO_CC_SOFT_RST_SYS__M | SIO_CC_SOFT_RST_OSC__M);
6064 if (status < 0)
6065 goto error;
6066 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
6067 if (status < 0)
6068 goto error;
6069 /* TODO is this needed, if yes how much delay in worst case scenario */
6070 msleep(1);
6071 state->m_DRXK_A3_PATCH_CODE = true;
6072 status = GetDeviceCapabilities(state);
6073 if (status < 0)
6074 goto error;
6075
6076 /* Bridge delay, uses oscilator clock */
6077 /* Delay = (delay (nano seconds) * oscclk (kHz))/ 1000 */
6078 /* SDA brdige delay */
6079 state->m_HICfgBridgeDelay =
6080 (u16) ((state->m_oscClockFreq / 1000) *
6081 HI_I2C_BRIDGE_DELAY) / 1000;
6082 /* Clipping */
6083 if (state->m_HICfgBridgeDelay >
6084 SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M) {
6085 state->m_HICfgBridgeDelay =
6086 SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M;
6087 }
6088 /* SCL bridge delay, same as SDA for now */
6089 state->m_HICfgBridgeDelay +=
6090 state->m_HICfgBridgeDelay <<
6091 SIO_HI_RA_RAM_PAR_3_CFG_DBL_SCL__B;
6092
6093 status = InitHI(state);
6094 if (status < 0)
6095 goto error;
6096 /* disable various processes */
6097 #if NOA1ROM
6098 if (!(state->m_DRXK_A1_ROM_CODE)
6099 && !(state->m_DRXK_A2_ROM_CODE))
6100 #endif
6101 {
6102 status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
6103 if (status < 0)
6104 goto error;
6105 }
6106
6107 /* disable MPEG port */
6108 status = MPEGTSDisable(state);
6109 if (status < 0)
6110 goto error;
6111
6112 /* Stop AUD and SCU */
6113 status = write16(state, AUD_COMM_EXEC__A, AUD_COMM_EXEC_STOP);
6114 if (status < 0)
6115 goto error;
6116 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_STOP);
6117 if (status < 0)
6118 goto error;
6119
6120 /* enable token-ring bus through OFDM block for possible ucode upload */
6121 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_ON);
6122 if (status < 0)
6123 goto error;
6124
6125 /* include boot loader section */
6126 status = write16(state, SIO_BL_COMM_EXEC__A, SIO_BL_COMM_EXEC_ACTIVE);
6127 if (status < 0)
6128 goto error;
6129 status = BLChainCmd(state, 0, 6, 100);
6130 if (status < 0)
6131 goto error;
6132
6133 if (state->fw) {
6134 status = DownloadMicrocode(state, state->fw->data,
6135 state->fw->size);
6136 if (status < 0)
6137 goto error;
6138 }
6139
6140 /* disable token-ring bus through OFDM block for possible ucode upload */
6141 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_OFF);
6142 if (status < 0)
6143 goto error;
6144
6145 /* Run SCU for a little while to initialize microcode version numbers */
6146 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
6147 if (status < 0)
6148 goto error;
6149 status = DRXX_Open(state);
6150 if (status < 0)
6151 goto error;
6152 /* added for test */
6153 msleep(30);
6154
6155 powerMode = DRXK_POWER_DOWN_OFDM;
6156 status = CtrlPowerMode(state, &powerMode);
6157 if (status < 0)
6158 goto error;
6159
6160 /* Stamp driver version number in SCU data RAM in BCD code
6161 Done to enable field application engineers to retreive drxdriver version
6162 via I2C from SCU RAM.
6163 Not using SCU command interface for SCU register access since no
6164 microcode may be present.
6165 */
6166 driverVersion =
6167 (((DRXK_VERSION_MAJOR / 100) % 10) << 12) +
6168 (((DRXK_VERSION_MAJOR / 10) % 10) << 8) +
6169 ((DRXK_VERSION_MAJOR % 10) << 4) +
6170 (DRXK_VERSION_MINOR % 10);
6171 status = write16(state, SCU_RAM_DRIVER_VER_HI__A, driverVersion);
6172 if (status < 0)
6173 goto error;
6174 driverVersion =
6175 (((DRXK_VERSION_PATCH / 1000) % 10) << 12) +
6176 (((DRXK_VERSION_PATCH / 100) % 10) << 8) +
6177 (((DRXK_VERSION_PATCH / 10) % 10) << 4) +
6178 (DRXK_VERSION_PATCH % 10);
6179 status = write16(state, SCU_RAM_DRIVER_VER_LO__A, driverVersion);
6180 if (status < 0)
6181 goto error;
6182
6183 printk(KERN_INFO "DRXK driver version %d.%d.%d\n",
6184 DRXK_VERSION_MAJOR, DRXK_VERSION_MINOR,
6185 DRXK_VERSION_PATCH);
6186
6187 /* Dirty fix of default values for ROM/PATCH microcode
6188 Dirty because this fix makes it impossible to setup suitable values
6189 before calling DRX_Open. This solution requires changes to RF AGC speed
6190 to be done via the CTRL function after calling DRX_Open */
6191
6192 /* m_dvbtRfAgcCfg.speed = 3; */
6193
6194 /* Reset driver debug flags to 0 */
6195 status = write16(state, SCU_RAM_DRIVER_DEBUG__A, 0);
6196 if (status < 0)
6197 goto error;
6198 /* driver 0.9.0 */
6199 /* Setup FEC OC:
6200 NOTE: No more full FEC resets allowed afterwards!! */
6201 status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP);
6202 if (status < 0)
6203 goto error;
6204 /* MPEGTS functions are still the same */
6205 status = MPEGTSDtoInit(state);
6206 if (status < 0)
6207 goto error;
6208 status = MPEGTSStop(state);
6209 if (status < 0)
6210 goto error;
6211 status = MPEGTSConfigurePolarity(state);
6212 if (status < 0)
6213 goto error;
6214 status = MPEGTSConfigurePins(state, state->m_enableMPEGOutput);
6215 if (status < 0)
6216 goto error;
6217 /* added: configure GPIO */
6218 status = WriteGPIO(state);
6219 if (status < 0)
6220 goto error;
6221
6222 state->m_DrxkState = DRXK_STOPPED;
6223
6224 if (state->m_bPowerDown) {
6225 status = PowerDownDevice(state);
6226 if (status < 0)
6227 goto error;
6228 state->m_DrxkState = DRXK_POWERED_DOWN;
6229 } else
6230 state->m_DrxkState = DRXK_STOPPED;
6231
6232 /* Initialize the supported delivery systems */
6233 n = 0;
6234 if (state->m_hasDVBC) {
6235 state->frontend.ops.delsys[n++] = SYS_DVBC_ANNEX_A;
6236 state->frontend.ops.delsys[n++] = SYS_DVBC_ANNEX_C;
6237 strlcat(state->frontend.ops.info.name, " DVB-C",
6238 sizeof(state->frontend.ops.info.name));
6239 }
6240 if (state->m_hasDVBT) {
6241 state->frontend.ops.delsys[n++] = SYS_DVBT;
6242 strlcat(state->frontend.ops.info.name, " DVB-T",
6243 sizeof(state->frontend.ops.info.name));
6244 }
6245 drxk_i2c_unlock(state);
6246 }
6247 error:
6248 if (status < 0) {
6249 state->m_DrxkState = DRXK_NO_DEV;
6250 drxk_i2c_unlock(state);
6251 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
6252 }
6253
6254 return status;
6255 }
6256
6257 static void load_firmware_cb(const struct firmware *fw,
6258 void *context)
6259 {
6260 struct drxk_state *state = context;
6261
6262 dprintk(1, ": %s\n", fw ? "firmware loaded" : "firmware not loaded");
6263 if (!fw) {
6264 printk(KERN_ERR
6265 "drxk: Could not load firmware file %s.\n",
6266 state->microcode_name);
6267 printk(KERN_INFO
6268 "drxk: Copy %s to your hotplug directory!\n",
6269 state->microcode_name);
6270 state->microcode_name = NULL;
6271
6272 /*
6273 * As firmware is now load asynchronous, it is not possible
6274 * anymore to fail at frontend attach. We might silently
6275 * return here, and hope that the driver won't crash.
6276 * We might also change all DVB callbacks to return -ENODEV
6277 * if the device is not initialized.
6278 * As the DRX-K devices have their own internal firmware,
6279 * let's just hope that it will match a firmware revision
6280 * compatible with this driver and proceed.
6281 */
6282 }
6283 state->fw = fw;
6284
6285 init_drxk(state);
6286 }
6287
6288 static void drxk_release(struct dvb_frontend *fe)
6289 {
6290 struct drxk_state *state = fe->demodulator_priv;
6291
6292 dprintk(1, "\n");
6293 if (state->fw)
6294 release_firmware(state->fw);
6295
6296 kfree(state);
6297 }
6298
6299 static int drxk_sleep(struct dvb_frontend *fe)
6300 {
6301 struct drxk_state *state = fe->demodulator_priv;
6302
6303 dprintk(1, "\n");
6304
6305 if (state->m_DrxkState == DRXK_NO_DEV)
6306 return -ENODEV;
6307 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6308 return 0;
6309
6310 ShutDown(state);
6311 return 0;
6312 }
6313
6314 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
6315 {
6316 struct drxk_state *state = fe->demodulator_priv;
6317
6318 dprintk(1, ": %s\n", enable ? "enable" : "disable");
6319
6320 if (state->m_DrxkState == DRXK_NO_DEV)
6321 return -ENODEV;
6322
6323 return ConfigureI2CBridge(state, enable ? true : false);
6324 }
6325
6326 static int drxk_set_parameters(struct dvb_frontend *fe)
6327 {
6328 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
6329 u32 delsys = p->delivery_system, old_delsys;
6330 struct drxk_state *state = fe->demodulator_priv;
6331 u32 IF;
6332
6333 dprintk(1, "\n");
6334
6335 if (state->m_DrxkState == DRXK_NO_DEV)
6336 return -ENODEV;
6337
6338 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6339 return -EAGAIN;
6340
6341 if (!fe->ops.tuner_ops.get_if_frequency) {
6342 printk(KERN_ERR
6343 "drxk: Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
6344 return -EINVAL;
6345 }
6346
6347 if (fe->ops.i2c_gate_ctrl)
6348 fe->ops.i2c_gate_ctrl(fe, 1);
6349 if (fe->ops.tuner_ops.set_params)
6350 fe->ops.tuner_ops.set_params(fe);
6351 if (fe->ops.i2c_gate_ctrl)
6352 fe->ops.i2c_gate_ctrl(fe, 0);
6353
6354 old_delsys = state->props.delivery_system;
6355 state->props = *p;
6356
6357 if (old_delsys != delsys) {
6358 ShutDown(state);
6359 switch (delsys) {
6360 case SYS_DVBC_ANNEX_A:
6361 case SYS_DVBC_ANNEX_C:
6362 if (!state->m_hasDVBC)
6363 return -EINVAL;
6364 state->m_itut_annex_c = (delsys == SYS_DVBC_ANNEX_C) ? true : false;
6365 if (state->m_itut_annex_c)
6366 SetOperationMode(state, OM_QAM_ITU_C);
6367 else
6368 SetOperationMode(state, OM_QAM_ITU_A);
6369 break;
6370 case SYS_DVBT:
6371 if (!state->m_hasDVBT)
6372 return -EINVAL;
6373 SetOperationMode(state, OM_DVBT);
6374 break;
6375 default:
6376 return -EINVAL;
6377 }
6378 }
6379
6380 fe->ops.tuner_ops.get_if_frequency(fe, &IF);
6381 Start(state, 0, IF);
6382
6383 /* printk(KERN_DEBUG "drxk: %s IF=%d done\n", __func__, IF); */
6384
6385 return 0;
6386 }
6387
6388 static int drxk_read_status(struct dvb_frontend *fe, fe_status_t *status)
6389 {
6390 struct drxk_state *state = fe->demodulator_priv;
6391 u32 stat;
6392
6393 dprintk(1, "\n");
6394
6395 if (state->m_DrxkState == DRXK_NO_DEV)
6396 return -ENODEV;
6397 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6398 return -EAGAIN;
6399
6400 *status = 0;
6401 GetLockStatus(state, &stat, 0);
6402 if (stat == MPEG_LOCK)
6403 *status |= 0x1f;
6404 if (stat == FEC_LOCK)
6405 *status |= 0x0f;
6406 if (stat == DEMOD_LOCK)
6407 *status |= 0x07;
6408 return 0;
6409 }
6410
6411 static int drxk_read_ber(struct dvb_frontend *fe, u32 *ber)
6412 {
6413 struct drxk_state *state = fe->demodulator_priv;
6414
6415 dprintk(1, "\n");
6416
6417 if (state->m_DrxkState == DRXK_NO_DEV)
6418 return -ENODEV;
6419 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6420 return -EAGAIN;
6421
6422 *ber = 0;
6423 return 0;
6424 }
6425
6426 static int drxk_read_signal_strength(struct dvb_frontend *fe,
6427 u16 *strength)
6428 {
6429 struct drxk_state *state = fe->demodulator_priv;
6430 u32 val = 0;
6431
6432 dprintk(1, "\n");
6433
6434 if (state->m_DrxkState == DRXK_NO_DEV)
6435 return -ENODEV;
6436 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6437 return -EAGAIN;
6438
6439 ReadIFAgc(state, &val);
6440 *strength = val & 0xffff;
6441 return 0;
6442 }
6443
6444 static int drxk_read_snr(struct dvb_frontend *fe, u16 *snr)
6445 {
6446 struct drxk_state *state = fe->demodulator_priv;
6447 s32 snr2;
6448
6449 dprintk(1, "\n");
6450
6451 if (state->m_DrxkState == DRXK_NO_DEV)
6452 return -ENODEV;
6453 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6454 return -EAGAIN;
6455
6456 GetSignalToNoise(state, &snr2);
6457 *snr = snr2 & 0xffff;
6458 return 0;
6459 }
6460
6461 static int drxk_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
6462 {
6463 struct drxk_state *state = fe->demodulator_priv;
6464 u16 err;
6465
6466 dprintk(1, "\n");
6467
6468 if (state->m_DrxkState == DRXK_NO_DEV)
6469 return -ENODEV;
6470 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6471 return -EAGAIN;
6472
6473 DVBTQAMGetAccPktErr(state, &err);
6474 *ucblocks = (u32) err;
6475 return 0;
6476 }
6477
6478 static int drxk_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings
6479 *sets)
6480 {
6481 struct drxk_state *state = fe->demodulator_priv;
6482 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
6483
6484 dprintk(1, "\n");
6485
6486 if (state->m_DrxkState == DRXK_NO_DEV)
6487 return -ENODEV;
6488 if (state->m_DrxkState == DRXK_UNINITIALIZED)
6489 return -EAGAIN;
6490
6491 switch (p->delivery_system) {
6492 case SYS_DVBC_ANNEX_A:
6493 case SYS_DVBC_ANNEX_C:
6494 case SYS_DVBT:
6495 sets->min_delay_ms = 3000;
6496 sets->max_drift = 0;
6497 sets->step_size = 0;
6498 return 0;
6499 default:
6500 return -EINVAL;
6501 }
6502 }
6503
6504 static struct dvb_frontend_ops drxk_ops = {
6505 /* .delsys will be filled dynamically */
6506 .info = {
6507 .name = "DRXK",
6508 .frequency_min = 47000000,
6509 .frequency_max = 865000000,
6510 /* For DVB-C */
6511 .symbol_rate_min = 870000,
6512 .symbol_rate_max = 11700000,
6513 /* For DVB-T */
6514 .frequency_stepsize = 166667,
6515
6516 .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
6517 FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_FEC_AUTO |
6518 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
6519 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_MUTE_TS |
6520 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_RECOVER |
6521 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO
6522 },
6523
6524 .release = drxk_release,
6525 .sleep = drxk_sleep,
6526 .i2c_gate_ctrl = drxk_gate_ctrl,
6527
6528 .set_frontend = drxk_set_parameters,
6529 .get_tune_settings = drxk_get_tune_settings,
6530
6531 .read_status = drxk_read_status,
6532 .read_ber = drxk_read_ber,
6533 .read_signal_strength = drxk_read_signal_strength,
6534 .read_snr = drxk_read_snr,
6535 .read_ucblocks = drxk_read_ucblocks,
6536 };
6537
6538 struct dvb_frontend *drxk_attach(const struct drxk_config *config,
6539 struct i2c_adapter *i2c)
6540 {
6541 struct drxk_state *state = NULL;
6542 u8 adr = config->adr;
6543 int status;
6544
6545 dprintk(1, "\n");
6546 state = kzalloc(sizeof(struct drxk_state), GFP_KERNEL);
6547 if (!state)
6548 return NULL;
6549
6550 state->i2c = i2c;
6551 state->demod_address = adr;
6552 state->single_master = config->single_master;
6553 state->microcode_name = config->microcode_name;
6554 state->qam_demod_parameter_count = config->qam_demod_parameter_count;
6555 state->no_i2c_bridge = config->no_i2c_bridge;
6556 state->antenna_gpio = config->antenna_gpio;
6557 state->antenna_dvbt = config->antenna_dvbt;
6558 state->m_ChunkSize = config->chunk_size;
6559 state->enable_merr_cfg = config->enable_merr_cfg;
6560
6561 if (config->dynamic_clk) {
6562 state->m_DVBTStaticCLK = 0;
6563 state->m_DVBCStaticCLK = 0;
6564 } else {
6565 state->m_DVBTStaticCLK = 1;
6566 state->m_DVBCStaticCLK = 1;
6567 }
6568
6569
6570 if (config->mpeg_out_clk_strength)
6571 state->m_TSClockkStrength = config->mpeg_out_clk_strength & 0x07;
6572 else
6573 state->m_TSClockkStrength = 0x06;
6574
6575 if (config->parallel_ts)
6576 state->m_enableParallel = true;
6577 else
6578 state->m_enableParallel = false;
6579
6580 /* NOTE: as more UIO bits will be used, add them to the mask */
6581 state->UIO_mask = config->antenna_gpio;
6582
6583 /* Default gpio to DVB-C */
6584 if (!state->antenna_dvbt && state->antenna_gpio)
6585 state->m_GPIO |= state->antenna_gpio;
6586 else
6587 state->m_GPIO &= ~state->antenna_gpio;
6588
6589 mutex_init(&state->mutex);
6590
6591 memcpy(&state->frontend.ops, &drxk_ops, sizeof(drxk_ops));
6592 state->frontend.demodulator_priv = state;
6593
6594 init_state(state);
6595
6596 /* Load firmware and initialize DRX-K */
6597 if (state->microcode_name) {
6598 if (config->load_firmware_sync) {
6599 const struct firmware *fw = NULL;
6600
6601 status = request_firmware(&fw, state->microcode_name,
6602 state->i2c->dev.parent);
6603 if (status < 0)
6604 fw = NULL;
6605 load_firmware_cb(fw, state);
6606 } else {
6607 status = request_firmware_nowait(THIS_MODULE, 1,
6608 state->microcode_name,
6609 state->i2c->dev.parent,
6610 GFP_KERNEL,
6611 state, load_firmware_cb);
6612 if (status < 0) {
6613 printk(KERN_ERR
6614 "drxk: failed to request a firmware\n");
6615 return NULL;
6616 }
6617 }
6618 } else if (init_drxk(state) < 0)
6619 goto error;
6620
6621 printk(KERN_INFO "drxk: frontend initialized.\n");
6622 return &state->frontend;
6623
6624 error:
6625 printk(KERN_ERR "drxk: not found\n");
6626 kfree(state);
6627 return NULL;
6628 }
6629 EXPORT_SYMBOL(drxk_attach);
6630
6631 MODULE_DESCRIPTION("DRX-K driver");
6632 MODULE_AUTHOR("Ralph Metzler");
6633 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror