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(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