1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 	Driver for ST STV0288 demodulator
4 	Copyright (C) 2006 Georg Acher, BayCom GmbH, acher (at) baycom (dot) de
5 		for Reel Multimedia
6 	Copyright (C) 2008 TurboSight.com, Bob Liu <bob@turbosight.com>
7 	Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by>
8 		Removed stb6000 specific tuner code and revised some
9 		procedures.
10 	2010-09-01 Josef Pavlik <josef@pavlik.it>
11 		Fixed diseqc_msg, diseqc_burst and set_tone problems
12 
13 
14 */
15 
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/string.h>
20 #include <linux/slab.h>
21 #include <linux/jiffies.h>
22 #include <asm/div64.h>
23 
24 #include <media/dvb_frontend.h>
25 #include "stv0288.h"
26 
27 struct stv0288_state {
28 	struct i2c_adapter *i2c;
29 	const struct stv0288_config *config;
30 	struct dvb_frontend frontend;
31 
32 	u8 initialised:1;
33 	u32 tuner_frequency;
34 	u32 symbol_rate;
35 	enum fe_code_rate fec_inner;
36 	int errmode;
37 };
38 
39 #define STATUS_BER 0
40 #define STATUS_UCBLOCKS 1
41 
42 static int debug;
43 static int debug_legacy_dish_switch;
44 #define dprintk(args...) \
45 	do { \
46 		if (debug) \
47 			printk(KERN_DEBUG "stv0288: " args); \
48 	} while (0)
49 
50 
51 static int stv0288_writeregI(struct stv0288_state *state, u8 reg, u8 data)
52 {
53 	int ret;
54 	u8 buf[] = { reg, data };
55 	struct i2c_msg msg = {
56 		.addr = state->config->demod_address,
57 		.flags = 0,
58 		.buf = buf,
59 		.len = 2
60 	};
61 
62 	ret = i2c_transfer(state->i2c, &msg, 1);
63 
64 	if (ret != 1)
65 		dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, ret == %i)\n",
66 			__func__, reg, data, ret);
67 
68 	return (ret != 1) ? -EREMOTEIO : 0;
69 }
70 
71 static int stv0288_write(struct dvb_frontend *fe, const u8 buf[], int len)
72 {
73 	struct stv0288_state *state = fe->demodulator_priv;
74 
75 	if (len != 2)
76 		return -EINVAL;
77 
78 	return stv0288_writeregI(state, buf[0], buf[1]);
79 }
80 
81 static u8 stv0288_readreg(struct stv0288_state *state, u8 reg)
82 {
83 	int ret;
84 	u8 b0[] = { reg };
85 	u8 b1[] = { 0 };
86 	struct i2c_msg msg[] = {
87 		{
88 			.addr = state->config->demod_address,
89 			.flags = 0,
90 			.buf = b0,
91 			.len = 1
92 		}, {
93 			.addr = state->config->demod_address,
94 			.flags = I2C_M_RD,
95 			.buf = b1,
96 			.len = 1
97 		}
98 	};
99 
100 	ret = i2c_transfer(state->i2c, msg, 2);
101 
102 	if (ret != 2)
103 		dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
104 				__func__, reg, ret);
105 
106 	return b1[0];
107 }
108 
109 static int stv0288_set_symbolrate(struct dvb_frontend *fe, u32 srate)
110 {
111 	struct stv0288_state *state = fe->demodulator_priv;
112 	unsigned int temp;
113 	unsigned char b[3];
114 
115 	if ((srate < 1000000) || (srate > 45000000))
116 		return -EINVAL;
117 
118 	stv0288_writeregI(state, 0x22, 0);
119 	stv0288_writeregI(state, 0x23, 0);
120 	stv0288_writeregI(state, 0x2b, 0xff);
121 	stv0288_writeregI(state, 0x2c, 0xf7);
122 
123 	temp = (unsigned int)srate / 1000;
124 
125 	temp = temp * 32768;
126 	temp = temp / 25;
127 	temp = temp / 125;
128 	b[0] = (unsigned char)((temp >> 12) & 0xff);
129 	b[1] = (unsigned char)((temp >> 4) & 0xff);
130 	b[2] = (unsigned char)((temp << 4) & 0xf0);
131 	stv0288_writeregI(state, 0x28, 0x80); /* SFRH */
132 	stv0288_writeregI(state, 0x29, 0); /* SFRM */
133 	stv0288_writeregI(state, 0x2a, 0); /* SFRL */
134 
135 	stv0288_writeregI(state, 0x28, b[0]);
136 	stv0288_writeregI(state, 0x29, b[1]);
137 	stv0288_writeregI(state, 0x2a, b[2]);
138 	dprintk("stv0288: stv0288_set_symbolrate\n");
139 
140 	return 0;
141 }
142 
143 static int stv0288_send_diseqc_msg(struct dvb_frontend *fe,
144 				    struct dvb_diseqc_master_cmd *m)
145 {
146 	struct stv0288_state *state = fe->demodulator_priv;
147 
148 	int i;
149 
150 	dprintk("%s\n", __func__);
151 
152 	stv0288_writeregI(state, 0x09, 0);
153 	msleep(30);
154 	stv0288_writeregI(state, 0x05, 0x12);/* modulated mode, single shot */
155 
156 	for (i = 0; i < m->msg_len; i++) {
157 		if (stv0288_writeregI(state, 0x06, m->msg[i]))
158 			return -EREMOTEIO;
159 	}
160 	msleep(m->msg_len*12);
161 	return 0;
162 }
163 
164 static int stv0288_send_diseqc_burst(struct dvb_frontend *fe,
165 				     enum fe_sec_mini_cmd burst)
166 {
167 	struct stv0288_state *state = fe->demodulator_priv;
168 
169 	dprintk("%s\n", __func__);
170 
171 	if (stv0288_writeregI(state, 0x05, 0x03))/* burst mode, single shot */
172 		return -EREMOTEIO;
173 
174 	if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff))
175 		return -EREMOTEIO;
176 
177 	msleep(15);
178 	if (stv0288_writeregI(state, 0x05, 0x12))
179 		return -EREMOTEIO;
180 
181 	return 0;
182 }
183 
184 static int stv0288_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
185 {
186 	struct stv0288_state *state = fe->demodulator_priv;
187 
188 	switch (tone) {
189 	case SEC_TONE_ON:
190 		if (stv0288_writeregI(state, 0x05, 0x10))/* cont carrier */
191 			return -EREMOTEIO;
192 	break;
193 
194 	case SEC_TONE_OFF:
195 		if (stv0288_writeregI(state, 0x05, 0x12))/* burst mode off*/
196 			return -EREMOTEIO;
197 	break;
198 
199 	default:
200 		return -EINVAL;
201 	}
202 	return 0;
203 }
204 
205 static u8 stv0288_inittab[] = {
206 	0x01, 0x15,
207 	0x02, 0x20,
208 	0x09, 0x0,
209 	0x0a, 0x4,
210 	0x0b, 0x0,
211 	0x0c, 0x0,
212 	0x0d, 0x0,
213 	0x0e, 0xd4,
214 	0x0f, 0x30,
215 	0x11, 0x80,
216 	0x12, 0x03,
217 	0x13, 0x48,
218 	0x14, 0x84,
219 	0x15, 0x45,
220 	0x16, 0xb7,
221 	0x17, 0x9c,
222 	0x18, 0x0,
223 	0x19, 0xa6,
224 	0x1a, 0x88,
225 	0x1b, 0x8f,
226 	0x1c, 0xf0,
227 	0x20, 0x0b,
228 	0x21, 0x54,
229 	0x22, 0x0,
230 	0x23, 0x0,
231 	0x2b, 0xff,
232 	0x2c, 0xf7,
233 	0x30, 0x0,
234 	0x31, 0x1e,
235 	0x32, 0x14,
236 	0x33, 0x0f,
237 	0x34, 0x09,
238 	0x35, 0x0c,
239 	0x36, 0x05,
240 	0x37, 0x2f,
241 	0x38, 0x16,
242 	0x39, 0xbe,
243 	0x3a, 0x0,
244 	0x3b, 0x13,
245 	0x3c, 0x11,
246 	0x3d, 0x30,
247 	0x40, 0x63,
248 	0x41, 0x04,
249 	0x42, 0x20,
250 	0x43, 0x00,
251 	0x44, 0x00,
252 	0x45, 0x00,
253 	0x46, 0x00,
254 	0x47, 0x00,
255 	0x4a, 0x00,
256 	0x50, 0x10,
257 	0x51, 0x38,
258 	0x52, 0x21,
259 	0x58, 0x54,
260 	0x59, 0x86,
261 	0x5a, 0x0,
262 	0x5b, 0x9b,
263 	0x5c, 0x08,
264 	0x5d, 0x7f,
265 	0x5e, 0x0,
266 	0x5f, 0xff,
267 	0x70, 0x0,
268 	0x71, 0x0,
269 	0x72, 0x0,
270 	0x74, 0x0,
271 	0x75, 0x0,
272 	0x76, 0x0,
273 	0x81, 0x0,
274 	0x82, 0x3f,
275 	0x83, 0x3f,
276 	0x84, 0x0,
277 	0x85, 0x0,
278 	0x88, 0x0,
279 	0x89, 0x0,
280 	0x8a, 0x0,
281 	0x8b, 0x0,
282 	0x8c, 0x0,
283 	0x90, 0x0,
284 	0x91, 0x0,
285 	0x92, 0x0,
286 	0x93, 0x0,
287 	0x94, 0x1c,
288 	0x97, 0x0,
289 	0xa0, 0x48,
290 	0xa1, 0x0,
291 	0xb0, 0xb8,
292 	0xb1, 0x3a,
293 	0xb2, 0x10,
294 	0xb3, 0x82,
295 	0xb4, 0x80,
296 	0xb5, 0x82,
297 	0xb6, 0x82,
298 	0xb7, 0x82,
299 	0xb8, 0x20,
300 	0xb9, 0x0,
301 	0xf0, 0x0,
302 	0xf1, 0x0,
303 	0xf2, 0xc0,
304 	0x51, 0x36,
305 	0x52, 0x09,
306 	0x53, 0x94,
307 	0x54, 0x62,
308 	0x55, 0x29,
309 	0x56, 0x64,
310 	0x57, 0x2b,
311 	0xff, 0xff,
312 };
313 
314 static int stv0288_set_voltage(struct dvb_frontend *fe,
315 			       enum fe_sec_voltage volt)
316 {
317 	dprintk("%s: %s\n", __func__,
318 		volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
319 		volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
320 
321 	return 0;
322 }
323 
324 static int stv0288_init(struct dvb_frontend *fe)
325 {
326 	struct stv0288_state *state = fe->demodulator_priv;
327 	int i;
328 	u8 reg;
329 	u8 val;
330 
331 	dprintk("stv0288: init chip\n");
332 	stv0288_writeregI(state, 0x41, 0x04);
333 	msleep(50);
334 
335 	/* we have default inittab */
336 	if (state->config->inittab == NULL) {
337 		for (i = 0; !(stv0288_inittab[i] == 0xff &&
338 				stv0288_inittab[i + 1] == 0xff); i += 2)
339 			stv0288_writeregI(state, stv0288_inittab[i],
340 					stv0288_inittab[i + 1]);
341 	} else {
342 		for (i = 0; ; i += 2)  {
343 			reg = state->config->inittab[i];
344 			val = state->config->inittab[i+1];
345 			if (reg == 0xff && val == 0xff)
346 				break;
347 			stv0288_writeregI(state, reg, val);
348 		}
349 	}
350 	return 0;
351 }
352 
353 static int stv0288_read_status(struct dvb_frontend *fe, enum fe_status *status)
354 {
355 	struct stv0288_state *state = fe->demodulator_priv;
356 
357 	u8 sync = stv0288_readreg(state, 0x24);
358 	if (sync == 255)
359 		sync = 0;
360 
361 	dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
362 
363 	*status = 0;
364 	if (sync & 0x80)
365 		*status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
366 	if (sync & 0x10)
367 		*status |= FE_HAS_VITERBI;
368 	if (sync & 0x08) {
369 		*status |= FE_HAS_LOCK;
370 		dprintk("stv0288 has locked\n");
371 	}
372 
373 	return 0;
374 }
375 
376 static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber)
377 {
378 	struct stv0288_state *state = fe->demodulator_priv;
379 
380 	if (state->errmode != STATUS_BER)
381 		return 0;
382 	*ber = (stv0288_readreg(state, 0x26) << 8) |
383 					stv0288_readreg(state, 0x27);
384 	dprintk("stv0288_read_ber %d\n", *ber);
385 
386 	return 0;
387 }
388 
389 
390 static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
391 {
392 	struct stv0288_state *state = fe->demodulator_priv;
393 
394 	s32 signal =  0xffff - ((stv0288_readreg(state, 0x10) << 8));
395 
396 
397 	signal = signal * 5 / 4;
398 	*strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
399 	dprintk("stv0288_read_signal_strength %d\n", *strength);
400 
401 	return 0;
402 }
403 static int stv0288_sleep(struct dvb_frontend *fe)
404 {
405 	struct stv0288_state *state = fe->demodulator_priv;
406 
407 	stv0288_writeregI(state, 0x41, 0x84);
408 	state->initialised = 0;
409 
410 	return 0;
411 }
412 static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr)
413 {
414 	struct stv0288_state *state = fe->demodulator_priv;
415 
416 	s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
417 			   | stv0288_readreg(state, 0x2e));
418 	xsnr = 3 * (xsnr - 0xa100);
419 	*snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
420 	dprintk("stv0288_read_snr %d\n", *snr);
421 
422 	return 0;
423 }
424 
425 static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
426 {
427 	struct stv0288_state *state = fe->demodulator_priv;
428 
429 	if (state->errmode != STATUS_BER)
430 		return 0;
431 	*ucblocks = (stv0288_readreg(state, 0x26) << 8) |
432 					stv0288_readreg(state, 0x27);
433 	dprintk("stv0288_read_ber %d\n", *ucblocks);
434 
435 	return 0;
436 }
437 
438 static int stv0288_set_frontend(struct dvb_frontend *fe)
439 {
440 	struct stv0288_state *state = fe->demodulator_priv;
441 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
442 
443 	u8 tda[3], reg, time_out = 0;
444 	s8 tm;
445 
446 	dprintk("%s : FE_SET_FRONTEND\n", __func__);
447 
448 	if (c->delivery_system != SYS_DVBS) {
449 		dprintk("%s: unsupported delivery system selected (%d)\n",
450 			__func__, c->delivery_system);
451 		return -EOPNOTSUPP;
452 	}
453 
454 	if (state->config->set_ts_params)
455 		state->config->set_ts_params(fe, 0);
456 
457 	/* only frequency & symbol_rate are used for tuner*/
458 	if (fe->ops.tuner_ops.set_params) {
459 		fe->ops.tuner_ops.set_params(fe);
460 		if (fe->ops.i2c_gate_ctrl)
461 			fe->ops.i2c_gate_ctrl(fe, 0);
462 	}
463 
464 	udelay(10);
465 	stv0288_set_symbolrate(fe, c->symbol_rate);
466 	/* Carrier lock control register */
467 	stv0288_writeregI(state, 0x15, 0xc5);
468 
469 	tda[2] = 0x0; /* CFRL */
470 	for (tm = -9; tm < 7;) {
471 		/* Viterbi status */
472 		reg = stv0288_readreg(state, 0x24);
473 		if (reg & 0x8)
474 				break;
475 		if (reg & 0x80) {
476 			time_out++;
477 			if (time_out > 10)
478 				break;
479 			tda[2] += 40;
480 			if (tda[2] < 40)
481 				tm++;
482 		} else {
483 			tm++;
484 			tda[2] = 0;
485 			time_out = 0;
486 		}
487 		tda[1] = (unsigned char)tm;
488 		stv0288_writeregI(state, 0x2b, tda[1]);
489 		stv0288_writeregI(state, 0x2c, tda[2]);
490 		msleep(30);
491 	}
492 	state->tuner_frequency = c->frequency;
493 	state->fec_inner = FEC_AUTO;
494 	state->symbol_rate = c->symbol_rate;
495 
496 	return 0;
497 }
498 
499 static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
500 {
501 	struct stv0288_state *state = fe->demodulator_priv;
502 
503 	if (enable)
504 		stv0288_writeregI(state, 0x01, 0xb5);
505 	else
506 		stv0288_writeregI(state, 0x01, 0x35);
507 
508 	udelay(1);
509 
510 	return 0;
511 }
512 
513 static void stv0288_release(struct dvb_frontend *fe)
514 {
515 	struct stv0288_state *state = fe->demodulator_priv;
516 	kfree(state);
517 }
518 
519 static const struct dvb_frontend_ops stv0288_ops = {
520 	.delsys = { SYS_DVBS },
521 	.info = {
522 		.name			= "ST STV0288 DVB-S",
523 		.frequency_min_hz	=  950 * MHz,
524 		.frequency_max_hz	= 2150 * MHz,
525 		.frequency_stepsize_hz	=    1 * MHz,
526 		.symbol_rate_min	= 1000000,
527 		.symbol_rate_max	= 45000000,
528 		.symbol_rate_tolerance	= 500,	/* ppm */
529 		.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
530 		      FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
531 		      FE_CAN_QPSK |
532 		      FE_CAN_FEC_AUTO
533 	},
534 
535 	.release = stv0288_release,
536 	.init = stv0288_init,
537 	.sleep = stv0288_sleep,
538 	.write = stv0288_write,
539 	.i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
540 	.read_status = stv0288_read_status,
541 	.read_ber = stv0288_read_ber,
542 	.read_signal_strength = stv0288_read_signal_strength,
543 	.read_snr = stv0288_read_snr,
544 	.read_ucblocks = stv0288_read_ucblocks,
545 	.diseqc_send_master_cmd = stv0288_send_diseqc_msg,
546 	.diseqc_send_burst = stv0288_send_diseqc_burst,
547 	.set_tone = stv0288_set_tone,
548 	.set_voltage = stv0288_set_voltage,
549 
550 	.set_frontend = stv0288_set_frontend,
551 };
552 
553 struct dvb_frontend *stv0288_attach(const struct stv0288_config *config,
554 				    struct i2c_adapter *i2c)
555 {
556 	struct stv0288_state *state = NULL;
557 	int id;
558 
559 	/* allocate memory for the internal state */
560 	state = kzalloc(sizeof(struct stv0288_state), GFP_KERNEL);
561 	if (state == NULL)
562 		goto error;
563 
564 	/* setup the state */
565 	state->config = config;
566 	state->i2c = i2c;
567 	state->initialised = 0;
568 	state->tuner_frequency = 0;
569 	state->symbol_rate = 0;
570 	state->fec_inner = 0;
571 	state->errmode = STATUS_BER;
572 
573 	stv0288_writeregI(state, 0x41, 0x04);
574 	msleep(200);
575 	id = stv0288_readreg(state, 0x00);
576 	dprintk("stv0288 id %x\n", id);
577 
578 	/* register 0x00 contains 0x11 for STV0288  */
579 	if (id != 0x11)
580 		goto error;
581 
582 	/* create dvb_frontend */
583 	memcpy(&state->frontend.ops, &stv0288_ops,
584 			sizeof(struct dvb_frontend_ops));
585 	state->frontend.demodulator_priv = state;
586 	return &state->frontend;
587 
588 error:
589 	kfree(state);
590 
591 	return NULL;
592 }
593 EXPORT_SYMBOL_GPL(stv0288_attach);
594 
595 module_param(debug_legacy_dish_switch, int, 0444);
596 MODULE_PARM_DESC(debug_legacy_dish_switch,
597 		"Enable timing analysis for Dish Network legacy switches");
598 
599 module_param(debug, int, 0644);
600 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
601 
602 MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
603 MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
604 MODULE_LICENSE("GPL");
605 
606