?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.12.39
[linux/fpc-iii.git] / drivers / media / dvb-frontends / ds3000.c
blob22e8c2032f6d8280d2e302fe2b21baadd3f127eb
1 /*
2 Montage Technology DS3000 - DVBS/S2 Demodulator driver
3 Copyright (C) 2009-2012 Konstantin Dimitrov <kosio.dimitrov@gmail.com>
4
5 Copyright (C) 2009-2012 TurboSight.com
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include <linux/slab.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/init.h>
27 #include <linux/firmware.h>
28
29 #include "dvb_frontend.h"
30 #include "ts2020.h"
31 #include "ds3000.h"
32
33 static int debug;
34
35 #define dprintk(args...) \
36 do { \
37 if (debug) \
38 printk(args); \
39 } while (0)
40
41 /* as of March 2009 current DS3000 firmware version is 1.78 */
42 /* DS3000 FW v1.78 MD5: a32d17910c4f370073f9346e71d34b80 */
43 #define DS3000_DEFAULT_FIRMWARE "dvb-fe-ds3000.fw"
44
45 #define DS3000_SAMPLE_RATE 96000 /* in kHz */
46
47 /* Register values to initialise the demod in DVB-S mode */
48 static u8 ds3000_dvbs_init_tab[] = {
49 0x23, 0x05,
50 0x08, 0x03,
51 0x0c, 0x00,
52 0x21, 0x54,
53 0x25, 0x82,
54 0x27, 0x31,
55 0x30, 0x08,
56 0x31, 0x40,
57 0x32, 0x32,
58 0x33, 0x35,
59 0x35, 0xff,
60 0x3a, 0x00,
61 0x37, 0x10,
62 0x38, 0x10,
63 0x39, 0x02,
64 0x42, 0x60,
65 0x4a, 0x40,
66 0x4b, 0x04,
67 0x4d, 0x91,
68 0x5d, 0xc8,
69 0x50, 0x77,
70 0x51, 0x77,
71 0x52, 0x36,
72 0x53, 0x36,
73 0x56, 0x01,
74 0x63, 0x43,
75 0x64, 0x30,
76 0x65, 0x40,
77 0x68, 0x26,
78 0x69, 0x4c,
79 0x70, 0x20,
80 0x71, 0x70,
81 0x72, 0x04,
82 0x73, 0x00,
83 0x70, 0x40,
84 0x71, 0x70,
85 0x72, 0x04,
86 0x73, 0x00,
87 0x70, 0x60,
88 0x71, 0x70,
89 0x72, 0x04,
90 0x73, 0x00,
91 0x70, 0x80,
92 0x71, 0x70,
93 0x72, 0x04,
94 0x73, 0x00,
95 0x70, 0xa0,
96 0x71, 0x70,
97 0x72, 0x04,
98 0x73, 0x00,
99 0x70, 0x1f,
100 0x76, 0x00,
101 0x77, 0xd1,
102 0x78, 0x0c,
103 0x79, 0x80,
104 0x7f, 0x04,
105 0x7c, 0x00,
106 0x80, 0x86,
107 0x81, 0xa6,
108 0x85, 0x04,
109 0xcd, 0xf4,
110 0x90, 0x33,
111 0xa0, 0x44,
112 0xc0, 0x18,
113 0xc3, 0x10,
114 0xc4, 0x08,
115 0xc5, 0x80,
116 0xc6, 0x80,
117 0xc7, 0x0a,
118 0xc8, 0x1a,
119 0xc9, 0x80,
120 0xfe, 0x92,
121 0xe0, 0xf8,
122 0xe6, 0x8b,
123 0xd0, 0x40,
124 0xf8, 0x20,
125 0xfa, 0x0f,
126 0xfd, 0x20,
127 0xad, 0x20,
128 0xae, 0x07,
129 0xb8, 0x00,
130 };
131
132 /* Register values to initialise the demod in DVB-S2 mode */
133 static u8 ds3000_dvbs2_init_tab[] = {
134 0x23, 0x0f,
135 0x08, 0x07,
136 0x0c, 0x00,
137 0x21, 0x54,
138 0x25, 0x82,
139 0x27, 0x31,
140 0x30, 0x08,
141 0x31, 0x32,
142 0x32, 0x32,
143 0x33, 0x35,
144 0x35, 0xff,
145 0x3a, 0x00,
146 0x37, 0x10,
147 0x38, 0x10,
148 0x39, 0x02,
149 0x42, 0x60,
150 0x4a, 0x80,
151 0x4b, 0x04,
152 0x4d, 0x81,
153 0x5d, 0x88,
154 0x50, 0x36,
155 0x51, 0x36,
156 0x52, 0x36,
157 0x53, 0x36,
158 0x63, 0x60,
159 0x64, 0x10,
160 0x65, 0x10,
161 0x68, 0x04,
162 0x69, 0x29,
163 0x70, 0x20,
164 0x71, 0x70,
165 0x72, 0x04,
166 0x73, 0x00,
167 0x70, 0x40,
168 0x71, 0x70,
169 0x72, 0x04,
170 0x73, 0x00,
171 0x70, 0x60,
172 0x71, 0x70,
173 0x72, 0x04,
174 0x73, 0x00,
175 0x70, 0x80,
176 0x71, 0x70,
177 0x72, 0x04,
178 0x73, 0x00,
179 0x70, 0xa0,
180 0x71, 0x70,
181 0x72, 0x04,
182 0x73, 0x00,
183 0x70, 0x1f,
184 0xa0, 0x44,
185 0xc0, 0x08,
186 0xc1, 0x10,
187 0xc2, 0x08,
188 0xc3, 0x10,
189 0xc4, 0x08,
190 0xc5, 0xf0,
191 0xc6, 0xf0,
192 0xc7, 0x0a,
193 0xc8, 0x1a,
194 0xc9, 0x80,
195 0xca, 0x23,
196 0xcb, 0x24,
197 0xce, 0x74,
198 0x90, 0x03,
199 0x76, 0x80,
200 0x77, 0x42,
201 0x78, 0x0a,
202 0x79, 0x80,
203 0xad, 0x40,
204 0xae, 0x07,
205 0x7f, 0xd4,
206 0x7c, 0x00,
207 0x80, 0xa8,
208 0x81, 0xda,
209 0x7c, 0x01,
210 0x80, 0xda,
211 0x81, 0xec,
212 0x7c, 0x02,
213 0x80, 0xca,
214 0x81, 0xeb,
215 0x7c, 0x03,
216 0x80, 0xba,
217 0x81, 0xdb,
218 0x85, 0x08,
219 0x86, 0x00,
220 0x87, 0x02,
221 0x89, 0x80,
222 0x8b, 0x44,
223 0x8c, 0xaa,
224 0x8a, 0x10,
225 0xba, 0x00,
226 0xf5, 0x04,
227 0xfe, 0x44,
228 0xd2, 0x32,
229 0xb8, 0x00,
230 };
231
232 struct ds3000_state {
233 struct i2c_adapter *i2c;
234 const struct ds3000_config *config;
235 struct dvb_frontend frontend;
236 /* previous uncorrected block counter for DVB-S2 */
237 u16 prevUCBS2;
238 };
239
240 static int ds3000_writereg(struct ds3000_state *state, int reg, int data)
241 {
242 u8 buf[] = { reg, data };
243 struct i2c_msg msg = { .addr = state->config->demod_address,
244 .flags = 0, .buf = buf, .len = 2 };
245 int err;
246
247 dprintk("%s: write reg 0x%02x, value 0x%02x\n", __func__, reg, data);
248
249 err = i2c_transfer(state->i2c, &msg, 1);
250 if (err != 1) {
251 printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x,"
252 " value == 0x%02x)\n", __func__, err, reg, data);
253 return -EREMOTEIO;
254 }
255
256 return 0;
257 }
258
259 static int ds3000_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
260 {
261 struct ds3000_state *state = fe->demodulator_priv;
262
263 if (enable)
264 ds3000_writereg(state, 0x03, 0x12);
265 else
266 ds3000_writereg(state, 0x03, 0x02);
267
268 return 0;
269 }
270
271 /* I2C write for 8k firmware load */
272 static int ds3000_writeFW(struct ds3000_state *state, int reg,
273 const u8 *data, u16 len)
274 {
275 int i, ret = 0;
276 struct i2c_msg msg;
277 u8 *buf;
278
279 buf = kmalloc(33, GFP_KERNEL);
280 if (buf == NULL) {
281 printk(KERN_ERR "Unable to kmalloc\n");
282 return -ENOMEM;
283 }
284
285 *(buf) = reg;
286
287 msg.addr = state->config->demod_address;
288 msg.flags = 0;
289 msg.buf = buf;
290 msg.len = 33;
291
292 for (i = 0; i < len; i += 32) {
293 memcpy(buf + 1, data + i, 32);
294
295 dprintk("%s: write reg 0x%02x, len = %d\n", __func__, reg, len);
296
297 ret = i2c_transfer(state->i2c, &msg, 1);
298 if (ret != 1) {
299 printk(KERN_ERR "%s: write error(err == %i, "
300 "reg == 0x%02x\n", __func__, ret, reg);
301 ret = -EREMOTEIO;
302 goto error;
303 }
304 }
305 ret = 0;
306
307 error:
308 kfree(buf);
309
310 return ret;
311 }
312
313 static int ds3000_readreg(struct ds3000_state *state, u8 reg)
314 {
315 int ret;
316 u8 b0[] = { reg };
317 u8 b1[] = { 0 };
318 struct i2c_msg msg[] = {
319 {
320 .addr = state->config->demod_address,
321 .flags = 0,
322 .buf = b0,
323 .len = 1
324 }, {
325 .addr = state->config->demod_address,
326 .flags = I2C_M_RD,
327 .buf = b1,
328 .len = 1
329 }
330 };
331
332 ret = i2c_transfer(state->i2c, msg, 2);
333
334 if (ret != 2) {
335 printk(KERN_ERR "%s: reg=0x%x(error=%d)\n", __func__, reg, ret);
336 return ret;
337 }
338
339 dprintk("%s: read reg 0x%02x, value 0x%02x\n", __func__, reg, b1[0]);
340
341 return b1[0];
342 }
343
344 static int ds3000_load_firmware(struct dvb_frontend *fe,
345 const struct firmware *fw);
346
347 static int ds3000_firmware_ondemand(struct dvb_frontend *fe)
348 {
349 struct ds3000_state *state = fe->demodulator_priv;
350 const struct firmware *fw;
351 int ret = 0;
352
353 dprintk("%s()\n", __func__);
354
355 ret = ds3000_readreg(state, 0xb2);
356 if (ret < 0)
357 return ret;
358
359 /* Load firmware */
360 /* request the firmware, this will block until someone uploads it */
361 printk(KERN_INFO "%s: Waiting for firmware upload (%s)...\n", __func__,
362 DS3000_DEFAULT_FIRMWARE);
363 ret = request_firmware(&fw, DS3000_DEFAULT_FIRMWARE,
364 state->i2c->dev.parent);
365 printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n", __func__);
366 if (ret) {
367 printk(KERN_ERR "%s: No firmware uploaded (timeout or file not "
368 "found?)\n", __func__);
369 return ret;
370 }
371
372 ret = ds3000_load_firmware(fe, fw);
373 if (ret)
374 printk("%s: Writing firmware to device failed\n", __func__);
375
376 release_firmware(fw);
377
378 dprintk("%s: Firmware upload %s\n", __func__,
379 ret == 0 ? "complete" : "failed");
380
381 return ret;
382 }
383
384 static int ds3000_load_firmware(struct dvb_frontend *fe,
385 const struct firmware *fw)
386 {
387 struct ds3000_state *state = fe->demodulator_priv;
388 int ret = 0;
389
390 dprintk("%s\n", __func__);
391 dprintk("Firmware is %zu bytes (%02x %02x .. %02x %02x)\n",
392 fw->size,
393 fw->data[0],
394 fw->data[1],
395 fw->data[fw->size - 2],
396 fw->data[fw->size - 1]);
397
398 /* Begin the firmware load process */
399 ds3000_writereg(state, 0xb2, 0x01);
400 /* write the entire firmware */
401 ret = ds3000_writeFW(state, 0xb0, fw->data, fw->size);
402 ds3000_writereg(state, 0xb2, 0x00);
403
404 return ret;
405 }
406
407 static int ds3000_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
408 {
409 struct ds3000_state *state = fe->demodulator_priv;
410 u8 data;
411
412 dprintk("%s(%d)\n", __func__, voltage);
413
414 data = ds3000_readreg(state, 0xa2);
415 data |= 0x03; /* bit0 V/H, bit1 off/on */
416
417 switch (voltage) {
418 case SEC_VOLTAGE_18:
419 data &= ~0x03;
420 break;
421 case SEC_VOLTAGE_13:
422 data &= ~0x03;
423 data |= 0x01;
424 break;
425 case SEC_VOLTAGE_OFF:
426 break;
427 }
428
429 ds3000_writereg(state, 0xa2, data);
430
431 return 0;
432 }
433
434 static int ds3000_read_status(struct dvb_frontend *fe, fe_status_t* status)
435 {
436 struct ds3000_state *state = fe->demodulator_priv;
437 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
438 int lock;
439
440 *status = 0;
441
442 switch (c->delivery_system) {
443 case SYS_DVBS:
444 lock = ds3000_readreg(state, 0xd1);
445 if ((lock & 0x07) == 0x07)
446 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
447 FE_HAS_VITERBI | FE_HAS_SYNC |
448 FE_HAS_LOCK;
449
450 break;
451 case SYS_DVBS2:
452 lock = ds3000_readreg(state, 0x0d);
453 if ((lock & 0x8f) == 0x8f)
454 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
455 FE_HAS_VITERBI | FE_HAS_SYNC |
456 FE_HAS_LOCK;
457
458 break;
459 default:
460 return 1;
461 }
462
463 if (state->config->set_lock_led)
464 state->config->set_lock_led(fe, *status == 0 ? 0 : 1);
465
466 dprintk("%s: status = 0x%02x\n", __func__, lock);
467
468 return 0;
469 }
470
471 /* read DS3000 BER value */
472 static int ds3000_read_ber(struct dvb_frontend *fe, u32* ber)
473 {
474 struct ds3000_state *state = fe->demodulator_priv;
475 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
476 u8 data;
477 u32 ber_reading, lpdc_frames;
478
479 dprintk("%s()\n", __func__);
480
481 switch (c->delivery_system) {
482 case SYS_DVBS:
483 /* set the number of bytes checked during
484 BER estimation */
485 ds3000_writereg(state, 0xf9, 0x04);
486 /* read BER estimation status */
487 data = ds3000_readreg(state, 0xf8);
488 /* check if BER estimation is ready */
489 if ((data & 0x10) == 0) {
490 /* this is the number of error bits,
491 to calculate the bit error rate
492 divide to 8388608 */
493 *ber = (ds3000_readreg(state, 0xf7) << 8) |
494 ds3000_readreg(state, 0xf6);
495 /* start counting error bits */
496 /* need to be set twice
497 otherwise it fails sometimes */
498 data |= 0x10;
499 ds3000_writereg(state, 0xf8, data);
500 ds3000_writereg(state, 0xf8, data);
501 } else
502 /* used to indicate that BER estimation
503 is not ready, i.e. BER is unknown */
504 *ber = 0xffffffff;
505 break;
506 case SYS_DVBS2:
507 /* read the number of LPDC decoded frames */
508 lpdc_frames = (ds3000_readreg(state, 0xd7) << 16) |
509 (ds3000_readreg(state, 0xd6) << 8) |
510 ds3000_readreg(state, 0xd5);
511 /* read the number of packets with bad CRC */
512 ber_reading = (ds3000_readreg(state, 0xf8) << 8) |
513 ds3000_readreg(state, 0xf7);
514 if (lpdc_frames > 750) {
515 /* clear LPDC frame counters */
516 ds3000_writereg(state, 0xd1, 0x01);
517 /* clear bad packets counter */
518 ds3000_writereg(state, 0xf9, 0x01);
519 /* enable bad packets counter */
520 ds3000_writereg(state, 0xf9, 0x00);
521 /* enable LPDC frame counters */
522 ds3000_writereg(state, 0xd1, 0x00);
523 *ber = ber_reading;
524 } else
525 /* used to indicate that BER estimation is not ready,
526 i.e. BER is unknown */
527 *ber = 0xffffffff;
528 break;
529 default:
530 return 1;
531 }
532
533 return 0;
534 }
535
536 static int ds3000_read_signal_strength(struct dvb_frontend *fe,
537 u16 *signal_strength)
538 {
539 if (fe->ops.tuner_ops.get_rf_strength)
540 fe->ops.tuner_ops.get_rf_strength(fe, signal_strength);
541
542 return 0;
543 }
544
545 /* calculate DS3000 snr value in dB */
546 static int ds3000_read_snr(struct dvb_frontend *fe, u16 *snr)
547 {
548 struct ds3000_state *state = fe->demodulator_priv;
549 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
550 u8 snr_reading, snr_value;
551 u32 dvbs2_signal_reading, dvbs2_noise_reading, tmp;
552 static const u16 dvbs_snr_tab[] = { /* 20 x Table (rounded up) */
553 0x0000, 0x1b13, 0x2aea, 0x3627, 0x3ede, 0x45fe, 0x4c03,
554 0x513a, 0x55d4, 0x59f2, 0x5dab, 0x6111, 0x6431, 0x6717,
555 0x69c9, 0x6c4e, 0x6eac, 0x70e8, 0x7304, 0x7505
556 };
557 static const u16 dvbs2_snr_tab[] = { /* 80 x Table (rounded up) */
558 0x0000, 0x0bc2, 0x12a3, 0x1785, 0x1b4e, 0x1e65, 0x2103,
559 0x2347, 0x2546, 0x2710, 0x28ae, 0x2a28, 0x2b83, 0x2cc5,
560 0x2df1, 0x2f09, 0x3010, 0x3109, 0x31f4, 0x32d2, 0x33a6,
561 0x3470, 0x3531, 0x35ea, 0x369b, 0x3746, 0x37ea, 0x3888,
562 0x3920, 0x39b3, 0x3a42, 0x3acc, 0x3b51, 0x3bd3, 0x3c51,
563 0x3ccb, 0x3d42, 0x3db6, 0x3e27, 0x3e95, 0x3f00, 0x3f68,
564 0x3fcf, 0x4033, 0x4094, 0x40f4, 0x4151, 0x41ac, 0x4206,
565 0x425e, 0x42b4, 0x4308, 0x435b, 0x43ac, 0x43fc, 0x444a,
566 0x4497, 0x44e2, 0x452d, 0x4576, 0x45bd, 0x4604, 0x4649,
567 0x468e, 0x46d1, 0x4713, 0x4755, 0x4795, 0x47d4, 0x4813,
568 0x4851, 0x488d, 0x48c9, 0x4904, 0x493f, 0x4978, 0x49b1,
569 0x49e9, 0x4a20, 0x4a57
570 };
571
572 dprintk("%s()\n", __func__);
573
574 switch (c->delivery_system) {
575 case SYS_DVBS:
576 snr_reading = ds3000_readreg(state, 0xff);
577 snr_reading /= 8;
578 if (snr_reading == 0)
579 *snr = 0x0000;
580 else {
581 if (snr_reading > 20)
582 snr_reading = 20;
583 snr_value = dvbs_snr_tab[snr_reading - 1] * 10 / 23026;
584 /* cook the value to be suitable for szap-s2
585 human readable output */
586 *snr = snr_value * 8 * 655;
587 }
588 dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
589 snr_reading, *snr);
590 break;
591 case SYS_DVBS2:
592 dvbs2_noise_reading = (ds3000_readreg(state, 0x8c) & 0x3f) +
593 (ds3000_readreg(state, 0x8d) << 4);
594 dvbs2_signal_reading = ds3000_readreg(state, 0x8e);
595 tmp = dvbs2_signal_reading * dvbs2_signal_reading >> 1;
596 if (tmp == 0) {
597 *snr = 0x0000;
598 return 0;
599 }
600 if (dvbs2_noise_reading == 0) {
601 snr_value = 0x0013;
602 /* cook the value to be suitable for szap-s2
603 human readable output */
604 *snr = 0xffff;
605 return 0;
606 }
607 if (tmp > dvbs2_noise_reading) {
608 snr_reading = tmp / dvbs2_noise_reading;
609 if (snr_reading > 80)
610 snr_reading = 80;
611 snr_value = dvbs2_snr_tab[snr_reading - 1] / 1000;
612 /* cook the value to be suitable for szap-s2
613 human readable output */
614 *snr = snr_value * 5 * 655;
615 } else {
616 snr_reading = dvbs2_noise_reading / tmp;
617 if (snr_reading > 80)
618 snr_reading = 80;
619 *snr = -(dvbs2_snr_tab[snr_reading] / 1000);
620 }
621 dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
622 snr_reading, *snr);
623 break;
624 default:
625 return 1;
626 }
627
628 return 0;
629 }
630
631 /* read DS3000 uncorrected blocks */
632 static int ds3000_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
633 {
634 struct ds3000_state *state = fe->demodulator_priv;
635 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
636 u8 data;
637 u16 _ucblocks;
638
639 dprintk("%s()\n", __func__);
640
641 switch (c->delivery_system) {
642 case SYS_DVBS:
643 *ucblocks = (ds3000_readreg(state, 0xf5) << 8) |
644 ds3000_readreg(state, 0xf4);
645 data = ds3000_readreg(state, 0xf8);
646 /* clear packet counters */
647 data &= ~0x20;
648 ds3000_writereg(state, 0xf8, data);
649 /* enable packet counters */
650 data |= 0x20;
651 ds3000_writereg(state, 0xf8, data);
652 break;
653 case SYS_DVBS2:
654 _ucblocks = (ds3000_readreg(state, 0xe2) << 8) |
655 ds3000_readreg(state, 0xe1);
656 if (_ucblocks > state->prevUCBS2)
657 *ucblocks = _ucblocks - state->prevUCBS2;
658 else
659 *ucblocks = state->prevUCBS2 - _ucblocks;
660 state->prevUCBS2 = _ucblocks;
661 break;
662 default:
663 return 1;
664 }
665
666 return 0;
667 }
668
669 static int ds3000_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
670 {
671 struct ds3000_state *state = fe->demodulator_priv;
672 u8 data;
673
674 dprintk("%s(%d)\n", __func__, tone);
675 if ((tone != SEC_TONE_ON) && (tone != SEC_TONE_OFF)) {
676 printk(KERN_ERR "%s: Invalid, tone=%d\n", __func__, tone);
677 return -EINVAL;
678 }
679
680 data = ds3000_readreg(state, 0xa2);
681 data &= ~0xc0;
682 ds3000_writereg(state, 0xa2, data);
683
684 switch (tone) {
685 case SEC_TONE_ON:
686 dprintk("%s: setting tone on\n", __func__);
687 data = ds3000_readreg(state, 0xa1);
688 data &= ~0x43;
689 data |= 0x04;
690 ds3000_writereg(state, 0xa1, data);
691 break;
692 case SEC_TONE_OFF:
693 dprintk("%s: setting tone off\n", __func__);
694 data = ds3000_readreg(state, 0xa2);
695 data |= 0x80;
696 ds3000_writereg(state, 0xa2, data);
697 break;
698 }
699
700 return 0;
701 }
702
703 static int ds3000_send_diseqc_msg(struct dvb_frontend *fe,
704 struct dvb_diseqc_master_cmd *d)
705 {
706 struct ds3000_state *state = fe->demodulator_priv;
707 int i;
708 u8 data;
709
710 /* Dump DiSEqC message */
711 dprintk("%s(", __func__);
712 for (i = 0 ; i < d->msg_len;) {
713 dprintk("0x%02x", d->msg[i]);
714 if (++i < d->msg_len)
715 dprintk(", ");
716 }
717
718 /* enable DiSEqC message send pin */
719 data = ds3000_readreg(state, 0xa2);
720 data &= ~0xc0;
721 ds3000_writereg(state, 0xa2, data);
722
723 /* DiSEqC message */
724 for (i = 0; i < d->msg_len; i++)
725 ds3000_writereg(state, 0xa3 + i, d->msg[i]);
726
727 data = ds3000_readreg(state, 0xa1);
728 /* clear DiSEqC message length and status,
729 enable DiSEqC message send */
730 data &= ~0xf8;
731 /* set DiSEqC mode, modulation active during 33 pulses,
732 set DiSEqC message length */
733 data |= ((d->msg_len - 1) << 3) | 0x07;
734 ds3000_writereg(state, 0xa1, data);
735
736 /* wait up to 150ms for DiSEqC transmission to complete */
737 for (i = 0; i < 15; i++) {
738 data = ds3000_readreg(state, 0xa1);
739 if ((data & 0x40) == 0)
740 break;
741 msleep(10);
742 }
743
744 /* DiSEqC timeout after 150ms */
745 if (i == 15) {
746 data = ds3000_readreg(state, 0xa1);
747 data &= ~0x80;
748 data |= 0x40;
749 ds3000_writereg(state, 0xa1, data);
750
751 data = ds3000_readreg(state, 0xa2);
752 data &= ~0xc0;
753 data |= 0x80;
754 ds3000_writereg(state, 0xa2, data);
755
756 return 1;
757 }
758
759 data = ds3000_readreg(state, 0xa2);
760 data &= ~0xc0;
761 data |= 0x80;
762 ds3000_writereg(state, 0xa2, data);
763
764 return 0;
765 }
766
767 /* Send DiSEqC burst */
768 static int ds3000_diseqc_send_burst(struct dvb_frontend *fe,
769 fe_sec_mini_cmd_t burst)
770 {
771 struct ds3000_state *state = fe->demodulator_priv;
772 int i;
773 u8 data;
774
775 dprintk("%s()\n", __func__);
776
777 data = ds3000_readreg(state, 0xa2);
778 data &= ~0xc0;
779 ds3000_writereg(state, 0xa2, data);
780
781 /* DiSEqC burst */
782 if (burst == SEC_MINI_A)
783 /* Unmodulated tone burst */
784 ds3000_writereg(state, 0xa1, 0x02);
785 else if (burst == SEC_MINI_B)
786 /* Modulated tone burst */
787 ds3000_writereg(state, 0xa1, 0x01);
788 else
789 return -EINVAL;
790
791 msleep(13);
792 for (i = 0; i < 5; i++) {
793 data = ds3000_readreg(state, 0xa1);
794 if ((data & 0x40) == 0)
795 break;
796 msleep(1);
797 }
798
799 if (i == 5) {
800 data = ds3000_readreg(state, 0xa1);
801 data &= ~0x80;
802 data |= 0x40;
803 ds3000_writereg(state, 0xa1, data);
804
805 data = ds3000_readreg(state, 0xa2);
806 data &= ~0xc0;
807 data |= 0x80;
808 ds3000_writereg(state, 0xa2, data);
809
810 return 1;
811 }
812
813 data = ds3000_readreg(state, 0xa2);
814 data &= ~0xc0;
815 data |= 0x80;
816 ds3000_writereg(state, 0xa2, data);
817
818 return 0;
819 }
820
821 static void ds3000_release(struct dvb_frontend *fe)
822 {
823 struct ds3000_state *state = fe->demodulator_priv;
824
825 if (state->config->set_lock_led)
826 state->config->set_lock_led(fe, 0);
827
828 dprintk("%s\n", __func__);
829 kfree(state);
830 }
831
832 static struct dvb_frontend_ops ds3000_ops;
833
834 struct dvb_frontend *ds3000_attach(const struct ds3000_config *config,
835 struct i2c_adapter *i2c)
836 {
837 struct ds3000_state *state = NULL;
838 int ret;
839
840 dprintk("%s\n", __func__);
841
842 /* allocate memory for the internal state */
843 state = kzalloc(sizeof(struct ds3000_state), GFP_KERNEL);
844 if (state == NULL) {
845 printk(KERN_ERR "Unable to kmalloc\n");
846 goto error2;
847 }
848
849 state->config = config;
850 state->i2c = i2c;
851 state->prevUCBS2 = 0;
852
853 /* check if the demod is present */
854 ret = ds3000_readreg(state, 0x00) & 0xfe;
855 if (ret != 0xe0) {
856 printk(KERN_ERR "Invalid probe, probably not a DS3000\n");
857 goto error3;
858 }
859
860 printk(KERN_INFO "DS3000 chip version: %d.%d attached.\n",
861 ds3000_readreg(state, 0x02),
862 ds3000_readreg(state, 0x01));
863
864 memcpy(&state->frontend.ops, &ds3000_ops,
865 sizeof(struct dvb_frontend_ops));
866 state->frontend.demodulator_priv = state;
867
868 /*
869 * Some devices like T480 starts with voltage on. Be sure
870 * to turn voltage off during init, as this can otherwise
871 * interfere with Unicable SCR systems.
872 */
873 ds3000_set_voltage(&state->frontend, SEC_VOLTAGE_OFF);
874 return &state->frontend;
875
876 error3:
877 kfree(state);
878 error2:
879 return NULL;
880 }
881 EXPORT_SYMBOL(ds3000_attach);
882
883 static int ds3000_set_carrier_offset(struct dvb_frontend *fe,
884 s32 carrier_offset_khz)
885 {
886 struct ds3000_state *state = fe->demodulator_priv;
887 s32 tmp;
888
889 tmp = carrier_offset_khz;
890 tmp *= 65536;
891 tmp = (2 * tmp + DS3000_SAMPLE_RATE) / (2 * DS3000_SAMPLE_RATE);
892
893 if (tmp < 0)
894 tmp += 65536;
895
896 ds3000_writereg(state, 0x5f, tmp >> 8);
897 ds3000_writereg(state, 0x5e, tmp & 0xff);
898
899 return 0;
900 }
901
902 static int ds3000_set_frontend(struct dvb_frontend *fe)
903 {
904 struct ds3000_state *state = fe->demodulator_priv;
905 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
906
907 int i;
908 fe_status_t status;
909 s32 offset_khz;
910 u32 frequency;
911 u16 value;
912
913 dprintk("%s() ", __func__);
914
915 if (state->config->set_ts_params)
916 state->config->set_ts_params(fe, 0);
917 /* Tune */
918 if (fe->ops.tuner_ops.set_params)
919 fe->ops.tuner_ops.set_params(fe);
920
921 /* ds3000 global reset */
922 ds3000_writereg(state, 0x07, 0x80);
923 ds3000_writereg(state, 0x07, 0x00);
924 /* ds3000 build-in uC reset */
925 ds3000_writereg(state, 0xb2, 0x01);
926 /* ds3000 software reset */
927 ds3000_writereg(state, 0x00, 0x01);
928
929 switch (c->delivery_system) {
930 case SYS_DVBS:
931 /* initialise the demod in DVB-S mode */
932 for (i = 0; i < sizeof(ds3000_dvbs_init_tab); i += 2)
933 ds3000_writereg(state,
934 ds3000_dvbs_init_tab[i],
935 ds3000_dvbs_init_tab[i + 1]);
936 value = ds3000_readreg(state, 0xfe);
937 value &= 0xc0;
938 value |= 0x1b;
939 ds3000_writereg(state, 0xfe, value);
940 break;
941 case SYS_DVBS2:
942 /* initialise the demod in DVB-S2 mode */
943 for (i = 0; i < sizeof(ds3000_dvbs2_init_tab); i += 2)
944 ds3000_writereg(state,
945 ds3000_dvbs2_init_tab[i],
946 ds3000_dvbs2_init_tab[i + 1]);
947 if (c->symbol_rate >= 30000000)
948 ds3000_writereg(state, 0xfe, 0x54);
949 else
950 ds3000_writereg(state, 0xfe, 0x98);
951 break;
952 default:
953 return 1;
954 }
955
956 /* enable 27MHz clock output */
957 ds3000_writereg(state, 0x29, 0x80);
958 /* enable ac coupling */
959 ds3000_writereg(state, 0x25, 0x8a);
960
961 /* enhance symbol rate performance */
962 if ((c->symbol_rate / 1000) <= 5000) {
963 value = 29777 / (c->symbol_rate / 1000) + 1;
964 if (value % 2 != 0)
965 value++;
966 ds3000_writereg(state, 0xc3, 0x0d);
967 ds3000_writereg(state, 0xc8, value);
968 ds3000_writereg(state, 0xc4, 0x10);
969 ds3000_writereg(state, 0xc7, 0x0e);
970 } else if ((c->symbol_rate / 1000) <= 10000) {
971 value = 92166 / (c->symbol_rate / 1000) + 1;
972 if (value % 2 != 0)
973 value++;
974 ds3000_writereg(state, 0xc3, 0x07);
975 ds3000_writereg(state, 0xc8, value);
976 ds3000_writereg(state, 0xc4, 0x09);
977 ds3000_writereg(state, 0xc7, 0x12);
978 } else if ((c->symbol_rate / 1000) <= 20000) {
979 value = 64516 / (c->symbol_rate / 1000) + 1;
980 ds3000_writereg(state, 0xc3, value);
981 ds3000_writereg(state, 0xc8, 0x0e);
982 ds3000_writereg(state, 0xc4, 0x07);
983 ds3000_writereg(state, 0xc7, 0x18);
984 } else {
985 value = 129032 / (c->symbol_rate / 1000) + 1;
986 ds3000_writereg(state, 0xc3, value);
987 ds3000_writereg(state, 0xc8, 0x0a);
988 ds3000_writereg(state, 0xc4, 0x05);
989 ds3000_writereg(state, 0xc7, 0x24);
990 }
991
992 /* normalized symbol rate rounded to the closest integer */
993 value = (((c->symbol_rate / 1000) << 16) +
994 (DS3000_SAMPLE_RATE / 2)) / DS3000_SAMPLE_RATE;
995 ds3000_writereg(state, 0x61, value & 0x00ff);
996 ds3000_writereg(state, 0x62, (value & 0xff00) >> 8);
997
998 /* co-channel interference cancellation disabled */
999 ds3000_writereg(state, 0x56, 0x00);
1000
1001 /* equalizer disabled */
1002 ds3000_writereg(state, 0x76, 0x00);
1003
1004 /*ds3000_writereg(state, 0x08, 0x03);
1005 ds3000_writereg(state, 0xfd, 0x22);
1006 ds3000_writereg(state, 0x08, 0x07);
1007 ds3000_writereg(state, 0xfd, 0x42);
1008 ds3000_writereg(state, 0x08, 0x07);*/
1009
1010 if (state->config->ci_mode) {
1011 switch (c->delivery_system) {
1012 case SYS_DVBS:
1013 default:
1014 ds3000_writereg(state, 0xfd, 0x80);
1015 break;
1016 case SYS_DVBS2:
1017 ds3000_writereg(state, 0xfd, 0x01);
1018 break;
1019 }
1020 }
1021
1022 /* ds3000 out of software reset */
1023 ds3000_writereg(state, 0x00, 0x00);
1024 /* start ds3000 build-in uC */
1025 ds3000_writereg(state, 0xb2, 0x00);
1026
1027 if (fe->ops.tuner_ops.get_frequency) {
1028 fe->ops.tuner_ops.get_frequency(fe, &frequency);
1029 offset_khz = frequency - c->frequency;
1030 ds3000_set_carrier_offset(fe, offset_khz);
1031 }
1032
1033 for (i = 0; i < 30 ; i++) {
1034 ds3000_read_status(fe, &status);
1035 if (status & FE_HAS_LOCK)
1036 break;
1037
1038 msleep(10);
1039 }
1040
1041 return 0;
1042 }
1043
1044 static int ds3000_tune(struct dvb_frontend *fe,
1045 bool re_tune,
1046 unsigned int mode_flags,
1047 unsigned int *delay,
1048 fe_status_t *status)
1049 {
1050 if (re_tune) {
1051 int ret = ds3000_set_frontend(fe);
1052 if (ret)
1053 return ret;
1054 }
1055
1056 *delay = HZ / 5;
1057
1058 return ds3000_read_status(fe, status);
1059 }
1060
1061 static enum dvbfe_algo ds3000_get_algo(struct dvb_frontend *fe)
1062 {
1063 struct ds3000_state *state = fe->demodulator_priv;
1064
1065 if (state->config->set_lock_led)
1066 state->config->set_lock_led(fe, 0);
1067
1068 dprintk("%s()\n", __func__);
1069 return DVBFE_ALGO_HW;
1070 }
1071
1072 /*
1073 * Initialise or wake up device
1074 *
1075 * Power config will reset and load initial firmware if required
1076 */
1077 static int ds3000_initfe(struct dvb_frontend *fe)
1078 {
1079 struct ds3000_state *state = fe->demodulator_priv;
1080 int ret;
1081
1082 dprintk("%s()\n", __func__);
1083 /* hard reset */
1084 ds3000_writereg(state, 0x08, 0x01 | ds3000_readreg(state, 0x08));
1085 msleep(1);
1086
1087 /* Load the firmware if required */
1088 ret = ds3000_firmware_ondemand(fe);
1089 if (ret != 0) {
1090 printk(KERN_ERR "%s: Unable initialize firmware\n", __func__);
1091 return ret;
1092 }
1093
1094 return 0;
1095 }
1096
1097 static struct dvb_frontend_ops ds3000_ops = {
1098 .delsys = { SYS_DVBS, SYS_DVBS2 },
1099 .info = {
1100 .name = "Montage Technology DS3000",
1101 .frequency_min = 950000,
1102 .frequency_max = 2150000,
1103 .frequency_stepsize = 1011, /* kHz for QPSK frontends */
1104 .frequency_tolerance = 5000,
1105 .symbol_rate_min = 1000000,
1106 .symbol_rate_max = 45000000,
1107 .caps = FE_CAN_INVERSION_AUTO |
1108 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1109 FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
1110 FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1111 FE_CAN_2G_MODULATION |
1112 FE_CAN_QPSK | FE_CAN_RECOVER
1113 },
1114
1115 .release = ds3000_release,
1116
1117 .init = ds3000_initfe,
1118 .i2c_gate_ctrl = ds3000_i2c_gate_ctrl,
1119 .read_status = ds3000_read_status,
1120 .read_ber = ds3000_read_ber,
1121 .read_signal_strength = ds3000_read_signal_strength,
1122 .read_snr = ds3000_read_snr,
1123 .read_ucblocks = ds3000_read_ucblocks,
1124 .set_voltage = ds3000_set_voltage,
1125 .set_tone = ds3000_set_tone,
1126 .diseqc_send_master_cmd = ds3000_send_diseqc_msg,
1127 .diseqc_send_burst = ds3000_diseqc_send_burst,
1128 .get_frontend_algo = ds3000_get_algo,
1129
1130 .set_frontend = ds3000_set_frontend,
1131 .tune = ds3000_tune,
1132 };
1133
1134 module_param(debug, int, 0644);
1135 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
1136
1137 MODULE_DESCRIPTION("DVB Frontend module for Montage Technology "
1138 "DS3000 hardware");
1139 MODULE_AUTHOR("Konstantin Dimitrov <kosio.dimitrov@gmail.com>");
1140 MODULE_LICENSE("GPL");
1141 MODULE_FIRMWARE(DS3000_DEFAULT_FIRMWARE);
Linux with added FPC-III support