This source file includes following definitions.
- _stb0899_read_reg
- stb0899_read_reg
- _stb0899_read_s2reg
- stb0899_write_s2reg
- stb0899_read_regs
- stb0899_write_regs
- stb0899_write_reg
- stb0899_get_mclk
- stb0899_set_mclk
- stb0899_postproc
- stb0899_detach
- stb0899_release
- stb0899_get_alpha
- stb0899_init_calc
- stb0899_wait_diseqc_fifo_empty
- stb0899_send_diseqc_msg
- stb0899_wait_diseqc_rxidle
- stb0899_recv_slave_reply
- stb0899_wait_diseqc_txidle
- stb0899_send_diseqc_burst
- stb0899_diseqc_init
- stb0899_sleep
- stb0899_wakeup
- stb0899_init
- stb0899_table_lookup
- stb0899_read_signal_strength
- stb0899_read_snr
- stb0899_read_status
- stb0899_read_ber
- stb0899_set_voltage
- stb0899_set_tone
- stb0899_i2c_gate_ctrl
- CONVERT32
- stb0899_get_dev_id
- stb0899_set_delivery
- stb0899_set_iterations
- stb0899_search
- stb0899_get_frontend
- stb0899_frontend_algo
- stb0899_attach
1
2
3
4
5
6
7
8
9
10 #include <linux/init.h>
11 #include <linux/jiffies.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16
17 #include <linux/dvb/frontend.h>
18 #include <media/dvb_frontend.h>
19
20 #include "stb0899_drv.h"
21 #include "stb0899_priv.h"
22 #include "stb0899_reg.h"
23
24
25 #define MAX_XFER_SIZE 64
26
27 static unsigned int verbose = 0;
28 module_param(verbose, int, 0644);
29
30
31 static const struct stb0899_tab stb0899_cn_tab[] = {
32 { 200, 2600 },
33 { 190, 2700 },
34 { 180, 2860 },
35 { 170, 3020 },
36 { 160, 3210 },
37 { 150, 3440 },
38 { 140, 3710 },
39 { 130, 4010 },
40 { 120, 4360 },
41 { 110, 4740 },
42 { 100, 5190 },
43 { 90, 5670 },
44 { 80, 6200 },
45 { 70, 6770 },
46 { 60, 7360 },
47 { 50, 7970 },
48 { 40, 8250 },
49 { 30, 9000 },
50 { 20, 9450 },
51 { 15, 9600 },
52 };
53
54
55
56
57
58
59
60
61 static const struct stb0899_tab stb0899_dvbsrf_tab[] = {
62 { -750, -128 },
63 { -748, -94 },
64 { -745, -92 },
65 { -735, -90 },
66 { -720, -87 },
67 { -670, -77 },
68 { -640, -70 },
69 { -610, -62 },
70 { -600, -60 },
71 { -590, -56 },
72 { -560, -41 },
73 { -540, -25 },
74 { -530, -17 },
75 { -520, -11 },
76 { -500, 1 },
77 { -490, 6 },
78 { -480, 10 },
79 { -440, 22 },
80 { -420, 27 },
81 { -400, 31 },
82 { -380, 34 },
83 { -340, 40 },
84 { -320, 43 },
85 { -280, 48 },
86 { -250, 52 },
87 { -230, 55 },
88 { -180, 61 },
89 { -140, 66 },
90 { -90, 73 },
91 { -80, 74 },
92 { 500, 127 }
93 };
94
95
96
97
98
99
100
101
102 static const struct stb0899_tab stb0899_dvbs2rf_tab[] = {
103 { 700, 0 },
104 { -80, 3217 },
105 { -150, 3893 },
106 { -190, 4217 },
107 { -240, 4621 },
108 { -280, 4945 },
109 { -320, 5273 },
110 { -350, 5545 },
111 { -370, 5741 },
112 { -410, 6147 },
113 { -450, 6671 },
114 { -490, 7413 },
115 { -501, 7665 },
116 { -530, 8767 },
117 { -560, 10219 },
118 { -580, 10939 },
119 { -590, 11518 },
120 { -600, 11723 },
121 { -650, 12659 },
122 { -690, 13219 },
123 { -730, 13645 },
124 { -750, 13909 },
125 { -766, 14153 },
126 { -950, 16383 }
127 };
128
129
130 static struct stb0899_tab stb0899_quant_tab[] = {
131 { 0, 0 },
132 { 0, 100 },
133 { 600, 200 },
134 { 950, 299 },
135 { 1200, 398 },
136 { 1400, 501 },
137 { 1560, 603 },
138 { 1690, 700 },
139 { 1810, 804 },
140 { 1910, 902 },
141 { 2000, 1000 },
142 { 2080, 1096 },
143 { 2160, 1202 },
144 { 2230, 1303 },
145 { 2350, 1496 },
146 { 2410, 1603 },
147 { 2460, 1698 },
148 { 2510, 1799 },
149 { 2600, 1995 },
150 { 2650, 2113 },
151 { 2690, 2213 },
152 { 2720, 2291 },
153 { 2760, 2399 },
154 { 2800, 2512 },
155 { 2860, 2692 },
156 { 2930, 2917 },
157 { 2960, 3020 },
158 { 3010, 3199 },
159 { 3040, 3311 },
160 { 3060, 3388 },
161 { 3120, 3631 },
162 { 3190, 3936 },
163 { 3400, 5012 },
164 { 3610, 6383 },
165 { 3800, 7943 },
166 { 4210, 12735 },
167 { 4500, 17783 },
168 { 4690, 22131 },
169 { 4810, 25410 }
170 };
171
172
173 static struct stb0899_tab stb0899_est_tab[] = {
174 { 0, 0 },
175 { 0, 1 },
176 { 301, 2 },
177 { 1204, 16 },
178 { 1806, 64 },
179 { 2408, 256 },
180 { 2709, 512 },
181 { 3010, 1023 },
182 { 3311, 2046 },
183 { 3612, 4093 },
184 { 3823, 6653 },
185 { 3913, 8185 },
186 { 4010, 10233 },
187 { 4107, 12794 },
188 { 4214, 16368 },
189 { 4266, 18450 },
190 { 4311, 20464 },
191 { 4353, 22542 },
192 { 4391, 24604 },
193 { 4425, 26607 },
194 { 4457, 28642 },
195 { 4487, 30690 },
196 { 4515, 32734 },
197 { 4612, 40926 },
198 { 4692, 49204 },
199 { 4816, 65464 },
200 { 4913, 81846 },
201 { 4993, 98401 },
202 { 5060, 114815 },
203 { 5118, 131220 },
204 { 5200, 158489 },
205 { 5300, 199526 },
206 { 5400, 251189 },
207 { 5500, 316228 },
208 { 5600, 398107 },
209 { 5720, 524807 },
210 { 5721, 526017 },
211 };
212
213 static int _stb0899_read_reg(struct stb0899_state *state, unsigned int reg)
214 {
215 int ret;
216
217 u8 b0[] = { reg >> 8, reg & 0xff };
218 u8 buf;
219
220 struct i2c_msg msg[] = {
221 {
222 .addr = state->config->demod_address,
223 .flags = 0,
224 .buf = b0,
225 .len = 2
226 },{
227 .addr = state->config->demod_address,
228 .flags = I2C_M_RD,
229 .buf = &buf,
230 .len = 1
231 }
232 };
233
234 ret = i2c_transfer(state->i2c, msg, 2);
235 if (ret != 2) {
236 if (ret != -ERESTARTSYS)
237 dprintk(state->verbose, FE_ERROR, 1,
238 "Read error, Reg=[0x%02x], Status=%d",
239 reg, ret);
240
241 return ret < 0 ? ret : -EREMOTEIO;
242 }
243 if (unlikely(*state->verbose >= FE_DEBUGREG))
244 dprintk(state->verbose, FE_ERROR, 1, "Reg=[0x%02x], data=%02x",
245 reg, buf);
246
247 return (unsigned int)buf;
248 }
249
250 int stb0899_read_reg(struct stb0899_state *state, unsigned int reg)
251 {
252 int result;
253
254 result = _stb0899_read_reg(state, reg);
255
256
257
258
259
260 if ((reg != 0xf2ff) && (reg != 0xf6ff) &&
261 (((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600)))
262 _stb0899_read_reg(state, (reg | 0x00ff));
263
264 return result;
265 }
266
267 u32 _stb0899_read_s2reg(struct stb0899_state *state,
268 u32 stb0899_i2cdev,
269 u32 stb0899_base_addr,
270 u16 stb0899_reg_offset)
271 {
272 int status;
273 u32 data;
274 u8 buf[7] = { 0 };
275 u16 tmpaddr;
276
277 u8 buf_0[] = {
278 GETBYTE(stb0899_i2cdev, BYTE1),
279 GETBYTE(stb0899_i2cdev, BYTE0),
280 GETBYTE(stb0899_base_addr, BYTE0),
281 GETBYTE(stb0899_base_addr, BYTE1),
282 GETBYTE(stb0899_base_addr, BYTE2),
283 GETBYTE(stb0899_base_addr, BYTE3),
284 };
285 u8 buf_1[] = {
286 0x00,
287 0x00,
288 };
289
290 struct i2c_msg msg_0 = {
291 .addr = state->config->demod_address,
292 .flags = 0,
293 .buf = buf_0,
294 .len = 6
295 };
296
297 struct i2c_msg msg_1 = {
298 .addr = state->config->demod_address,
299 .flags = 0,
300 .buf = buf_1,
301 .len = 2
302 };
303
304 struct i2c_msg msg_r = {
305 .addr = state->config->demod_address,
306 .flags = I2C_M_RD,
307 .buf = buf,
308 .len = 4
309 };
310
311 tmpaddr = stb0899_reg_offset & 0xff00;
312 if (!(stb0899_reg_offset & 0x8))
313 tmpaddr = stb0899_reg_offset | 0x20;
314
315 buf_1[0] = GETBYTE(tmpaddr, BYTE1);
316 buf_1[1] = GETBYTE(tmpaddr, BYTE0);
317
318 status = i2c_transfer(state->i2c, &msg_0, 1);
319 if (status < 1) {
320 if (status != -ERESTARTSYS)
321 printk(KERN_ERR "%s ERR(1), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n",
322 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status);
323
324 goto err;
325 }
326
327
328 status = i2c_transfer(state->i2c, &msg_1, 1);
329 if (status < 1)
330 goto err;
331
332 status = i2c_transfer(state->i2c, &msg_r, 1);
333 if (status < 1)
334 goto err;
335
336 buf_1[0] = GETBYTE(stb0899_reg_offset, BYTE1);
337 buf_1[1] = GETBYTE(stb0899_reg_offset, BYTE0);
338
339
340 status = i2c_transfer(state->i2c, &msg_1, 1);
341 if (status < 1) {
342 if (status != -ERESTARTSYS)
343 printk(KERN_ERR "%s ERR(2), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n",
344 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status);
345 goto err;
346 }
347
348 status = i2c_transfer(state->i2c, &msg_r, 1);
349 if (status < 1) {
350 if (status != -ERESTARTSYS)
351 printk(KERN_ERR "%s ERR(3), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n",
352 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status);
353 return status < 0 ? status : -EREMOTEIO;
354 }
355
356 data = MAKEWORD32(buf[3], buf[2], buf[1], buf[0]);
357 if (unlikely(*state->verbose >= FE_DEBUGREG))
358 printk(KERN_DEBUG "%s Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Data=[0x%08x]\n",
359 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, data);
360
361 return data;
362
363 err:
364 return status < 0 ? status : -EREMOTEIO;
365 }
366
367 int stb0899_write_s2reg(struct stb0899_state *state,
368 u32 stb0899_i2cdev,
369 u32 stb0899_base_addr,
370 u16 stb0899_reg_offset,
371 u32 stb0899_data)
372 {
373 int status;
374
375
376 u8 buf_0[] = {
377 GETBYTE(stb0899_i2cdev, BYTE1),
378 GETBYTE(stb0899_i2cdev, BYTE0),
379 GETBYTE(stb0899_base_addr, BYTE0),
380 GETBYTE(stb0899_base_addr, BYTE1),
381 GETBYTE(stb0899_base_addr, BYTE2),
382 GETBYTE(stb0899_base_addr, BYTE3),
383 };
384 u8 buf_1[] = {
385 0x00,
386 0x00,
387 0x00,
388 0x00,
389 0x00,
390 0x00,
391 };
392
393 struct i2c_msg msg_0 = {
394 .addr = state->config->demod_address,
395 .flags = 0,
396 .buf = buf_0,
397 .len = 6
398 };
399
400 struct i2c_msg msg_1 = {
401 .addr = state->config->demod_address,
402 .flags = 0,
403 .buf = buf_1,
404 .len = 6
405 };
406
407 buf_1[0] = GETBYTE(stb0899_reg_offset, BYTE1);
408 buf_1[1] = GETBYTE(stb0899_reg_offset, BYTE0);
409 buf_1[2] = GETBYTE(stb0899_data, BYTE0);
410 buf_1[3] = GETBYTE(stb0899_data, BYTE1);
411 buf_1[4] = GETBYTE(stb0899_data, BYTE2);
412 buf_1[5] = GETBYTE(stb0899_data, BYTE3);
413
414 if (unlikely(*state->verbose >= FE_DEBUGREG))
415 printk(KERN_DEBUG "%s Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x]\n",
416 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data);
417
418 status = i2c_transfer(state->i2c, &msg_0, 1);
419 if (unlikely(status < 1)) {
420 if (status != -ERESTARTSYS)
421 printk(KERN_ERR "%s ERR (1), Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x], status=%d\n",
422 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data, status);
423 goto err;
424 }
425 status = i2c_transfer(state->i2c, &msg_1, 1);
426 if (unlikely(status < 1)) {
427 if (status != -ERESTARTSYS)
428 printk(KERN_ERR "%s ERR (2), Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x], status=%d\n",
429 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data, status);
430
431 return status < 0 ? status : -EREMOTEIO;
432 }
433
434 return 0;
435
436 err:
437 return status < 0 ? status : -EREMOTEIO;
438 }
439
440 int stb0899_read_regs(struct stb0899_state *state, unsigned int reg, u8 *buf, u32 count)
441 {
442 int status;
443
444 u8 b0[] = { reg >> 8, reg & 0xff };
445
446 struct i2c_msg msg[] = {
447 {
448 .addr = state->config->demod_address,
449 .flags = 0,
450 .buf = b0,
451 .len = 2
452 },{
453 .addr = state->config->demod_address,
454 .flags = I2C_M_RD,
455 .buf = buf,
456 .len = count
457 }
458 };
459
460 status = i2c_transfer(state->i2c, msg, 2);
461 if (status != 2) {
462 if (status != -ERESTARTSYS)
463 printk(KERN_ERR "%s Read error, Reg=[0x%04x], Count=%u, Status=%d\n",
464 __func__, reg, count, status);
465 goto err;
466 }
467
468
469
470
471
472 if ((reg != 0xf2ff) && (reg != 0xf6ff) &&
473 (((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600)))
474 _stb0899_read_reg(state, (reg | 0x00ff));
475
476 dprintk(state->verbose, FE_DEBUGREG, 1,
477 "%s [0x%04x]: %*ph", __func__, reg, count, buf);
478
479 return 0;
480 err:
481 return status < 0 ? status : -EREMOTEIO;
482 }
483
484 int stb0899_write_regs(struct stb0899_state *state, unsigned int reg, u8 *data, u32 count)
485 {
486 int ret;
487 u8 buf[MAX_XFER_SIZE];
488 struct i2c_msg i2c_msg = {
489 .addr = state->config->demod_address,
490 .flags = 0,
491 .buf = buf,
492 .len = 2 + count
493 };
494
495 if (2 + count > sizeof(buf)) {
496 printk(KERN_WARNING
497 "%s: i2c wr reg=%04x: len=%d is too big!\n",
498 KBUILD_MODNAME, reg, count);
499 return -EINVAL;
500 }
501
502 buf[0] = reg >> 8;
503 buf[1] = reg & 0xff;
504 memcpy(&buf[2], data, count);
505
506 dprintk(state->verbose, FE_DEBUGREG, 1,
507 "%s [0x%04x]: %*ph", __func__, reg, count, data);
508 ret = i2c_transfer(state->i2c, &i2c_msg, 1);
509
510
511
512
513
514
515 if ((((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600)))
516 stb0899_read_reg(state, (reg | 0x00ff));
517
518 if (ret != 1) {
519 if (ret != -ERESTARTSYS)
520 dprintk(state->verbose, FE_ERROR, 1, "Reg=[0x%04x], Data=[0x%02x ...], Count=%u, Status=%d",
521 reg, data[0], count, ret);
522 return ret < 0 ? ret : -EREMOTEIO;
523 }
524
525 return 0;
526 }
527
528 int stb0899_write_reg(struct stb0899_state *state, unsigned int reg, u8 data)
529 {
530 u8 tmp = data;
531 return stb0899_write_regs(state, reg, &tmp, 1);
532 }
533
534
535
536
537
538
539 static u32 stb0899_get_mclk(struct stb0899_state *state)
540 {
541 u32 mclk = 0, div = 0;
542
543 div = stb0899_read_reg(state, STB0899_NCOARSE);
544 mclk = (div + 1) * state->config->xtal_freq / 6;
545 dprintk(state->verbose, FE_DEBUG, 1, "div=%d, mclk=%d", div, mclk);
546
547 return mclk;
548 }
549
550
551
552
553
554
555
556 static void stb0899_set_mclk(struct stb0899_state *state, u32 Mclk)
557 {
558 struct stb0899_internal *internal = &state->internal;
559 u8 mdiv = 0;
560
561 dprintk(state->verbose, FE_DEBUG, 1, "state->config=%p", state->config);
562 mdiv = ((6 * Mclk) / state->config->xtal_freq) - 1;
563 dprintk(state->verbose, FE_DEBUG, 1, "mdiv=%d", mdiv);
564
565 stb0899_write_reg(state, STB0899_NCOARSE, mdiv);
566 internal->master_clk = stb0899_get_mclk(state);
567
568 dprintk(state->verbose, FE_DEBUG, 1, "MasterCLOCK=%d", internal->master_clk);
569 }
570
571 static int stb0899_postproc(struct stb0899_state *state, u8 ctl, int enable)
572 {
573 struct stb0899_config *config = state->config;
574 const struct stb0899_postproc *postproc = config->postproc;
575
576
577 if (postproc) {
578 if (enable) {
579 if (postproc[ctl].level == STB0899_GPIOPULLUP)
580 stb0899_write_reg(state, postproc[ctl].gpio, 0x02);
581 else
582 stb0899_write_reg(state, postproc[ctl].gpio, 0x82);
583 } else {
584 if (postproc[ctl].level == STB0899_GPIOPULLUP)
585 stb0899_write_reg(state, postproc[ctl].gpio, 0x82);
586 else
587 stb0899_write_reg(state, postproc[ctl].gpio, 0x02);
588 }
589 }
590 return 0;
591 }
592
593 static void stb0899_detach(struct dvb_frontend *fe)
594 {
595 struct stb0899_state *state = fe->demodulator_priv;
596
597
598 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 0);
599 }
600
601 static void stb0899_release(struct dvb_frontend *fe)
602 {
603 struct stb0899_state *state = fe->demodulator_priv;
604
605 dprintk(state->verbose, FE_DEBUG, 1, "Release Frontend");
606 kfree(state);
607 }
608
609
610
611
612
613 static int stb0899_get_alpha(struct stb0899_state *state)
614 {
615 u8 mode_coeff;
616
617 mode_coeff = stb0899_read_reg(state, STB0899_DEMOD);
618
619 if (STB0899_GETFIELD(MODECOEFF, mode_coeff) == 1)
620 return 20;
621 else
622 return 35;
623 }
624
625
626
627
628 static void stb0899_init_calc(struct stb0899_state *state)
629 {
630 struct stb0899_internal *internal = &state->internal;
631 int master_clk;
632 u8 agc[2];
633 u32 reg;
634
635
636 stb0899_read_regs(state, STB0899_AGC1REF, agc, 2);
637
638
639 master_clk = stb0899_get_mclk(state);
640 internal->t_agc1 = 0;
641 internal->t_agc2 = 0;
642 internal->master_clk = master_clk;
643 internal->mclk = master_clk / 65536L;
644 internal->rolloff = stb0899_get_alpha(state);
645
646
647
648 internal->agc_gain = 8154;
649 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, IF_AGC_CNTRL);
650 STB0899_SETFIELD_VAL(IF_GAIN_INIT, reg, internal->agc_gain);
651 stb0899_write_s2reg(state, STB0899_S2DEMOD, STB0899_BASE_IF_AGC_CNTRL, STB0899_OFF0_IF_AGC_CNTRL, reg);
652
653 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, RRC_ALPHA);
654 internal->rrc_alpha = STB0899_GETFIELD(RRC_ALPHA, reg);
655
656 internal->center_freq = 0;
657 internal->av_frame_coarse = 10;
658 internal->av_frame_fine = 20;
659 internal->step_size = 2;
660
661
662
663
664
665
666 }
667
668 static int stb0899_wait_diseqc_fifo_empty(struct stb0899_state *state, int timeout)
669 {
670 u8 reg = 0;
671 unsigned long start = jiffies;
672
673 while (1) {
674 reg = stb0899_read_reg(state, STB0899_DISSTATUS);
675 if (!STB0899_GETFIELD(FIFOFULL, reg))
676 break;
677 if (time_after(jiffies, start + timeout)) {
678 dprintk(state->verbose, FE_ERROR, 1, "timed out !!");
679 return -ETIMEDOUT;
680 }
681 }
682
683 return 0;
684 }
685
686 static int stb0899_send_diseqc_msg(struct dvb_frontend *fe, struct dvb_diseqc_master_cmd *cmd)
687 {
688 struct stb0899_state *state = fe->demodulator_priv;
689 u8 reg, i;
690
691 if (cmd->msg_len > sizeof(cmd->msg))
692 return -EINVAL;
693
694
695 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
696 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 1);
697 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
698 for (i = 0; i < cmd->msg_len; i++) {
699
700 if (stb0899_wait_diseqc_fifo_empty(state, 100) < 0)
701 return -ETIMEDOUT;
702
703 stb0899_write_reg(state, STB0899_DISFIFO, cmd->msg[i]);
704 }
705 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
706 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0);
707 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
708 msleep(100);
709 return 0;
710 }
711
712 static int stb0899_wait_diseqc_rxidle(struct stb0899_state *state, int timeout)
713 {
714 u8 reg = 0;
715 unsigned long start = jiffies;
716
717 while (!STB0899_GETFIELD(RXEND, reg)) {
718 reg = stb0899_read_reg(state, STB0899_DISRX_ST0);
719 if (time_after(jiffies, start + timeout)) {
720 dprintk(state->verbose, FE_ERROR, 1, "timed out!!");
721 return -ETIMEDOUT;
722 }
723 msleep(10);
724 }
725
726 return 0;
727 }
728
729 static int stb0899_recv_slave_reply(struct dvb_frontend *fe, struct dvb_diseqc_slave_reply *reply)
730 {
731 struct stb0899_state *state = fe->demodulator_priv;
732 u8 reg, length = 0, i;
733 int result;
734
735 if (stb0899_wait_diseqc_rxidle(state, 100) < 0)
736 return -ETIMEDOUT;
737
738 reg = stb0899_read_reg(state, STB0899_DISRX_ST0);
739 if (STB0899_GETFIELD(RXEND, reg)) {
740
741 reg = stb0899_read_reg(state, STB0899_DISRX_ST1);
742 length = STB0899_GETFIELD(FIFOBYTENBR, reg);
743
744 if (length > sizeof (reply->msg)) {
745 result = -EOVERFLOW;
746 goto exit;
747 }
748 reply->msg_len = length;
749
750
751 for (i = 0; i < length; i++)
752 reply->msg[i] = stb0899_read_reg(state, STB0899_DISFIFO);
753 }
754
755 return 0;
756 exit:
757
758 return result;
759 }
760
761 static int stb0899_wait_diseqc_txidle(struct stb0899_state *state, int timeout)
762 {
763 u8 reg = 0;
764 unsigned long start = jiffies;
765
766 while (!STB0899_GETFIELD(TXIDLE, reg)) {
767 reg = stb0899_read_reg(state, STB0899_DISSTATUS);
768 if (time_after(jiffies, start + timeout)) {
769 dprintk(state->verbose, FE_ERROR, 1, "timed out!!");
770 return -ETIMEDOUT;
771 }
772 msleep(10);
773 }
774 return 0;
775 }
776
777 static int stb0899_send_diseqc_burst(struct dvb_frontend *fe,
778 enum fe_sec_mini_cmd burst)
779 {
780 struct stb0899_state *state = fe->demodulator_priv;
781 u8 reg, old_state;
782
783
784 if (stb0899_wait_diseqc_txidle(state, 100) < 0)
785 return -ETIMEDOUT;
786
787 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
788 old_state = reg;
789
790 STB0899_SETFIELD_VAL(DISEQCMODE, reg, 0x03);
791 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0x01);
792 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
793 switch (burst) {
794 case SEC_MINI_A:
795
796 stb0899_write_reg(state, STB0899_DISFIFO, 0x00);
797 break;
798 case SEC_MINI_B:
799
800 stb0899_write_reg(state, STB0899_DISFIFO, 0xff);
801 break;
802 }
803 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
804 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0x00);
805 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
806
807 if (stb0899_wait_diseqc_txidle(state, 100) < 0)
808 return -ETIMEDOUT;
809
810
811 stb0899_write_reg(state, STB0899_DISCNTRL1, old_state);
812
813 return 0;
814 }
815
816 static int stb0899_diseqc_init(struct stb0899_state *state)
817 {
818
819
820
821 u8 f22_tx, reg;
822
823 u32 mclk, tx_freq = 22000;
824 reg = stb0899_read_reg(state, STB0899_DISCNTRL2);
825 STB0899_SETFIELD_VAL(ONECHIP_TRX, reg, 0);
826 stb0899_write_reg(state, STB0899_DISCNTRL2, reg);
827
828
829 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
830 STB0899_SETFIELD_VAL(DISEQCRESET, reg, 1);
831 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
832
833 reg = stb0899_read_reg(state, STB0899_DISCNTRL1);
834 STB0899_SETFIELD_VAL(DISEQCRESET, reg, 0);
835 stb0899_write_reg(state, STB0899_DISCNTRL1, reg);
836
837 mclk = stb0899_get_mclk(state);
838 f22_tx = mclk / (tx_freq * 32);
839 stb0899_write_reg(state, STB0899_DISF22, f22_tx);
840 state->rx_freq = 20000;
841
842 return 0;
843 }
844
845 static int stb0899_sleep(struct dvb_frontend *fe)
846 {
847 struct stb0899_state *state = fe->demodulator_priv;
848
849
850
851 dprintk(state->verbose, FE_DEBUG, 1, "Going to Sleep .. (Really tired .. :-))");
852
853 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 0);
854
855 return 0;
856 }
857
858 static int stb0899_wakeup(struct dvb_frontend *fe)
859 {
860 int rc;
861 struct stb0899_state *state = fe->demodulator_priv;
862
863 if ((rc = stb0899_write_reg(state, STB0899_SYNTCTRL, STB0899_SELOSCI)))
864 return rc;
865
866 if ((rc = stb0899_write_reg(state, STB0899_STOPCLK1, 0x00)))
867 return rc;
868 if ((rc = stb0899_write_reg(state, STB0899_STOPCLK2, 0x00)))
869 return rc;
870
871
872 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 1);
873
874 return 0;
875 }
876
877 static int stb0899_init(struct dvb_frontend *fe)
878 {
879 int i;
880 struct stb0899_state *state = fe->demodulator_priv;
881 struct stb0899_config *config = state->config;
882
883 dprintk(state->verbose, FE_DEBUG, 1, "Initializing STB0899 ... ");
884
885
886 dprintk(state->verbose, FE_DEBUG, 1, "init device");
887 for (i = 0; config->init_dev[i].address != 0xffff; i++)
888 stb0899_write_reg(state, config->init_dev[i].address, config->init_dev[i].data);
889
890 dprintk(state->verbose, FE_DEBUG, 1, "init S2 demod");
891
892 for (i = 0; config->init_s2_demod[i].offset != 0xffff; i++)
893 stb0899_write_s2reg(state, STB0899_S2DEMOD,
894 config->init_s2_demod[i].base_address,
895 config->init_s2_demod[i].offset,
896 config->init_s2_demod[i].data);
897
898 dprintk(state->verbose, FE_DEBUG, 1, "init S1 demod");
899
900 for (i = 0; config->init_s1_demod[i].address != 0xffff; i++)
901 stb0899_write_reg(state, config->init_s1_demod[i].address, config->init_s1_demod[i].data);
902
903 dprintk(state->verbose, FE_DEBUG, 1, "init S2 FEC");
904
905 for (i = 0; config->init_s2_fec[i].offset != 0xffff; i++)
906 stb0899_write_s2reg(state, STB0899_S2FEC,
907 config->init_s2_fec[i].base_address,
908 config->init_s2_fec[i].offset,
909 config->init_s2_fec[i].data);
910
911 dprintk(state->verbose, FE_DEBUG, 1, "init TST");
912
913 for (i = 0; config->init_tst[i].address != 0xffff; i++)
914 stb0899_write_reg(state, config->init_tst[i].address, config->init_tst[i].data);
915
916 stb0899_init_calc(state);
917 stb0899_diseqc_init(state);
918
919 return 0;
920 }
921
922 static int stb0899_table_lookup(const struct stb0899_tab *tab, int max, int val)
923 {
924 int res = 0;
925 int min = 0, med;
926
927 if (val < tab[min].read)
928 res = tab[min].real;
929 else if (val >= tab[max].read)
930 res = tab[max].real;
931 else {
932 while ((max - min) > 1) {
933 med = (max + min) / 2;
934 if (val >= tab[min].read && val < tab[med].read)
935 max = med;
936 else
937 min = med;
938 }
939 res = ((val - tab[min].read) *
940 (tab[max].real - tab[min].real) /
941 (tab[max].read - tab[min].read)) +
942 tab[min].real;
943 }
944
945 return res;
946 }
947
948 static int stb0899_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
949 {
950 struct stb0899_state *state = fe->demodulator_priv;
951 struct stb0899_internal *internal = &state->internal;
952
953 int val;
954 u32 reg;
955 *strength = 0;
956 switch (state->delsys) {
957 case SYS_DVBS:
958 case SYS_DSS:
959 if (internal->lock) {
960 reg = stb0899_read_reg(state, STB0899_VSTATUS);
961 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) {
962
963 reg = stb0899_read_reg(state, STB0899_AGCIQIN);
964 val = (s32)(s8)STB0899_GETFIELD(AGCIQVALUE, reg);
965
966 *strength = stb0899_table_lookup(stb0899_dvbsrf_tab, ARRAY_SIZE(stb0899_dvbsrf_tab) - 1, val);
967 *strength += 750;
968 dprintk(state->verbose, FE_DEBUG, 1, "AGCIQVALUE = 0x%02x, C = %d * 0.1 dBm",
969 val & 0xff, *strength);
970 }
971 }
972 break;
973 case SYS_DVBS2:
974 if (internal->lock) {
975 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, IF_AGC_GAIN);
976 val = STB0899_GETFIELD(IF_AGC_GAIN, reg);
977
978 *strength = stb0899_table_lookup(stb0899_dvbs2rf_tab, ARRAY_SIZE(stb0899_dvbs2rf_tab) - 1, val);
979 *strength += 950;
980 dprintk(state->verbose, FE_DEBUG, 1, "IF_AGC_GAIN = 0x%04x, C = %d * 0.1 dBm",
981 val & 0x3fff, *strength);
982 }
983 break;
984 default:
985 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system");
986 return -EINVAL;
987 }
988
989 return 0;
990 }
991
992 static int stb0899_read_snr(struct dvb_frontend *fe, u16 *snr)
993 {
994 struct stb0899_state *state = fe->demodulator_priv;
995 struct stb0899_internal *internal = &state->internal;
996
997 unsigned int val, quant, quantn = -1, est, estn = -1;
998 u8 buf[2];
999 u32 reg;
1000
1001 *snr = 0;
1002 reg = stb0899_read_reg(state, STB0899_VSTATUS);
1003 switch (state->delsys) {
1004 case SYS_DVBS:
1005 case SYS_DSS:
1006 if (internal->lock) {
1007 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) {
1008
1009 stb0899_read_regs(state, STB0899_NIRM, buf, 2);
1010 val = MAKEWORD16(buf[0], buf[1]);
1011
1012 *snr = stb0899_table_lookup(stb0899_cn_tab, ARRAY_SIZE(stb0899_cn_tab) - 1, val);
1013 dprintk(state->verbose, FE_DEBUG, 1, "NIR = 0x%02x%02x = %u, C/N = %d * 0.1 dBm\n",
1014 buf[0], buf[1], val, *snr);
1015 }
1016 }
1017 break;
1018 case SYS_DVBS2:
1019 if (internal->lock) {
1020 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, UWP_CNTRL1);
1021 quant = STB0899_GETFIELD(UWP_ESN0_QUANT, reg);
1022 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, UWP_STAT2);
1023 est = STB0899_GETFIELD(ESN0_EST, reg);
1024 if (est == 1)
1025 val = 301;
1026 else if (est == 2)
1027 val = 270;
1028 else {
1029
1030 quantn = stb0899_table_lookup(stb0899_quant_tab, ARRAY_SIZE(stb0899_quant_tab) - 1, quant * 100);
1031
1032 estn = stb0899_table_lookup(stb0899_est_tab, ARRAY_SIZE(stb0899_est_tab) - 1, est);
1033
1034 val = (quantn - estn) / 10;
1035 }
1036 *snr = val;
1037 dprintk(state->verbose, FE_DEBUG, 1, "Es/N0 quant = %d (%d) estimate = %u (%d), C/N = %d * 0.1 dBm",
1038 quant, quantn, est, estn, val);
1039 }
1040 break;
1041 default:
1042 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system");
1043 return -EINVAL;
1044 }
1045
1046 return 0;
1047 }
1048
1049 static int stb0899_read_status(struct dvb_frontend *fe, enum fe_status *status)
1050 {
1051 struct stb0899_state *state = fe->demodulator_priv;
1052 struct stb0899_internal *internal = &state->internal;
1053 u8 reg;
1054 *status = 0;
1055
1056 switch (state->delsys) {
1057 case SYS_DVBS:
1058 case SYS_DSS:
1059 dprintk(state->verbose, FE_DEBUG, 1, "Delivery system DVB-S/DSS");
1060 if (internal->lock) {
1061 reg = stb0899_read_reg(state, STB0899_VSTATUS);
1062 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) {
1063 dprintk(state->verbose, FE_DEBUG, 1, "--------> FE_HAS_CARRIER | FE_HAS_LOCK");
1064 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK;
1065
1066 reg = stb0899_read_reg(state, STB0899_PLPARM);
1067 if (STB0899_GETFIELD(VITCURPUN, reg)) {
1068 dprintk(state->verbose, FE_DEBUG, 1, "--------> FE_HAS_VITERBI | FE_HAS_SYNC");
1069 *status |= FE_HAS_VITERBI | FE_HAS_SYNC;
1070
1071 stb0899_postproc(state, STB0899_POSTPROC_GPIO_LOCK, 1);
1072 }
1073 }
1074 }
1075 break;
1076 case SYS_DVBS2:
1077 dprintk(state->verbose, FE_DEBUG, 1, "Delivery system DVB-S2");
1078 if (internal->lock) {
1079 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_STAT2);
1080 if (STB0899_GETFIELD(UWP_LOCK, reg) && STB0899_GETFIELD(CSM_LOCK, reg)) {
1081 *status |= FE_HAS_CARRIER;
1082 dprintk(state->verbose, FE_DEBUG, 1,
1083 "UWP & CSM Lock ! ---> DVB-S2 FE_HAS_CARRIER");
1084
1085 reg = stb0899_read_reg(state, STB0899_CFGPDELSTATUS1);
1086 if (STB0899_GETFIELD(CFGPDELSTATUS_LOCK, reg)) {
1087 *status |= FE_HAS_LOCK;
1088 dprintk(state->verbose, FE_DEBUG, 1,
1089 "Packet Delineator Locked ! -----> DVB-S2 FE_HAS_LOCK");
1090
1091 }
1092 if (STB0899_GETFIELD(CONTINUOUS_STREAM, reg)) {
1093 *status |= FE_HAS_VITERBI;
1094 dprintk(state->verbose, FE_DEBUG, 1,
1095 "Packet Delineator found VITERBI ! -----> DVB-S2 FE_HAS_VITERBI");
1096 }
1097 if (STB0899_GETFIELD(ACCEPTED_STREAM, reg)) {
1098 *status |= FE_HAS_SYNC;
1099 dprintk(state->verbose, FE_DEBUG, 1,
1100 "Packet Delineator found SYNC ! -----> DVB-S2 FE_HAS_SYNC");
1101
1102 stb0899_postproc(state, STB0899_POSTPROC_GPIO_LOCK, 1);
1103 }
1104 }
1105 }
1106 break;
1107 default:
1108 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system");
1109 return -EINVAL;
1110 }
1111 return 0;
1112 }
1113
1114
1115
1116
1117
1118
1119
1120 static int stb0899_read_ber(struct dvb_frontend *fe, u32 *ber)
1121 {
1122 struct stb0899_state *state = fe->demodulator_priv;
1123 struct stb0899_internal *internal = &state->internal;
1124
1125 u8 lsb, msb;
1126
1127 *ber = 0;
1128
1129 switch (state->delsys) {
1130 case SYS_DVBS:
1131 case SYS_DSS:
1132 if (internal->lock) {
1133 lsb = stb0899_read_reg(state, STB0899_ECNT1L);
1134 msb = stb0899_read_reg(state, STB0899_ECNT1M);
1135 *ber = MAKEWORD16(msb, lsb);
1136
1137 if (STB0899_GETFIELD(VSTATUS_PRFVIT, internal->v_status)) {
1138
1139 *ber *= 9766;
1140
1141 *ber /= (-1 + (1 << (2 * STB0899_GETFIELD(NOE, internal->err_ctrl))));
1142 *ber /= 8;
1143 }
1144 }
1145 break;
1146 case SYS_DVBS2:
1147 if (internal->lock) {
1148 lsb = stb0899_read_reg(state, STB0899_ECNT1L);
1149 msb = stb0899_read_reg(state, STB0899_ECNT1M);
1150 *ber = MAKEWORD16(msb, lsb);
1151
1152 *ber *= 10000000;
1153 *ber /= (-1 + (1 << (4 + 2 * STB0899_GETFIELD(NOE, internal->err_ctrl))));
1154 }
1155 break;
1156 default:
1157 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system");
1158 return -EINVAL;
1159 }
1160
1161 return 0;
1162 }
1163
1164 static int stb0899_set_voltage(struct dvb_frontend *fe,
1165 enum fe_sec_voltage voltage)
1166 {
1167 struct stb0899_state *state = fe->demodulator_priv;
1168
1169 switch (voltage) {
1170 case SEC_VOLTAGE_13:
1171 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x82);
1172 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x02);
1173 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x00);
1174 break;
1175 case SEC_VOLTAGE_18:
1176 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x02);
1177 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x02);
1178 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x82);
1179 break;
1180 case SEC_VOLTAGE_OFF:
1181 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x82);
1182 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x82);
1183 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x82);
1184 break;
1185 default:
1186 return -EINVAL;
1187 }
1188
1189 return 0;
1190 }
1191
1192 static int stb0899_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
1193 {
1194 struct stb0899_state *state = fe->demodulator_priv;
1195 struct stb0899_internal *internal = &state->internal;
1196
1197 u8 div, reg;
1198
1199
1200 if (stb0899_wait_diseqc_txidle(state, 100) < 0)
1201 return -ETIMEDOUT;
1202
1203 switch (tone) {
1204 case SEC_TONE_ON:
1205 div = (internal->master_clk / 100) / 5632;
1206 div = (div + 5) / 10;
1207 stb0899_write_reg(state, STB0899_DISEQCOCFG, 0x66);
1208 reg = stb0899_read_reg(state, STB0899_ACRPRESC);
1209 STB0899_SETFIELD_VAL(ACRPRESC, reg, 0x03);
1210 stb0899_write_reg(state, STB0899_ACRPRESC, reg);
1211 stb0899_write_reg(state, STB0899_ACRDIV1, div);
1212 break;
1213 case SEC_TONE_OFF:
1214 stb0899_write_reg(state, STB0899_DISEQCOCFG, 0x20);
1215 break;
1216 default:
1217 return -EINVAL;
1218 }
1219 return 0;
1220 }
1221
1222 int stb0899_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
1223 {
1224 int i2c_stat;
1225 struct stb0899_state *state = fe->demodulator_priv;
1226
1227 i2c_stat = stb0899_read_reg(state, STB0899_I2CRPT);
1228 if (i2c_stat < 0)
1229 goto err;
1230
1231 if (enable) {
1232 dprintk(state->verbose, FE_DEBUG, 1, "Enabling I2C Repeater ...");
1233 i2c_stat |= STB0899_I2CTON;
1234 if (stb0899_write_reg(state, STB0899_I2CRPT, i2c_stat) < 0)
1235 goto err;
1236 } else {
1237 dprintk(state->verbose, FE_DEBUG, 1, "Disabling I2C Repeater ...");
1238 i2c_stat &= ~STB0899_I2CTON;
1239 if (stb0899_write_reg(state, STB0899_I2CRPT, i2c_stat) < 0)
1240 goto err;
1241 }
1242 return 0;
1243 err:
1244 dprintk(state->verbose, FE_ERROR, 1, "I2C Repeater control failed");
1245 return -EREMOTEIO;
1246 }
1247
1248
1249 static inline void CONVERT32(u32 x, char *str)
1250 {
1251 *str++ = (x >> 24) & 0xff;
1252 *str++ = (x >> 16) & 0xff;
1253 *str++ = (x >> 8) & 0xff;
1254 *str++ = (x >> 0) & 0xff;
1255 *str = '\0';
1256 }
1257
1258 static int stb0899_get_dev_id(struct stb0899_state *state)
1259 {
1260 u8 chip_id, release;
1261 u16 id;
1262 u32 demod_ver = 0, fec_ver = 0;
1263 char demod_str[5] = { 0 };
1264 char fec_str[5] = { 0 };
1265
1266 id = stb0899_read_reg(state, STB0899_DEV_ID);
1267 dprintk(state->verbose, FE_DEBUG, 1, "ID reg=[0x%02x]", id);
1268 chip_id = STB0899_GETFIELD(CHIP_ID, id);
1269 release = STB0899_GETFIELD(CHIP_REL, id);
1270
1271 dprintk(state->verbose, FE_ERROR, 1, "Device ID=[%d], Release=[%d]",
1272 chip_id, release);
1273
1274 CONVERT32(STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_CORE_ID), (char *)&demod_str);
1275
1276 demod_ver = STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_VERSION_ID);
1277 dprintk(state->verbose, FE_ERROR, 1, "Demodulator Core ID=[%s], Version=[%d]", (char *) &demod_str, demod_ver);
1278 CONVERT32(STB0899_READ_S2REG(STB0899_S2FEC, FEC_CORE_ID_REG), (char *)&fec_str);
1279 fec_ver = STB0899_READ_S2REG(STB0899_S2FEC, FEC_VER_ID_REG);
1280 if (! (chip_id > 0)) {
1281 dprintk(state->verbose, FE_ERROR, 1, "couldn't find a STB 0899");
1282
1283 return -ENODEV;
1284 }
1285 dprintk(state->verbose, FE_ERROR, 1, "FEC Core ID=[%s], Version=[%d]", (char*) &fec_str, fec_ver);
1286
1287 return 0;
1288 }
1289
1290 static void stb0899_set_delivery(struct stb0899_state *state)
1291 {
1292 u8 reg;
1293 u8 stop_clk[2];
1294
1295 stop_clk[0] = stb0899_read_reg(state, STB0899_STOPCLK1);
1296 stop_clk[1] = stb0899_read_reg(state, STB0899_STOPCLK2);
1297
1298 switch (state->delsys) {
1299 case SYS_DVBS:
1300 dprintk(state->verbose, FE_DEBUG, 1, "Delivery System -- DVB-S");
1301
1302 reg = stb0899_read_reg(state, STB0899_FECM);
1303 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 0);
1304 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 1);
1305 stb0899_write_reg(state, STB0899_FECM, reg);
1306
1307 stb0899_write_reg(state, STB0899_RSULC, 0xb1);
1308 stb0899_write_reg(state, STB0899_TSULC, 0x40);
1309 stb0899_write_reg(state, STB0899_RSLLC, 0x42);
1310 stb0899_write_reg(state, STB0899_TSLPL, 0x12);
1311
1312 reg = stb0899_read_reg(state, STB0899_TSTRES);
1313 STB0899_SETFIELD_VAL(FRESLDPC, reg, 1);
1314 stb0899_write_reg(state, STB0899_TSTRES, reg);
1315
1316 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1);
1317 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 1);
1318 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 1);
1319
1320 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 1);
1321 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 1);
1322
1323 STB0899_SETFIELD_VAL(STOP_CKINTBUF216, stop_clk[0], 1);
1324 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0);
1325
1326 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 1);
1327 break;
1328 case SYS_DVBS2:
1329
1330 reg = stb0899_read_reg(state, STB0899_FECM);
1331 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 0);
1332 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 0);
1333 stb0899_write_reg(state, STB0899_FECM, reg);
1334
1335 stb0899_write_reg(state, STB0899_RSULC, 0xb1);
1336 stb0899_write_reg(state, STB0899_TSULC, 0x42);
1337 stb0899_write_reg(state, STB0899_RSLLC, 0x40);
1338 stb0899_write_reg(state, STB0899_TSLPL, 0x02);
1339
1340 reg = stb0899_read_reg(state, STB0899_TSTRES);
1341 STB0899_SETFIELD_VAL(FRESLDPC, reg, 0);
1342 stb0899_write_reg(state, STB0899_TSTRES, reg);
1343
1344 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1);
1345 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 0);
1346 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 0);
1347
1348 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 0);
1349 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 0);
1350
1351 STB0899_SETFIELD_VAL(STOP_CKINTBUF216, stop_clk[0], 0);
1352 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0);
1353
1354 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 0);
1355 break;
1356 case SYS_DSS:
1357
1358 reg = stb0899_read_reg(state, STB0899_FECM);
1359 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 1);
1360 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 1);
1361 stb0899_write_reg(state, STB0899_FECM, reg);
1362
1363 stb0899_write_reg(state, STB0899_RSULC, 0xa1);
1364 stb0899_write_reg(state, STB0899_TSULC, 0x61);
1365 stb0899_write_reg(state, STB0899_RSLLC, 0x42);
1366
1367 reg = stb0899_read_reg(state, STB0899_TSTRES);
1368 STB0899_SETFIELD_VAL(FRESLDPC, reg, 1);
1369 stb0899_write_reg(state, STB0899_TSTRES, reg);
1370
1371 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1);
1372 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 1);
1373 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 1);
1374
1375 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 1);
1376 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 1);
1377
1378 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0);
1379
1380 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 1);
1381 break;
1382 default:
1383 dprintk(state->verbose, FE_ERROR, 1, "Unsupported delivery system");
1384 break;
1385 }
1386 STB0899_SETFIELD_VAL(STOP_CKADCI108, stop_clk[0], 0);
1387 stb0899_write_regs(state, STB0899_STOPCLK1, stop_clk, 2);
1388 }
1389
1390
1391
1392
1393
1394 static void stb0899_set_iterations(struct stb0899_state *state)
1395 {
1396 struct stb0899_internal *internal = &state->internal;
1397 struct stb0899_config *config = state->config;
1398
1399 s32 iter_scale;
1400 u32 reg;
1401
1402 iter_scale = 17 * (internal->master_clk / 1000);
1403 iter_scale += 410000;
1404 iter_scale /= (internal->srate / 1000000);
1405 iter_scale /= 1000;
1406
1407 if (iter_scale > config->ldpc_max_iter)
1408 iter_scale = config->ldpc_max_iter;
1409
1410 reg = STB0899_READ_S2REG(STB0899_S2FEC, MAX_ITER);
1411 STB0899_SETFIELD_VAL(MAX_ITERATIONS, reg, iter_scale);
1412 stb0899_write_s2reg(state, STB0899_S2FEC, STB0899_BASE_MAX_ITER, STB0899_OFF0_MAX_ITER, reg);
1413 }
1414
1415 static enum dvbfe_search stb0899_search(struct dvb_frontend *fe)
1416 {
1417 struct stb0899_state *state = fe->demodulator_priv;
1418 struct stb0899_params *i_params = &state->params;
1419 struct stb0899_internal *internal = &state->internal;
1420 struct stb0899_config *config = state->config;
1421 struct dtv_frontend_properties *props = &fe->dtv_property_cache;
1422
1423 u32 SearchRange, gain;
1424
1425 i_params->freq = props->frequency;
1426 i_params->srate = props->symbol_rate;
1427 state->delsys = props->delivery_system;
1428 dprintk(state->verbose, FE_DEBUG, 1, "delivery system=%d", state->delsys);
1429
1430 SearchRange = 10000000;
1431 dprintk(state->verbose, FE_DEBUG, 1, "Frequency=%d, Srate=%d", i_params->freq, i_params->srate);
1432
1433 if (INRANGE(i_params->srate, 1000000, 45000000)) {
1434 dprintk(state->verbose, FE_DEBUG, 1, "Parameters IN RANGE");
1435 stb0899_set_delivery(state);
1436
1437 if (state->config->tuner_set_rfsiggain) {
1438 if (internal->srate > 15000000)
1439 gain = 8;
1440 else if (internal->srate > 5000000)
1441 gain = 12;
1442 else
1443 gain = 14;
1444 state->config->tuner_set_rfsiggain(fe, gain);
1445 }
1446
1447 if (i_params->srate <= 5000000)
1448 stb0899_set_mclk(state, config->lo_clk);
1449 else
1450 stb0899_set_mclk(state, config->hi_clk);
1451
1452 switch (state->delsys) {
1453 case SYS_DVBS:
1454 case SYS_DSS:
1455 dprintk(state->verbose, FE_DEBUG, 1, "DVB-S delivery system");
1456 internal->freq = i_params->freq;
1457 internal->srate = i_params->srate;
1458
1459
1460
1461
1462
1463
1464 internal->srch_range = SearchRange + 1500000 + (i_params->srate / 5);
1465 internal->derot_percent = 30;
1466
1467
1468
1469 stb0899_i2c_gate_ctrl(&state->frontend, 1);
1470
1471 if (state->config->tuner_set_bandwidth)
1472 state->config->tuner_set_bandwidth(fe, (13 * (stb0899_carr_width(state) + SearchRange)) / 10);
1473 if (state->config->tuner_get_bandwidth)
1474 state->config->tuner_get_bandwidth(fe, &internal->tuner_bw);
1475
1476
1477 stb0899_i2c_gate_ctrl(&state->frontend, 0);
1478
1479
1480 stb0899_write_reg(state, STB0899_AGCRFCFG, 0x11);
1481
1482
1483 dprintk(state->verbose, FE_DEBUG, 1, "running DVB-S search algo ..");
1484 if (stb0899_dvbs_algo(state) == RANGEOK) {
1485 internal->lock = 1;
1486 dprintk(state->verbose, FE_DEBUG, 1,
1487 "-------------------------------------> DVB-S LOCK !");
1488
1489
1490
1491
1492
1493
1494
1495 return DVBFE_ALGO_SEARCH_SUCCESS;
1496 } else {
1497 internal->lock = 0;
1498
1499 return DVBFE_ALGO_SEARCH_FAILED;
1500 }
1501 break;
1502 case SYS_DVBS2:
1503 internal->freq = i_params->freq;
1504 internal->srate = i_params->srate;
1505 internal->srch_range = SearchRange;
1506
1507
1508 stb0899_i2c_gate_ctrl(&state->frontend, 1);
1509
1510 if (state->config->tuner_set_bandwidth)
1511 state->config->tuner_set_bandwidth(fe, (stb0899_carr_width(state) + SearchRange));
1512 if (state->config->tuner_get_bandwidth)
1513 state->config->tuner_get_bandwidth(fe, &internal->tuner_bw);
1514
1515
1516 stb0899_i2c_gate_ctrl(&state->frontend, 0);
1517
1518
1519
1520
1521 stb0899_write_reg(state, STB0899_AGCRFCFG, 0x1c);
1522
1523
1524 stb0899_set_iterations(state);
1525
1526
1527 dprintk(state->verbose, FE_DEBUG, 1, "running DVB-S2 search algo ..");
1528 if (stb0899_dvbs2_algo(state) == DVBS2_FEC_LOCK) {
1529 internal->lock = 1;
1530 dprintk(state->verbose, FE_DEBUG, 1,
1531 "-------------------------------------> DVB-S2 LOCK !");
1532
1533
1534
1535
1536
1537 return DVBFE_ALGO_SEARCH_SUCCESS;
1538 } else {
1539 internal->lock = 0;
1540
1541 return DVBFE_ALGO_SEARCH_FAILED;
1542 }
1543 break;
1544 default:
1545 dprintk(state->verbose, FE_ERROR, 1, "Unsupported delivery system");
1546 return DVBFE_ALGO_SEARCH_INVALID;
1547 }
1548 }
1549
1550 return DVBFE_ALGO_SEARCH_ERROR;
1551 }
1552
1553 static int stb0899_get_frontend(struct dvb_frontend *fe,
1554 struct dtv_frontend_properties *p)
1555 {
1556 struct stb0899_state *state = fe->demodulator_priv;
1557 struct stb0899_internal *internal = &state->internal;
1558
1559 dprintk(state->verbose, FE_DEBUG, 1, "Get params");
1560 p->symbol_rate = internal->srate;
1561 p->frequency = internal->freq;
1562
1563 return 0;
1564 }
1565
1566 static enum dvbfe_algo stb0899_frontend_algo(struct dvb_frontend *fe)
1567 {
1568 return DVBFE_ALGO_CUSTOM;
1569 }
1570
1571 static const struct dvb_frontend_ops stb0899_ops = {
1572 .delsys = { SYS_DVBS, SYS_DVBS2, SYS_DSS },
1573 .info = {
1574 .name = "STB0899 Multistandard",
1575 .frequency_min_hz = 950 * MHz,
1576 .frequency_max_hz = 2150 * MHz,
1577 .symbol_rate_min = 5000000,
1578 .symbol_rate_max = 45000000,
1579
1580 .caps = FE_CAN_INVERSION_AUTO |
1581 FE_CAN_FEC_AUTO |
1582 FE_CAN_2G_MODULATION |
1583 FE_CAN_QPSK
1584 },
1585
1586 .detach = stb0899_detach,
1587 .release = stb0899_release,
1588 .init = stb0899_init,
1589 .sleep = stb0899_sleep,
1590
1591
1592 .i2c_gate_ctrl = stb0899_i2c_gate_ctrl,
1593
1594 .get_frontend_algo = stb0899_frontend_algo,
1595 .search = stb0899_search,
1596 .get_frontend = stb0899_get_frontend,
1597
1598
1599 .read_status = stb0899_read_status,
1600 .read_snr = stb0899_read_snr,
1601 .read_signal_strength = stb0899_read_signal_strength,
1602 .read_ber = stb0899_read_ber,
1603
1604 .set_voltage = stb0899_set_voltage,
1605 .set_tone = stb0899_set_tone,
1606
1607 .diseqc_send_master_cmd = stb0899_send_diseqc_msg,
1608 .diseqc_recv_slave_reply = stb0899_recv_slave_reply,
1609 .diseqc_send_burst = stb0899_send_diseqc_burst,
1610 };
1611
1612 struct dvb_frontend *stb0899_attach(struct stb0899_config *config, struct i2c_adapter *i2c)
1613 {
1614 struct stb0899_state *state = NULL;
1615
1616 state = kzalloc(sizeof (struct stb0899_state), GFP_KERNEL);
1617 if (state == NULL)
1618 goto error;
1619
1620 state->verbose = &verbose;
1621 state->config = config;
1622 state->i2c = i2c;
1623 state->frontend.ops = stb0899_ops;
1624 state->frontend.demodulator_priv = state;
1625
1626 state->internal.inversion = config->inversion;
1627
1628 stb0899_wakeup(&state->frontend);
1629 if (stb0899_get_dev_id(state) == -ENODEV) {
1630 printk("%s: Exiting .. !\n", __func__);
1631 goto error;
1632 }
1633
1634 printk("%s: Attaching STB0899 \n", __func__);
1635 return &state->frontend;
1636
1637 error:
1638 kfree(state);
1639 return NULL;
1640 }
1641 EXPORT_SYMBOL(stb0899_attach);
1642 MODULE_PARM_DESC(verbose, "Set Verbosity level");
1643 MODULE_AUTHOR("Manu Abraham");
1644 MODULE_DESCRIPTION("STB0899 Multi-Std frontend");
1645 MODULE_LICENSE("GPL");