tda10071.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner driver
   4 *
   5 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
   6 */
   7
   8#include "tda10071_priv.h"
   9
  10static const struct dvb_frontend_ops tda10071_ops;
  11
  12/*
  13 * XXX: regmap_update_bits() does not fit our needs as it does not support
  14 * partially volatile registers. Also it performs register read even mask is as
  15 * wide as register value.
  16 */
  17/* write single register with mask */
  18static int tda10071_wr_reg_mask(struct tda10071_dev *dev,
  19				u8 reg, u8 val, u8 mask)
  20{
  21	int ret;
  22	u8 tmp;
  23
  24	/* no need for read if whole reg is written */
  25	if (mask != 0xff) {
  26		ret = regmap_bulk_read(dev->regmap, reg, &tmp, 1);
  27		if (ret)
  28			return ret;
  29
  30		val &= mask;
  31		tmp &= ~mask;
  32		val |= tmp;
  33	}
  34
  35	return regmap_bulk_write(dev->regmap, reg, &val, 1);
  36}
  37
  38/* execute firmware command */
  39static int tda10071_cmd_execute(struct tda10071_dev *dev,
  40	struct tda10071_cmd *cmd)
  41{
  42	struct i2c_client *client = dev->client;
  43	int ret, i;
  44	unsigned int uitmp;
  45
  46	if (!dev->warm) {
  47		ret = -EFAULT;
  48		goto error;
  49	}
  50
  51	mutex_lock(&dev->cmd_execute_mutex);
  52
  53	/* write cmd and args for firmware */
  54	ret = regmap_bulk_write(dev->regmap, 0x00, cmd->args, cmd->len);
  55	if (ret)
  56		goto error_mutex_unlock;
  57
  58	/* start cmd execution */
  59	ret = regmap_write(dev->regmap, 0x1f, 1);
  60	if (ret)
  61		goto error_mutex_unlock;
  62
  63	/* wait cmd execution terminate */
  64	for (i = 1000, uitmp = 1; i && uitmp; i--) {
  65		ret = regmap_read(dev->regmap, 0x1f, &uitmp);
  66		if (ret)
  67			goto error_mutex_unlock;
  68
  69		usleep_range(200, 5000);
  70	}
  71
  72	mutex_unlock(&dev->cmd_execute_mutex);
  73	dev_dbg(&client->dev, "loop=%d\n", i);
  74
  75	if (i == 0) {
  76		ret = -ETIMEDOUT;
  77		goto error;
  78	}
  79
  80	return ret;
  81error_mutex_unlock:
  82	mutex_unlock(&dev->cmd_execute_mutex);
  83error:
  84	dev_dbg(&client->dev, "failed=%d\n", ret);
  85	return ret;
  86}
  87
  88static int tda10071_set_tone(struct dvb_frontend *fe,
  89	enum fe_sec_tone_mode fe_sec_tone_mode)
  90{
  91	struct tda10071_dev *dev = fe->demodulator_priv;
  92	struct i2c_client *client = dev->client;
  93	struct tda10071_cmd cmd;
  94	int ret;
  95	u8 tone;
  96
  97	if (!dev->warm) {
  98		ret = -EFAULT;
  99		goto error;
 100	}
 101
 102	dev_dbg(&client->dev, "tone_mode=%d\n", fe_sec_tone_mode);
 103
 104	switch (fe_sec_tone_mode) {
 105	case SEC_TONE_ON:
 106		tone = 1;
 107		break;
 108	case SEC_TONE_OFF:
 109		tone = 0;
 110		break;
 111	default:
 112		dev_dbg(&client->dev, "invalid fe_sec_tone_mode\n");
 113		ret = -EINVAL;
 114		goto error;
 115	}
 116
 117	cmd.args[0] = CMD_LNB_PCB_CONFIG;
 118	cmd.args[1] = 0;
 119	cmd.args[2] = 0x00;
 120	cmd.args[3] = 0x00;
 121	cmd.args[4] = tone;
 122	cmd.len = 5;
 123	ret = tda10071_cmd_execute(dev, &cmd);
 124	if (ret)
 125		goto error;
 126
 127	return ret;
 128error:
 129	dev_dbg(&client->dev, "failed=%d\n", ret);
 130	return ret;
 131}
 132
 133static int tda10071_set_voltage(struct dvb_frontend *fe,
 134	enum fe_sec_voltage fe_sec_voltage)
 135{
 136	struct tda10071_dev *dev = fe->demodulator_priv;
 137	struct i2c_client *client = dev->client;
 138	struct tda10071_cmd cmd;
 139	int ret;
 140	u8 voltage;
 141
 142	if (!dev->warm) {
 143		ret = -EFAULT;
 144		goto error;
 145	}
 146
 147	dev_dbg(&client->dev, "voltage=%d\n", fe_sec_voltage);
 148
 149	switch (fe_sec_voltage) {
 150	case SEC_VOLTAGE_13:
 151		voltage = 0;
 152		break;
 153	case SEC_VOLTAGE_18:
 154		voltage = 1;
 155		break;
 156	case SEC_VOLTAGE_OFF:
 157		voltage = 0;
 158		break;
 159	default:
 160		dev_dbg(&client->dev, "invalid fe_sec_voltage\n");
 161		ret = -EINVAL;
 162		goto error;
 163	}
 164
 165	cmd.args[0] = CMD_LNB_SET_DC_LEVEL;
 166	cmd.args[1] = 0;
 167	cmd.args[2] = voltage;
 168	cmd.len = 3;
 169	ret = tda10071_cmd_execute(dev, &cmd);
 170	if (ret)
 171		goto error;
 172
 173	return ret;
 174error:
 175	dev_dbg(&client->dev, "failed=%d\n", ret);
 176	return ret;
 177}
 178
 179static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe,
 180	struct dvb_diseqc_master_cmd *diseqc_cmd)
 181{
 182	struct tda10071_dev *dev = fe->demodulator_priv;
 183	struct i2c_client *client = dev->client;
 184	struct tda10071_cmd cmd;
 185	int ret, i;
 186	unsigned int uitmp;
 187
 188	if (!dev->warm) {
 189		ret = -EFAULT;
 190		goto error;
 191	}
 192
 193	dev_dbg(&client->dev, "msg_len=%d\n", diseqc_cmd->msg_len);
 194
 195	if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) {
 196		ret = -EINVAL;
 197		goto error;
 198	}
 199
 200	/* wait LNB TX */
 201	for (i = 500, uitmp = 0; i && !uitmp; i--) {
 202		ret = regmap_read(dev->regmap, 0x47, &uitmp);
 203		if (ret)
 204			goto error;
 205		uitmp = (uitmp >> 0) & 1;
 206		usleep_range(10000, 20000);
 207	}
 208
 209	dev_dbg(&client->dev, "loop=%d\n", i);
 210
 211	if (i == 0) {
 212		ret = -ETIMEDOUT;
 213		goto error;
 214	}
 215
 216	ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00);
 217	if (ret)
 218		goto error;
 219
 220	cmd.args[0] = CMD_LNB_SEND_DISEQC;
 221	cmd.args[1] = 0;
 222	cmd.args[2] = 0;
 223	cmd.args[3] = 0;
 224	cmd.args[4] = 2;
 225	cmd.args[5] = 0;
 226	cmd.args[6] = diseqc_cmd->msg_len;
 227	memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len);
 228	cmd.len = 7 + diseqc_cmd->msg_len;
 229	ret = tda10071_cmd_execute(dev, &cmd);
 230	if (ret)
 231		goto error;
 232
 233	return ret;
 234error:
 235	dev_dbg(&client->dev, "failed=%d\n", ret);
 236	return ret;
 237}
 238
 239static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe,
 240	struct dvb_diseqc_slave_reply *reply)
 241{
 242	struct tda10071_dev *dev = fe->demodulator_priv;
 243	struct i2c_client *client = dev->client;
 244	struct tda10071_cmd cmd;
 245	int ret, i;
 246	unsigned int uitmp;
 247
 248	if (!dev->warm) {
 249		ret = -EFAULT;
 250		goto error;
 251	}
 252
 253	dev_dbg(&client->dev, "\n");
 254
 255	/* wait LNB RX */
 256	for (i = 500, uitmp = 0; i && !uitmp; i--) {
 257		ret = regmap_read(dev->regmap, 0x47, &uitmp);
 258		if (ret)
 259			goto error;
 260		uitmp = (uitmp >> 1) & 1;
 261		usleep_range(10000, 20000);
 262	}
 263
 264	dev_dbg(&client->dev, "loop=%d\n", i);
 265
 266	if (i == 0) {
 267		ret = -ETIMEDOUT;
 268		goto error;
 269	}
 270
 271	/* reply len */
 272	ret = regmap_read(dev->regmap, 0x46, &uitmp);
 273	if (ret)
 274		goto error;
 275
 276	reply->msg_len = uitmp & 0x1f; /* [4:0] */
 277	if (reply->msg_len > sizeof(reply->msg))
 278		reply->msg_len = sizeof(reply->msg); /* truncate API max */
 279
 280	/* read reply */
 281	cmd.args[0] = CMD_LNB_UPDATE_REPLY;
 282	cmd.args[1] = 0;
 283	cmd.len = 2;
 284	ret = tda10071_cmd_execute(dev, &cmd);
 285	if (ret)
 286		goto error;
 287
 288	ret = regmap_bulk_read(dev->regmap, cmd.len, reply->msg,
 289			       reply->msg_len);
 290	if (ret)
 291		goto error;
 292
 293	return ret;
 294error:
 295	dev_dbg(&client->dev, "failed=%d\n", ret);
 296	return ret;
 297}
 298
 299static int tda10071_diseqc_send_burst(struct dvb_frontend *fe,
 300	enum fe_sec_mini_cmd fe_sec_mini_cmd)
 301{
 302	struct tda10071_dev *dev = fe->demodulator_priv;
 303	struct i2c_client *client = dev->client;
 304	struct tda10071_cmd cmd;
 305	int ret, i;
 306	unsigned int uitmp;
 307	u8 burst;
 308
 309	if (!dev->warm) {
 310		ret = -EFAULT;
 311		goto error;
 312	}
 313
 314	dev_dbg(&client->dev, "fe_sec_mini_cmd=%d\n", fe_sec_mini_cmd);
 315
 316	switch (fe_sec_mini_cmd) {
 317	case SEC_MINI_A:
 318		burst = 0;
 319		break;
 320	case SEC_MINI_B:
 321		burst = 1;
 322		break;
 323	default:
 324		dev_dbg(&client->dev, "invalid fe_sec_mini_cmd\n");
 325		ret = -EINVAL;
 326		goto error;
 327	}
 328
 329	/* wait LNB TX */
 330	for (i = 500, uitmp = 0; i && !uitmp; i--) {
 331		ret = regmap_read(dev->regmap, 0x47, &uitmp);
 332		if (ret)
 333			goto error;
 334		uitmp = (uitmp >> 0) & 1;
 335		usleep_range(10000, 20000);
 336	}
 337
 338	dev_dbg(&client->dev, "loop=%d\n", i);
 339
 340	if (i == 0) {
 341		ret = -ETIMEDOUT;
 342		goto error;
 343	}
 344
 345	ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00);
 346	if (ret)
 347		goto error;
 348
 349	cmd.args[0] = CMD_LNB_SEND_TONEBURST;
 350	cmd.args[1] = 0;
 351	cmd.args[2] = burst;
 352	cmd.len = 3;
 353	ret = tda10071_cmd_execute(dev, &cmd);
 354	if (ret)
 355		goto error;
 356
 357	return ret;
 358error:
 359	dev_dbg(&client->dev, "failed=%d\n", ret);
 360	return ret;
 361}
 362
 363static int tda10071_read_status(struct dvb_frontend *fe, enum fe_status *status)
 364{
 365	struct tda10071_dev *dev = fe->demodulator_priv;
 366	struct i2c_client *client = dev->client;
 367	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 368	struct tda10071_cmd cmd;
 369	int ret;
 370	unsigned int uitmp;
 371	u8 buf[8];
 372
 373	*status = 0;
 374
 375	if (!dev->warm) {
 376		ret = 0;
 377		goto error;
 378	}
 379
 380	ret = regmap_read(dev->regmap, 0x39, &uitmp);
 381	if (ret)
 382		goto error;
 383
 384	/* 0x39[0] tuner PLL */
 385	if (uitmp & 0x02) /* demod PLL */
 386		*status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
 387	if (uitmp & 0x04) /* viterbi or LDPC*/
 388		*status |= FE_HAS_VITERBI;
 389	if (uitmp & 0x08) /* RS or BCH */
 390		*status |= FE_HAS_SYNC | FE_HAS_LOCK;
 391
 392	dev->fe_status = *status;
 393
 394	/* signal strength */
 395	if (dev->fe_status & FE_HAS_SIGNAL) {
 396		cmd.args[0] = CMD_GET_AGCACC;
 397		cmd.args[1] = 0;
 398		cmd.len = 2;
 399		ret = tda10071_cmd_execute(dev, &cmd);
 400		if (ret)
 401			goto error;
 402
 403		/* input power estimate dBm */
 404		ret = regmap_read(dev->regmap, 0x50, &uitmp);
 405		if (ret)
 406			goto error;
 407
 408		c->strength.stat[0].scale = FE_SCALE_DECIBEL;
 409		c->strength.stat[0].svalue = (int) (uitmp - 256) * 1000;
 410	} else {
 411		c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 412	}
 413
 414	/* CNR */
 415	if (dev->fe_status & FE_HAS_VITERBI) {
 416		/* Es/No */
 417		ret = regmap_bulk_read(dev->regmap, 0x3a, buf, 2);
 418		if (ret)
 419			goto error;
 420
 421		c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 422		c->cnr.stat[0].svalue = (buf[0] << 8 | buf[1] << 0) * 100;
 423	} else {
 424		c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 425	}
 426
 427	/* UCB/PER/BER */
 428	if (dev->fe_status & FE_HAS_LOCK) {
 429		/* TODO: report total bits/packets */
 430		u8 delivery_system, reg, len;
 431
 432		switch (dev->delivery_system) {
 433		case SYS_DVBS:
 434			reg = 0x4c;
 435			len = 8;
 436			delivery_system = 1;
 437			break;
 438		case SYS_DVBS2:
 439			reg = 0x4d;
 440			len = 4;
 441			delivery_system = 0;
 442			break;
 443		default:
 444			ret = -EINVAL;
 445			goto error;
 446		}
 447
 448		ret = regmap_read(dev->regmap, reg, &uitmp);
 449		if (ret)
 450			goto error;
 451
 452		if (dev->meas_count == uitmp) {
 453			dev_dbg(&client->dev, "meas not ready=%02x\n", uitmp);
 454			ret = 0;
 455			goto error;
 456		} else {
 457			dev->meas_count = uitmp;
 458		}
 459
 460		cmd.args[0] = CMD_BER_UPDATE_COUNTERS;
 461		cmd.args[1] = 0;
 462		cmd.args[2] = delivery_system;
 463		cmd.len = 3;
 464		ret = tda10071_cmd_execute(dev, &cmd);
 465		if (ret)
 466			goto error;
 467
 468		ret = regmap_bulk_read(dev->regmap, cmd.len, buf, len);
 469		if (ret)
 470			goto error;
 471
 472		if (dev->delivery_system == SYS_DVBS) {
 473			u32 bit_error = buf[0] << 24 | buf[1] << 16 |
 474					buf[2] << 8 | buf[3] << 0;
 475
 476			dev->dvbv3_ber = bit_error;
 477			dev->post_bit_error += bit_error;
 478			c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
 479			c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
 480			dev->block_error += buf[4] << 8 | buf[5] << 0;
 481			c->block_error.stat[0].scale = FE_SCALE_COUNTER;
 482			c->block_error.stat[0].uvalue = dev->block_error;
 483		} else {
 484			dev->dvbv3_ber = buf[0] << 8 | buf[1] << 0;
 485			dev->post_bit_error += buf[0] << 8 | buf[1] << 0;
 486			c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
 487			c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
 488			c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 489		}
 490	} else {
 491		c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 492		c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 493	}
 494
 495	return ret;
 496error:
 497	dev_dbg(&client->dev, "failed=%d\n", ret);
 498	return ret;
 499}
 500
 501static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr)
 502{
 503	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 504
 505	if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
 506		*snr = div_s64(c->cnr.stat[0].svalue, 100);
 507	else
 508		*snr = 0;
 509	return 0;
 510}
 511
 512static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 513{
 514	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 515	unsigned int uitmp;
 516
 517	if (c->strength.stat[0].scale == FE_SCALE_DECIBEL) {
 518		uitmp = div_s64(c->strength.stat[0].svalue, 1000) + 256;
 519		uitmp = clamp(uitmp, 181U, 236U); /* -75dBm - -20dBm */
 520		/* scale value to 0x0000-0xffff */
 521		*strength = (uitmp-181) * 0xffff / (236-181);
 522	} else {
 523		*strength = 0;
 524	}
 525	return 0;
 526}
 527
 528static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber)
 529{
 530	struct tda10071_dev *dev = fe->demodulator_priv;
 531
 532	*ber = dev->dvbv3_ber;
 533	return 0;
 534}
 535
 536static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 537{
 538	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 539
 540	if (c->block_error.stat[0].scale == FE_SCALE_COUNTER)
 541		*ucblocks = c->block_error.stat[0].uvalue;
 542	else
 543		*ucblocks = 0;
 544	return 0;
 545}
 546
 547static int tda10071_set_frontend(struct dvb_frontend *fe)
 548{
 549	struct tda10071_dev *dev = fe->demodulator_priv;
 550	struct i2c_client *client = dev->client;
 551	struct tda10071_cmd cmd;
 552	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 553	int ret, i;
 554	u8 mode, rolloff, pilot, inversion, div;
 555	enum fe_modulation modulation;
 556
 557	dev_dbg(&client->dev,
 558		"delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
 559		c->delivery_system, c->modulation, c->frequency, c->symbol_rate,
 560		c->inversion, c->pilot, c->rolloff);
 561
 562	dev->delivery_system = SYS_UNDEFINED;
 563
 564	if (!dev->warm) {
 565		ret = -EFAULT;
 566		goto error;
 567	}
 568
 569	switch (c->inversion) {
 570	case INVERSION_OFF:
 571		inversion = 1;
 572		break;
 573	case INVERSION_ON:
 574		inversion = 0;
 575		break;
 576	case INVERSION_AUTO:
 577		/* 2 = auto; try first on then off
 578		 * 3 = auto; try first off then on */
 579		inversion = 3;
 580		break;
 581	default:
 582		dev_dbg(&client->dev, "invalid inversion\n");
 583		ret = -EINVAL;
 584		goto error;
 585	}
 586
 587	switch (c->delivery_system) {
 588	case SYS_DVBS:
 589		modulation = QPSK;
 590		rolloff = 0;
 591		pilot = 2;
 592		break;
 593	case SYS_DVBS2:
 594		modulation = c->modulation;
 595
 596		switch (c->rolloff) {
 597		case ROLLOFF_20:
 598			rolloff = 2;
 599			break;
 600		case ROLLOFF_25:
 601			rolloff = 1;
 602			break;
 603		case ROLLOFF_35:
 604			rolloff = 0;
 605			break;
 606		case ROLLOFF_AUTO:
 607		default:
 608			dev_dbg(&client->dev, "invalid rolloff\n");
 609			ret = -EINVAL;
 610			goto error;
 611		}
 612
 613		switch (c->pilot) {
 614		case PILOT_OFF:
 615			pilot = 0;
 616			break;
 617		case PILOT_ON:
 618			pilot = 1;
 619			break;
 620		case PILOT_AUTO:
 621			pilot = 2;
 622			break;
 623		default:
 624			dev_dbg(&client->dev, "invalid pilot\n");
 625			ret = -EINVAL;
 626			goto error;
 627		}
 628		break;
 629	default:
 630		dev_dbg(&client->dev, "invalid delivery_system\n");
 631		ret = -EINVAL;
 632		goto error;
 633	}
 634
 635	for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
 636		if (c->delivery_system == TDA10071_MODCOD[i].delivery_system &&
 637			modulation == TDA10071_MODCOD[i].modulation &&
 638			c->fec_inner == TDA10071_MODCOD[i].fec) {
 639			mode = TDA10071_MODCOD[i].val;
 640			dev_dbg(&client->dev, "mode found=%02x\n", mode);
 641			break;
 642		}
 643	}
 644
 645	if (mode == 0xff) {
 646		dev_dbg(&client->dev, "invalid parameter combination\n");
 647		ret = -EINVAL;
 648		goto error;
 649	}
 650
 651	if (c->symbol_rate <= 5000000)
 652		div = 14;
 653	else
 654		div = 4;
 655
 656	ret = regmap_write(dev->regmap, 0x81, div);
 657	if (ret)
 658		goto error;
 659
 660	ret = regmap_write(dev->regmap, 0xe3, div);
 661	if (ret)
 662		goto error;
 663
 664	cmd.args[0] = CMD_CHANGE_CHANNEL;
 665	cmd.args[1] = 0;
 666	cmd.args[2] = mode;
 667	cmd.args[3] = (c->frequency >> 16) & 0xff;
 668	cmd.args[4] = (c->frequency >>  8) & 0xff;
 669	cmd.args[5] = (c->frequency >>  0) & 0xff;
 670	cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff;
 671	cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff;
 672	cmd.args[8] = ((tda10071_ops.info.frequency_tolerance_hz / 1000) >> 8) & 0xff;
 673	cmd.args[9] = ((tda10071_ops.info.frequency_tolerance_hz / 1000) >> 0) & 0xff;
 674	cmd.args[10] = rolloff;
 675	cmd.args[11] = inversion;
 676	cmd.args[12] = pilot;
 677	cmd.args[13] = 0x00;
 678	cmd.args[14] = 0x00;
 679	cmd.len = 15;
 680	ret = tda10071_cmd_execute(dev, &cmd);
 681	if (ret)
 682		goto error;
 683
 684	dev->delivery_system = c->delivery_system;
 685
 686	return ret;
 687error:
 688	dev_dbg(&client->dev, "failed=%d\n", ret);
 689	return ret;
 690}
 691
 692static int tda10071_get_frontend(struct dvb_frontend *fe,
 693				 struct dtv_frontend_properties *c)
 694{
 695	struct tda10071_dev *dev = fe->demodulator_priv;
 696	struct i2c_client *client = dev->client;
 697	int ret, i;
 698	u8 buf[5], tmp;
 699
 700	if (!dev->warm || !(dev->fe_status & FE_HAS_LOCK)) {
 701		ret = 0;
 702		goto error;
 703	}
 704
 705	ret = regmap_bulk_read(dev->regmap, 0x30, buf, 5);
 706	if (ret)
 707		goto error;
 708
 709	tmp = buf[0] & 0x3f;
 710	for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) {
 711		if (tmp == TDA10071_MODCOD[i].val) {
 712			c->modulation = TDA10071_MODCOD[i].modulation;
 713			c->fec_inner = TDA10071_MODCOD[i].fec;
 714			c->delivery_system = TDA10071_MODCOD[i].delivery_system;
 715		}
 716	}
 717
 718	switch ((buf[1] >> 0) & 0x01) {
 719	case 0:
 720		c->inversion = INVERSION_ON;
 721		break;
 722	case 1:
 723		c->inversion = INVERSION_OFF;
 724		break;
 725	}
 726
 727	switch ((buf[1] >> 7) & 0x01) {
 728	case 0:
 729		c->pilot = PILOT_OFF;
 730		break;
 731	case 1:
 732		c->pilot = PILOT_ON;
 733		break;
 734	}
 735
 736	c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0);
 737
 738	ret = regmap_bulk_read(dev->regmap, 0x52, buf, 3);
 739	if (ret)
 740		goto error;
 741
 742	c->symbol_rate = ((buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0)) * 1000;
 743
 744	return ret;
 745error:
 746	dev_dbg(&client->dev, "failed=%d\n", ret);
 747	return ret;
 748}
 749
 750static int tda10071_init(struct dvb_frontend *fe)
 751{
 752	struct tda10071_dev *dev = fe->demodulator_priv;
 753	struct i2c_client *client = dev->client;
 754	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 755	struct tda10071_cmd cmd;
 756	int ret, i, len, remaining, fw_size;
 757	unsigned int uitmp;
 758	const struct firmware *fw;
 759	u8 *fw_file = TDA10071_FIRMWARE;
 760	u8 tmp, buf[4];
 761	struct tda10071_reg_val_mask tab[] = {
 762		{ 0xcd, 0x00, 0x07 },
 763		{ 0x80, 0x00, 0x02 },
 764		{ 0xcd, 0x00, 0xc0 },
 765		{ 0xce, 0x00, 0x1b },
 766		{ 0x9d, 0x00, 0x01 },
 767		{ 0x9d, 0x00, 0x02 },
 768		{ 0x9e, 0x00, 0x01 },
 769		{ 0x87, 0x00, 0x80 },
 770		{ 0xce, 0x00, 0x08 },
 771		{ 0xce, 0x00, 0x10 },
 772	};
 773	struct tda10071_reg_val_mask tab2[] = {
 774		{ 0xf1, 0x70, 0xff },
 775		{ 0x88, dev->pll_multiplier, 0x3f },
 776		{ 0x89, 0x00, 0x10 },
 777		{ 0x89, 0x10, 0x10 },
 778		{ 0xc0, 0x01, 0x01 },
 779		{ 0xc0, 0x00, 0x01 },
 780		{ 0xe0, 0xff, 0xff },
 781		{ 0xe0, 0x00, 0xff },
 782		{ 0x96, 0x1e, 0x7e },
 783		{ 0x8b, 0x08, 0x08 },
 784		{ 0x8b, 0x00, 0x08 },
 785		{ 0x8f, 0x1a, 0x7e },
 786		{ 0x8c, 0x68, 0xff },
 787		{ 0x8d, 0x08, 0xff },
 788		{ 0x8e, 0x4c, 0xff },
 789		{ 0x8f, 0x01, 0x01 },
 790		{ 0x8b, 0x04, 0x04 },
 791		{ 0x8b, 0x00, 0x04 },
 792		{ 0x87, 0x05, 0x07 },
 793		{ 0x80, 0x00, 0x20 },
 794		{ 0xc8, 0x01, 0xff },
 795		{ 0xb4, 0x47, 0xff },
 796		{ 0xb5, 0x9c, 0xff },
 797		{ 0xb6, 0x7d, 0xff },
 798		{ 0xba, 0x00, 0x03 },
 799		{ 0xb7, 0x47, 0xff },
 800		{ 0xb8, 0x9c, 0xff },
 801		{ 0xb9, 0x7d, 0xff },
 802		{ 0xba, 0x00, 0x0c },
 803		{ 0xc8, 0x00, 0xff },
 804		{ 0xcd, 0x00, 0x04 },
 805		{ 0xcd, 0x00, 0x20 },
 806		{ 0xe8, 0x02, 0xff },
 807		{ 0xcf, 0x20, 0xff },
 808		{ 0x9b, 0xd7, 0xff },
 809		{ 0x9a, 0x01, 0x03 },
 810		{ 0xa8, 0x05, 0x0f },
 811		{ 0xa8, 0x65, 0xf0 },
 812		{ 0xa6, 0xa0, 0xf0 },
 813		{ 0x9d, 0x50, 0xfc },
 814		{ 0x9e, 0x20, 0xe0 },
 815		{ 0xa3, 0x1c, 0x7c },
 816		{ 0xd5, 0x03, 0x03 },
 817	};
 818
 819	if (dev->warm) {
 820		/* warm state - wake up device from sleep */
 821
 822		for (i = 0; i < ARRAY_SIZE(tab); i++) {
 823			ret = tda10071_wr_reg_mask(dev, tab[i].reg,
 824				tab[i].val, tab[i].mask);
 825			if (ret)
 826				goto error;
 827		}
 828
 829		cmd.args[0] = CMD_SET_SLEEP_MODE;
 830		cmd.args[1] = 0;
 831		cmd.args[2] = 0;
 832		cmd.len = 3;
 833		ret = tda10071_cmd_execute(dev, &cmd);
 834		if (ret)
 835			goto error;
 836	} else {
 837		/* cold state - try to download firmware */
 838
 839		/* request the firmware, this will block and timeout */
 840		ret = request_firmware(&fw, fw_file, &client->dev);
 841		if (ret) {
 842			dev_err(&client->dev,
 843				"did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\n",
 844				fw_file, ret);
 845			goto error;
 846		}
 847
 848		/* init */
 849		for (i = 0; i < ARRAY_SIZE(tab2); i++) {
 850			ret = tda10071_wr_reg_mask(dev, tab2[i].reg,
 851				tab2[i].val, tab2[i].mask);
 852			if (ret)
 853				goto error_release_firmware;
 854		}
 855
 856		/*  download firmware */
 857		ret = regmap_write(dev->regmap, 0xe0, 0x7f);
 858		if (ret)
 859			goto error_release_firmware;
 860
 861		ret = regmap_write(dev->regmap, 0xf7, 0x81);
 862		if (ret)
 863			goto error_release_firmware;
 864
 865		ret = regmap_write(dev->regmap, 0xf8, 0x00);
 866		if (ret)
 867			goto error_release_firmware;
 868
 869		ret = regmap_write(dev->regmap, 0xf9, 0x00);
 870		if (ret)
 871			goto error_release_firmware;
 872
 873		dev_info(&client->dev,
 874			 "found a '%s' in cold state, will try to load a firmware\n",
 875			 tda10071_ops.info.name);
 876		dev_info(&client->dev, "downloading firmware from file '%s'\n",
 877			 fw_file);
 878
 879		/* do not download last byte */
 880		fw_size = fw->size - 1;
 881
 882		for (remaining = fw_size; remaining > 0;
 883			remaining -= (dev->i2c_wr_max - 1)) {
 884			len = remaining;
 885			if (len > (dev->i2c_wr_max - 1))
 886				len = (dev->i2c_wr_max - 1);
 887
 888			ret = regmap_bulk_write(dev->regmap, 0xfa,
 889				(u8 *) &fw->data[fw_size - remaining], len);
 890			if (ret) {
 891				dev_err(&client->dev,
 892					"firmware download failed=%d\n", ret);
 893				goto error_release_firmware;
 894			}
 895		}
 896		release_firmware(fw);
 897
 898		ret = regmap_write(dev->regmap, 0xf7, 0x0c);
 899		if (ret)
 900			goto error;
 901
 902		ret = regmap_write(dev->regmap, 0xe0, 0x00);
 903		if (ret)
 904			goto error;
 905
 906		/* wait firmware start */
 907		msleep(250);
 908
 909		/* firmware status */
 910		ret = regmap_read(dev->regmap, 0x51, &uitmp);
 911		if (ret)
 912			goto error;
 913
 914		if (uitmp) {
 915			dev_info(&client->dev, "firmware did not run\n");
 916			ret = -EFAULT;
 917			goto error;
 918		} else {
 919			dev->warm = true;
 920		}
 921
 922		cmd.args[0] = CMD_GET_FW_VERSION;
 923		cmd.len = 1;
 924		ret = tda10071_cmd_execute(dev, &cmd);
 925		if (ret)
 926			goto error;
 927
 928		ret = regmap_bulk_read(dev->regmap, cmd.len, buf, 4);
 929		if (ret)
 930			goto error;
 931
 932		dev_info(&client->dev, "firmware version %d.%d.%d.%d\n",
 933			 buf[0], buf[1], buf[2], buf[3]);
 934		dev_info(&client->dev, "found a '%s' in warm state\n",
 935			 tda10071_ops.info.name);
 936
 937		ret = regmap_bulk_read(dev->regmap, 0x81, buf, 2);
 938		if (ret)
 939			goto error;
 940
 941		cmd.args[0] = CMD_DEMOD_INIT;
 942		cmd.args[1] = ((dev->clk / 1000) >> 8) & 0xff;
 943		cmd.args[2] = ((dev->clk / 1000) >> 0) & 0xff;
 944		cmd.args[3] = buf[0];
 945		cmd.args[4] = buf[1];
 946		cmd.args[5] = dev->pll_multiplier;
 947		cmd.args[6] = dev->spec_inv;
 948		cmd.args[7] = 0x00;
 949		cmd.len = 8;
 950		ret = tda10071_cmd_execute(dev, &cmd);
 951		if (ret)
 952			goto error;
 953
 954		if (dev->tuner_i2c_addr)
 955			tmp = dev->tuner_i2c_addr;
 956		else
 957			tmp = 0x14;
 958
 959		cmd.args[0] = CMD_TUNER_INIT;
 960		cmd.args[1] = 0x00;
 961		cmd.args[2] = 0x00;
 962		cmd.args[3] = 0x00;
 963		cmd.args[4] = 0x00;
 964		cmd.args[5] = tmp;
 965		cmd.args[6] = 0x00;
 966		cmd.args[7] = 0x03;
 967		cmd.args[8] = 0x02;
 968		cmd.args[9] = 0x02;
 969		cmd.args[10] = 0x00;
 970		cmd.args[11] = 0x00;
 971		cmd.args[12] = 0x00;
 972		cmd.args[13] = 0x00;
 973		cmd.args[14] = 0x00;
 974		cmd.len = 15;
 975		ret = tda10071_cmd_execute(dev, &cmd);
 976		if (ret)
 977			goto error;
 978
 979		cmd.args[0] = CMD_MPEG_CONFIG;
 980		cmd.args[1] = 0;
 981		cmd.args[2] = dev->ts_mode;
 982		cmd.args[3] = 0x00;
 983		cmd.args[4] = 0x04;
 984		cmd.args[5] = 0x00;
 985		cmd.len = 6;
 986		ret = tda10071_cmd_execute(dev, &cmd);
 987		if (ret)
 988			goto error;
 989
 990		ret = regmap_update_bits(dev->regmap, 0xf0, 0x01, 0x01);
 991		if (ret)
 992			goto error;
 993
 994		cmd.args[0] = CMD_LNB_CONFIG;
 995		cmd.args[1] = 0;
 996		cmd.args[2] = 150;
 997		cmd.args[3] = 3;
 998		cmd.args[4] = 22;
 999		cmd.args[5] = 1;
1000		cmd.args[6] = 1;
1001		cmd.args[7] = 30;
1002		cmd.args[8] = 30;
1003		cmd.args[9] = 30;
1004		cmd.args[10] = 30;
1005		cmd.len = 11;
1006		ret = tda10071_cmd_execute(dev, &cmd);
1007		if (ret)
1008			goto error;
1009
1010		cmd.args[0] = CMD_BER_CONTROL;
1011		cmd.args[1] = 0;
1012		cmd.args[2] = 14;
1013		cmd.args[3] = 14;
1014		cmd.len = 4;
1015		ret = tda10071_cmd_execute(dev, &cmd);
1016		if (ret)
1017			goto error;
1018	}
1019
1020	/* init stats here in order signal app which stats are supported */
1021	c->strength.len = 1;
1022	c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1023	c->cnr.len = 1;
1024	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1025	c->post_bit_error.len = 1;
1026	c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1027	c->block_error.len = 1;
1028	c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
1029
1030	return ret;
1031error_release_firmware:
1032	release_firmware(fw);
1033error:
1034	dev_dbg(&client->dev, "failed=%d\n", ret);
1035	return ret;
1036}
1037
1038static int tda10071_sleep(struct dvb_frontend *fe)
1039{
1040	struct tda10071_dev *dev = fe->demodulator_priv;
1041	struct i2c_client *client = dev->client;
1042	struct tda10071_cmd cmd;
1043	int ret, i;
1044	struct tda10071_reg_val_mask tab[] = {
1045		{ 0xcd, 0x07, 0x07 },
1046		{ 0x80, 0x02, 0x02 },
1047		{ 0xcd, 0xc0, 0xc0 },
1048		{ 0xce, 0x1b, 0x1b },
1049		{ 0x9d, 0x01, 0x01 },
1050		{ 0x9d, 0x02, 0x02 },
1051		{ 0x9e, 0x01, 0x01 },
1052		{ 0x87, 0x80, 0x80 },
1053		{ 0xce, 0x08, 0x08 },
1054		{ 0xce, 0x10, 0x10 },
1055	};
1056
1057	if (!dev->warm) {
1058		ret = -EFAULT;
1059		goto error;
1060	}
1061
1062	cmd.args[0] = CMD_SET_SLEEP_MODE;
1063	cmd.args[1] = 0;
1064	cmd.args[2] = 1;
1065	cmd.len = 3;
1066	ret = tda10071_cmd_execute(dev, &cmd);
1067	if (ret)
1068		goto error;
1069
1070	for (i = 0; i < ARRAY_SIZE(tab); i++) {
1071		ret = tda10071_wr_reg_mask(dev, tab[i].reg, tab[i].val,
1072			tab[i].mask);
1073		if (ret)
1074			goto error;
1075	}
1076
1077	return ret;
1078error:
1079	dev_dbg(&client->dev, "failed=%d\n", ret);
1080	return ret;
1081}
1082
1083static int tda10071_get_tune_settings(struct dvb_frontend *fe,
1084	struct dvb_frontend_tune_settings *s)
1085{
1086	s->min_delay_ms = 8000;
1087	s->step_size = 0;
1088	s->max_drift = 0;
1089
1090	return 0;
1091}
1092
1093static const struct dvb_frontend_ops tda10071_ops = {
1094	.delsys = { SYS_DVBS, SYS_DVBS2 },
1095	.info = {
1096		.name = "NXP TDA10071",
1097		.frequency_min_hz    =  950 * MHz,
1098		.frequency_max_hz    = 2150 * MHz,
1099		.frequency_tolerance_hz = 5 * MHz,
1100		.symbol_rate_min = 1000000,
1101		.symbol_rate_max = 45000000,
1102		.caps = FE_CAN_INVERSION_AUTO |
1103			FE_CAN_FEC_1_2 |
1104			FE_CAN_FEC_2_3 |
1105			FE_CAN_FEC_3_4 |
1106			FE_CAN_FEC_4_5 |
1107			FE_CAN_FEC_5_6 |
1108			FE_CAN_FEC_6_7 |
1109			FE_CAN_FEC_7_8 |
1110			FE_CAN_FEC_8_9 |
1111			FE_CAN_FEC_AUTO |
1112			FE_CAN_QPSK |
1113			FE_CAN_RECOVER |
1114			FE_CAN_2G_MODULATION
1115	},
1116
1117	.get_tune_settings = tda10071_get_tune_settings,
1118
1119	.init = tda10071_init,
1120	.sleep = tda10071_sleep,
1121
1122	.set_frontend = tda10071_set_frontend,
1123	.get_frontend = tda10071_get_frontend,
1124
1125	.read_status = tda10071_read_status,
1126	.read_snr = tda10071_read_snr,
1127	.read_signal_strength = tda10071_read_signal_strength,
1128	.read_ber = tda10071_read_ber,
1129	.read_ucblocks = tda10071_read_ucblocks,
1130
1131	.diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd,
1132	.diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply,
1133	.diseqc_send_burst = tda10071_diseqc_send_burst,
1134
1135	.set_tone = tda10071_set_tone,
1136	.set_voltage = tda10071_set_voltage,
1137};
1138
1139static struct dvb_frontend *tda10071_get_dvb_frontend(struct i2c_client *client)
1140{
1141	struct tda10071_dev *dev = i2c_get_clientdata(client);
1142
1143	dev_dbg(&client->dev, "\n");
1144
1145	return &dev->fe;
1146}
1147
1148static int tda10071_probe(struct i2c_client *client)
1149{
1150	struct tda10071_dev *dev;
1151	struct tda10071_platform_data *pdata = client->dev.platform_data;
1152	int ret;
1153	unsigned int uitmp;
1154	static const struct regmap_config regmap_config = {
1155		.reg_bits = 8,
1156		.val_bits = 8,
1157	};
1158
1159	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1160	if (!dev) {
1161		ret = -ENOMEM;
1162		goto err;
1163	}
1164
1165	dev->client = client;
1166	mutex_init(&dev->cmd_execute_mutex);
1167	dev->clk = pdata->clk;
1168	dev->i2c_wr_max = pdata->i2c_wr_max;
1169	dev->ts_mode = pdata->ts_mode;
1170	dev->spec_inv = pdata->spec_inv;
1171	dev->pll_multiplier = pdata->pll_multiplier;
1172	dev->tuner_i2c_addr = pdata->tuner_i2c_addr;
1173	dev->regmap = devm_regmap_init_i2c(client, &regmap_config);
1174	if (IS_ERR(dev->regmap)) {
1175		ret = PTR_ERR(dev->regmap);
1176		goto err_kfree;
1177	}
1178
1179	/* chip ID */
1180	ret = regmap_read(dev->regmap, 0xff, &uitmp);
1181	if (ret)
1182		goto err_kfree;
1183	if (uitmp != 0x0f) {
1184		ret = -ENODEV;
1185		goto err_kfree;
1186	}
1187
1188	/* chip type */
1189	ret = regmap_read(dev->regmap, 0xdd, &uitmp);
1190	if (ret)
1191		goto err_kfree;
1192	if (uitmp != 0x00) {
1193		ret = -ENODEV;
1194		goto err_kfree;
1195	}
1196
1197	/* chip version */
1198	ret = regmap_read(dev->regmap, 0xfe, &uitmp);
1199	if (ret)
1200		goto err_kfree;
1201	if (uitmp != 0x01) {
1202		ret = -ENODEV;
1203		goto err_kfree;
1204	}
1205
1206	/* create dvb_frontend */
1207	memcpy(&dev->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops));
1208	dev->fe.demodulator_priv = dev;
1209	i2c_set_clientdata(client, dev);
1210
1211	/* setup callbacks */
1212	pdata->get_dvb_frontend = tda10071_get_dvb_frontend;
1213
1214	dev_info(&client->dev, "NXP TDA10071 successfully identified\n");
1215	return 0;
1216err_kfree:
1217	kfree(dev);
1218err:
1219	dev_dbg(&client->dev, "failed=%d\n", ret);
1220	return ret;
1221}
1222
1223static void tda10071_remove(struct i2c_client *client)
1224{
1225	struct tda10071_dev *dev = i2c_get_clientdata(client);
1226
1227	dev_dbg(&client->dev, "\n");
1228
1229	kfree(dev);
1230}
1231
1232static const struct i2c_device_id tda10071_id_table[] = {
1233	{ "tda10071_cx24118" },
1234	{}
1235};
1236MODULE_DEVICE_TABLE(i2c, tda10071_id_table);
1237
1238static struct i2c_driver tda10071_driver = {
1239	.driver = {
1240		.name	= "tda10071",
1241		.suppress_bind_attrs = true,
1242	},
1243	.probe		= tda10071_probe,
1244	.remove		= tda10071_remove,
1245	.id_table	= tda10071_id_table,
1246};
1247
1248module_i2c_driver(tda10071_driver);
1249
1250MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1251MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver");
1252MODULE_LICENSE("GPL");
1253MODULE_FIRMWARE(TDA10071_FIRMWARE);