1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * cxd2880_top.c 4 * Sony CXD2880 DVB-T2/T tuner + demodulator driver 5 * 6 * Copyright (C) 2016, 2017, 2018 Sony Semiconductor Solutions Corporation 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ 10 11 #include <linux/spi/spi.h> 12 13 #include <media/dvb_frontend.h> 14 #include <linux/int_log.h> 15 16 #include "cxd2880.h" 17 #include "cxd2880_tnrdmd_mon.h" 18 #include "cxd2880_tnrdmd_dvbt2_mon.h" 19 #include "cxd2880_tnrdmd_dvbt_mon.h" 20 #include "cxd2880_integ.h" 21 #include "cxd2880_tnrdmd_dvbt2.h" 22 #include "cxd2880_tnrdmd_dvbt.h" 23 #include "cxd2880_devio_spi.h" 24 #include "cxd2880_spi_device.h" 25 #include "cxd2880_tnrdmd_driver_version.h" 26 27 struct cxd2880_priv { 28 struct cxd2880_tnrdmd tnrdmd; 29 struct spi_device *spi; 30 struct cxd2880_io regio; 31 struct cxd2880_spi_device spi_device; 32 struct cxd2880_spi cxd2880_spi; 33 struct cxd2880_dvbt_tune_param dvbt_tune_param; 34 struct cxd2880_dvbt2_tune_param dvbt2_tune_param; 35 struct mutex *spi_mutex; /* For SPI access exclusive control */ 36 unsigned long pre_ber_update; 37 unsigned long pre_ber_interval; 38 unsigned long post_ber_update; 39 unsigned long post_ber_interval; 40 unsigned long ucblock_update; 41 unsigned long ucblock_interval; 42 enum fe_status s; 43 }; 44 45 static int cxd2880_pre_bit_err_t(struct cxd2880_tnrdmd *tnrdmd, 46 u32 *pre_bit_err, u32 *pre_bit_count) 47 { 48 u8 rdata[2]; 49 int ret; 50 51 if (!tnrdmd || !pre_bit_err || !pre_bit_count) 52 return -EINVAL; 53 54 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 55 return -EINVAL; 56 57 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 58 return -EINVAL; 59 60 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT) 61 return -EINVAL; 62 63 ret = slvt_freeze_reg(tnrdmd); 64 if (ret) 65 return ret; 66 67 ret = tnrdmd->io->write_reg(tnrdmd->io, 68 CXD2880_IO_TGT_DMD, 69 0x00, 0x10); 70 if (ret) { 71 slvt_unfreeze_reg(tnrdmd); 72 return ret; 73 } 74 75 ret = tnrdmd->io->read_regs(tnrdmd->io, 76 CXD2880_IO_TGT_DMD, 77 0x39, rdata, 1); 78 if (ret) { 79 slvt_unfreeze_reg(tnrdmd); 80 return ret; 81 } 82 83 if ((rdata[0] & 0x01) == 0) { 84 slvt_unfreeze_reg(tnrdmd); 85 return -EAGAIN; 86 } 87 88 ret = tnrdmd->io->read_regs(tnrdmd->io, 89 CXD2880_IO_TGT_DMD, 90 0x22, rdata, 2); 91 if (ret) { 92 slvt_unfreeze_reg(tnrdmd); 93 return ret; 94 } 95 96 *pre_bit_err = (rdata[0] << 8) | rdata[1]; 97 98 ret = tnrdmd->io->read_regs(tnrdmd->io, 99 CXD2880_IO_TGT_DMD, 100 0x6f, rdata, 1); 101 if (ret) { 102 slvt_unfreeze_reg(tnrdmd); 103 return ret; 104 } 105 106 slvt_unfreeze_reg(tnrdmd); 107 108 *pre_bit_count = ((rdata[0] & 0x07) == 0) ? 109 256 : (0x1000 << (rdata[0] & 0x07)); 110 111 return 0; 112 } 113 114 static int cxd2880_pre_bit_err_t2(struct cxd2880_tnrdmd *tnrdmd, 115 u32 *pre_bit_err, 116 u32 *pre_bit_count) 117 { 118 u32 period_exp = 0; 119 u32 n_ldpc = 0; 120 u8 data[5]; 121 int ret; 122 123 if (!tnrdmd || !pre_bit_err || !pre_bit_count) 124 return -EINVAL; 125 126 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 127 return -EINVAL; 128 129 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 130 return -EINVAL; 131 132 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT2) 133 return -EINVAL; 134 135 ret = slvt_freeze_reg(tnrdmd); 136 if (ret) 137 return ret; 138 139 ret = tnrdmd->io->write_reg(tnrdmd->io, 140 CXD2880_IO_TGT_DMD, 141 0x00, 0x0b); 142 if (ret) { 143 slvt_unfreeze_reg(tnrdmd); 144 return ret; 145 } 146 147 ret = tnrdmd->io->read_regs(tnrdmd->io, 148 CXD2880_IO_TGT_DMD, 149 0x3c, data, sizeof(data)); 150 if (ret) { 151 slvt_unfreeze_reg(tnrdmd); 152 return ret; 153 } 154 155 if (!(data[0] & 0x01)) { 156 slvt_unfreeze_reg(tnrdmd); 157 return -EAGAIN; 158 } 159 *pre_bit_err = 160 ((data[1] & 0x0f) << 24) | (data[2] << 16) | (data[3] << 8) | data[4]; 161 162 ret = tnrdmd->io->read_regs(tnrdmd->io, 163 CXD2880_IO_TGT_DMD, 164 0xa0, data, 1); 165 if (ret) { 166 slvt_unfreeze_reg(tnrdmd); 167 return ret; 168 } 169 170 if (((enum cxd2880_dvbt2_plp_fec)(data[0] & 0x03)) == 171 CXD2880_DVBT2_FEC_LDPC_16K) 172 n_ldpc = 16200; 173 else 174 n_ldpc = 64800; 175 slvt_unfreeze_reg(tnrdmd); 176 177 ret = tnrdmd->io->write_reg(tnrdmd->io, 178 CXD2880_IO_TGT_DMD, 179 0x00, 0x20); 180 if (ret) 181 return ret; 182 183 ret = tnrdmd->io->read_regs(tnrdmd->io, 184 CXD2880_IO_TGT_DMD, 185 0x6f, data, 1); 186 if (ret) 187 return ret; 188 189 period_exp = data[0] & 0x0f; 190 191 *pre_bit_count = (1U << period_exp) * n_ldpc; 192 193 return 0; 194 } 195 196 static int cxd2880_post_bit_err_t(struct cxd2880_tnrdmd *tnrdmd, 197 u32 *post_bit_err, 198 u32 *post_bit_count) 199 { 200 u8 rdata[3]; 201 u32 bit_error = 0; 202 u32 period_exp = 0; 203 int ret; 204 205 if (!tnrdmd || !post_bit_err || !post_bit_count) 206 return -EINVAL; 207 208 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 209 return -EINVAL; 210 211 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 212 return -EINVAL; 213 214 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT) 215 return -EINVAL; 216 217 ret = tnrdmd->io->write_reg(tnrdmd->io, 218 CXD2880_IO_TGT_DMD, 219 0x00, 0x0d); 220 if (ret) 221 return ret; 222 223 ret = tnrdmd->io->read_regs(tnrdmd->io, 224 CXD2880_IO_TGT_DMD, 225 0x15, rdata, 3); 226 if (ret) 227 return ret; 228 229 if ((rdata[0] & 0x40) == 0) 230 return -EAGAIN; 231 232 *post_bit_err = ((rdata[0] & 0x3f) << 16) | (rdata[1] << 8) | rdata[2]; 233 234 ret = tnrdmd->io->write_reg(tnrdmd->io, 235 CXD2880_IO_TGT_DMD, 236 0x00, 0x10); 237 if (ret) 238 return ret; 239 240 ret = tnrdmd->io->read_regs(tnrdmd->io, 241 CXD2880_IO_TGT_DMD, 242 0x60, rdata, 1); 243 if (ret) 244 return ret; 245 246 period_exp = (rdata[0] & 0x1f); 247 248 if (period_exp <= 11 && (bit_error > (1U << period_exp) * 204 * 8)) 249 return -EAGAIN; 250 251 *post_bit_count = (1U << period_exp) * 204 * 8; 252 253 return 0; 254 } 255 256 static int cxd2880_post_bit_err_t2(struct cxd2880_tnrdmd *tnrdmd, 257 u32 *post_bit_err, 258 u32 *post_bit_count) 259 { 260 u32 period_exp = 0; 261 u32 n_bch = 0; 262 u8 data[3]; 263 enum cxd2880_dvbt2_plp_fec plp_fec_type = 264 CXD2880_DVBT2_FEC_LDPC_16K; 265 enum cxd2880_dvbt2_plp_code_rate plp_code_rate = 266 CXD2880_DVBT2_R1_2; 267 int ret; 268 static const u16 n_bch_bits_lookup[2][8] = { 269 {7200, 9720, 10800, 11880, 12600, 13320, 5400, 6480}, 270 {32400, 38880, 43200, 48600, 51840, 54000, 21600, 25920} 271 }; 272 273 if (!tnrdmd || !post_bit_err || !post_bit_count) 274 return -EINVAL; 275 276 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 277 return -EINVAL; 278 279 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 280 return -EINVAL; 281 282 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT2) 283 return -EINVAL; 284 285 ret = slvt_freeze_reg(tnrdmd); 286 if (ret) 287 return ret; 288 289 ret = tnrdmd->io->write_reg(tnrdmd->io, 290 CXD2880_IO_TGT_DMD, 291 0x00, 0x0b); 292 if (ret) { 293 slvt_unfreeze_reg(tnrdmd); 294 return ret; 295 } 296 297 ret = tnrdmd->io->read_regs(tnrdmd->io, 298 CXD2880_IO_TGT_DMD, 299 0x15, data, 3); 300 if (ret) { 301 slvt_unfreeze_reg(tnrdmd); 302 return ret; 303 } 304 305 if (!(data[0] & 0x40)) { 306 slvt_unfreeze_reg(tnrdmd); 307 return -EAGAIN; 308 } 309 310 *post_bit_err = 311 ((data[0] & 0x3f) << 16) | (data[1] << 8) | data[2]; 312 313 ret = tnrdmd->io->read_regs(tnrdmd->io, 314 CXD2880_IO_TGT_DMD, 315 0x9d, data, 1); 316 if (ret) { 317 slvt_unfreeze_reg(tnrdmd); 318 return ret; 319 } 320 321 plp_code_rate = 322 (enum cxd2880_dvbt2_plp_code_rate)(data[0] & 0x07); 323 324 ret = tnrdmd->io->read_regs(tnrdmd->io, 325 CXD2880_IO_TGT_DMD, 326 0xa0, data, 1); 327 if (ret) { 328 slvt_unfreeze_reg(tnrdmd); 329 return ret; 330 } 331 332 plp_fec_type = (enum cxd2880_dvbt2_plp_fec)(data[0] & 0x03); 333 334 slvt_unfreeze_reg(tnrdmd); 335 336 ret = tnrdmd->io->write_reg(tnrdmd->io, 337 CXD2880_IO_TGT_DMD, 338 0x00, 0x20); 339 if (ret) 340 return ret; 341 342 ret = tnrdmd->io->read_regs(tnrdmd->io, 343 CXD2880_IO_TGT_DMD, 344 0x72, data, 1); 345 if (ret) 346 return ret; 347 348 period_exp = data[0] & 0x0f; 349 350 if (plp_fec_type > CXD2880_DVBT2_FEC_LDPC_64K || 351 plp_code_rate > CXD2880_DVBT2_R2_5) 352 return -EAGAIN; 353 354 n_bch = n_bch_bits_lookup[plp_fec_type][plp_code_rate]; 355 356 if (*post_bit_err > ((1U << period_exp) * n_bch)) 357 return -EAGAIN; 358 359 *post_bit_count = (1U << period_exp) * n_bch; 360 361 return 0; 362 } 363 364 static int cxd2880_read_block_err_t(struct cxd2880_tnrdmd *tnrdmd, 365 u32 *block_err, 366 u32 *block_count) 367 { 368 u8 rdata[3]; 369 int ret; 370 371 if (!tnrdmd || !block_err || !block_count) 372 return -EINVAL; 373 374 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 375 return -EINVAL; 376 377 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 378 return -EINVAL; 379 380 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT) 381 return -EINVAL; 382 383 ret = tnrdmd->io->write_reg(tnrdmd->io, 384 CXD2880_IO_TGT_DMD, 385 0x00, 0x0d); 386 if (ret) 387 return ret; 388 389 ret = tnrdmd->io->read_regs(tnrdmd->io, 390 CXD2880_IO_TGT_DMD, 391 0x18, rdata, 3); 392 if (ret) 393 return ret; 394 395 if ((rdata[0] & 0x01) == 0) 396 return -EAGAIN; 397 398 *block_err = (rdata[1] << 8) | rdata[2]; 399 400 ret = tnrdmd->io->write_reg(tnrdmd->io, 401 CXD2880_IO_TGT_DMD, 402 0x00, 0x10); 403 if (ret) 404 return ret; 405 406 ret = tnrdmd->io->read_regs(tnrdmd->io, 407 CXD2880_IO_TGT_DMD, 408 0x5c, rdata, 1); 409 if (ret) 410 return ret; 411 412 *block_count = 1U << (rdata[0] & 0x0f); 413 414 if ((*block_count == 0) || (*block_err > *block_count)) 415 return -EAGAIN; 416 417 return 0; 418 } 419 420 static int cxd2880_read_block_err_t2(struct cxd2880_tnrdmd *tnrdmd, 421 u32 *block_err, 422 u32 *block_count) 423 { 424 u8 rdata[3]; 425 int ret; 426 427 if (!tnrdmd || !block_err || !block_count) 428 return -EINVAL; 429 430 if (tnrdmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 431 return -EINVAL; 432 433 if (tnrdmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 434 return -EINVAL; 435 if (tnrdmd->sys != CXD2880_DTV_SYS_DVBT2) 436 return -EINVAL; 437 438 ret = tnrdmd->io->write_reg(tnrdmd->io, 439 CXD2880_IO_TGT_DMD, 440 0x00, 0x0b); 441 if (ret) 442 return ret; 443 444 ret = tnrdmd->io->read_regs(tnrdmd->io, 445 CXD2880_IO_TGT_DMD, 446 0x18, rdata, 3); 447 if (ret) 448 return ret; 449 450 if ((rdata[0] & 0x01) == 0) 451 return -EAGAIN; 452 453 *block_err = (rdata[1] << 8) | rdata[2]; 454 455 ret = tnrdmd->io->write_reg(tnrdmd->io, 456 CXD2880_IO_TGT_DMD, 457 0x00, 0x24); 458 if (ret) 459 return ret; 460 461 ret = tnrdmd->io->read_regs(tnrdmd->io, 462 CXD2880_IO_TGT_DMD, 463 0xdc, rdata, 1); 464 if (ret) 465 return ret; 466 467 *block_count = 1U << (rdata[0] & 0x0f); 468 469 if ((*block_count == 0) || (*block_err > *block_count)) 470 return -EAGAIN; 471 472 return 0; 473 } 474 475 static void cxd2880_release(struct dvb_frontend *fe) 476 { 477 struct cxd2880_priv *priv = NULL; 478 479 if (!fe) { 480 pr_err("invalid arg.\n"); 481 return; 482 } 483 priv = fe->demodulator_priv; 484 kfree(priv); 485 } 486 487 static int cxd2880_init(struct dvb_frontend *fe) 488 { 489 int ret; 490 struct cxd2880_priv *priv = NULL; 491 struct cxd2880_tnrdmd_create_param create_param; 492 493 if (!fe) { 494 pr_err("invalid arg.\n"); 495 return -EINVAL; 496 } 497 498 priv = fe->demodulator_priv; 499 500 create_param.ts_output_if = CXD2880_TNRDMD_TSOUT_IF_SPI; 501 create_param.xtal_share_type = CXD2880_TNRDMD_XTAL_SHARE_NONE; 502 create_param.en_internal_ldo = 1; 503 create_param.xosc_cap = 18; 504 create_param.xosc_i = 8; 505 create_param.stationary_use = 1; 506 507 mutex_lock(priv->spi_mutex); 508 if (priv->tnrdmd.io != &priv->regio) { 509 ret = cxd2880_tnrdmd_create(&priv->tnrdmd, 510 &priv->regio, &create_param); 511 if (ret) { 512 mutex_unlock(priv->spi_mutex); 513 pr_info("cxd2880 tnrdmd create failed %d\n", ret); 514 return ret; 515 } 516 } 517 ret = cxd2880_integ_init(&priv->tnrdmd); 518 if (ret) { 519 mutex_unlock(priv->spi_mutex); 520 pr_err("cxd2880 integ init failed %d\n", ret); 521 return ret; 522 } 523 524 ret = cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 525 CXD2880_TNRDMD_CFG_TSPIN_CURRENT, 526 0x00); 527 if (ret) { 528 mutex_unlock(priv->spi_mutex); 529 pr_err("cxd2880 set config failed %d\n", ret); 530 return ret; 531 } 532 mutex_unlock(priv->spi_mutex); 533 534 pr_debug("OK.\n"); 535 536 return ret; 537 } 538 539 static int cxd2880_sleep(struct dvb_frontend *fe) 540 { 541 int ret; 542 struct cxd2880_priv *priv = NULL; 543 544 if (!fe) { 545 pr_err("invalid arg\n"); 546 return -EINVAL; 547 } 548 549 priv = fe->demodulator_priv; 550 551 mutex_lock(priv->spi_mutex); 552 ret = cxd2880_tnrdmd_sleep(&priv->tnrdmd); 553 mutex_unlock(priv->spi_mutex); 554 555 pr_debug("tnrdmd_sleep ret %d\n", ret); 556 557 return ret; 558 } 559 560 static int cxd2880_read_signal_strength(struct dvb_frontend *fe, 561 u16 *strength) 562 { 563 int ret; 564 struct cxd2880_priv *priv = NULL; 565 struct dtv_frontend_properties *c = NULL; 566 int level = 0; 567 568 if (!fe || !strength) { 569 pr_err("invalid arg\n"); 570 return -EINVAL; 571 } 572 573 priv = fe->demodulator_priv; 574 c = &fe->dtv_property_cache; 575 576 mutex_lock(priv->spi_mutex); 577 if (c->delivery_system == SYS_DVBT || 578 c->delivery_system == SYS_DVBT2) { 579 ret = cxd2880_tnrdmd_mon_rf_lvl(&priv->tnrdmd, &level); 580 } else { 581 pr_debug("invalid system\n"); 582 mutex_unlock(priv->spi_mutex); 583 return -EINVAL; 584 } 585 mutex_unlock(priv->spi_mutex); 586 587 level /= 125; 588 /* 589 * level should be between -105dBm and -30dBm. 590 * E.g. they should be between: 591 * -105000/125 = -840 and -30000/125 = -240 592 */ 593 level = clamp(level, -840, -240); 594 /* scale value to 0x0000-0xffff */ 595 *strength = ((level + 840) * 0xffff) / (-240 + 840); 596 597 if (ret) 598 pr_debug("ret = %d\n", ret); 599 600 return ret; 601 } 602 603 static int cxd2880_read_snr(struct dvb_frontend *fe, u16 *snr) 604 { 605 int ret; 606 int snrvalue = 0; 607 struct cxd2880_priv *priv = NULL; 608 struct dtv_frontend_properties *c = NULL; 609 610 if (!fe || !snr) { 611 pr_err("invalid arg\n"); 612 return -EINVAL; 613 } 614 615 priv = fe->demodulator_priv; 616 c = &fe->dtv_property_cache; 617 618 mutex_lock(priv->spi_mutex); 619 if (c->delivery_system == SYS_DVBT) { 620 ret = cxd2880_tnrdmd_dvbt_mon_snr(&priv->tnrdmd, 621 &snrvalue); 622 } else if (c->delivery_system == SYS_DVBT2) { 623 ret = cxd2880_tnrdmd_dvbt2_mon_snr(&priv->tnrdmd, 624 &snrvalue); 625 } else { 626 pr_err("invalid system\n"); 627 mutex_unlock(priv->spi_mutex); 628 return -EINVAL; 629 } 630 mutex_unlock(priv->spi_mutex); 631 632 if (snrvalue < 0) 633 snrvalue = 0; 634 *snr = snrvalue; 635 636 if (ret) 637 pr_debug("ret = %d\n", ret); 638 639 return ret; 640 } 641 642 static int cxd2880_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 643 { 644 int ret; 645 struct cxd2880_priv *priv = NULL; 646 struct dtv_frontend_properties *c = NULL; 647 648 if (!fe || !ucblocks) { 649 pr_err("invalid arg\n"); 650 return -EINVAL; 651 } 652 653 priv = fe->demodulator_priv; 654 c = &fe->dtv_property_cache; 655 656 mutex_lock(priv->spi_mutex); 657 if (c->delivery_system == SYS_DVBT) { 658 ret = cxd2880_tnrdmd_dvbt_mon_packet_error_number(&priv->tnrdmd, 659 ucblocks); 660 } else if (c->delivery_system == SYS_DVBT2) { 661 ret = cxd2880_tnrdmd_dvbt2_mon_packet_error_number(&priv->tnrdmd, 662 ucblocks); 663 } else { 664 pr_err("invalid system\n"); 665 mutex_unlock(priv->spi_mutex); 666 return -EINVAL; 667 } 668 mutex_unlock(priv->spi_mutex); 669 670 if (ret) 671 pr_debug("ret = %d\n", ret); 672 673 return ret; 674 } 675 676 static int cxd2880_read_ber(struct dvb_frontend *fe, u32 *ber) 677 { 678 *ber = 0; 679 680 return 0; 681 } 682 683 static int cxd2880_set_ber_per_period_t(struct dvb_frontend *fe) 684 { 685 int ret; 686 struct cxd2880_priv *priv; 687 struct cxd2880_dvbt_tpsinfo info; 688 enum cxd2880_dtv_bandwidth bw; 689 u32 pre_ber_rate = 0; 690 u32 post_ber_rate = 0; 691 u32 ucblock_rate = 0; 692 u32 mes_exp = 0; 693 static const int cr_table[5] = {31500, 42000, 47250, 52500, 55125}; 694 static const int denominator_tbl[4] = {125664, 129472, 137088, 152320}; 695 696 if (!fe) { 697 pr_err("invalid arg\n"); 698 return -EINVAL; 699 } 700 701 priv = fe->demodulator_priv; 702 bw = priv->dvbt_tune_param.bandwidth; 703 704 ret = cxd2880_tnrdmd_dvbt_mon_tps_info(&priv->tnrdmd, 705 &info); 706 if (ret) { 707 pr_err("tps monitor error ret = %d\n", ret); 708 info.hierarchy = CXD2880_DVBT_HIERARCHY_NON; 709 info.constellation = CXD2880_DVBT_CONSTELLATION_QPSK; 710 info.guard = CXD2880_DVBT_GUARD_1_4; 711 info.rate_hp = CXD2880_DVBT_CODERATE_1_2; 712 info.rate_lp = CXD2880_DVBT_CODERATE_1_2; 713 } 714 715 if (info.hierarchy == CXD2880_DVBT_HIERARCHY_NON) { 716 pre_ber_rate = 63000000 * bw * (info.constellation * 2 + 2) / 717 denominator_tbl[info.guard]; 718 719 post_ber_rate = 1000 * cr_table[info.rate_hp] * bw * 720 (info.constellation * 2 + 2) / 721 denominator_tbl[info.guard]; 722 723 ucblock_rate = 875 * cr_table[info.rate_hp] * bw * 724 (info.constellation * 2 + 2) / 725 denominator_tbl[info.guard]; 726 } else { 727 u8 data = 0; 728 struct cxd2880_tnrdmd *tnrdmd = &priv->tnrdmd; 729 730 ret = tnrdmd->io->write_reg(tnrdmd->io, 731 CXD2880_IO_TGT_DMD, 732 0x00, 0x10); 733 if (!ret) { 734 ret = tnrdmd->io->read_regs(tnrdmd->io, 735 CXD2880_IO_TGT_DMD, 736 0x67, &data, 1); 737 if (ret) 738 data = 0x00; 739 } else { 740 data = 0x00; 741 } 742 743 if (data & 0x01) { /* Low priority */ 744 pre_ber_rate = 745 63000000 * bw * (info.constellation * 2 + 2) / 746 denominator_tbl[info.guard]; 747 748 post_ber_rate = 1000 * cr_table[info.rate_lp] * bw * 749 (info.constellation * 2 + 2) / 750 denominator_tbl[info.guard]; 751 752 ucblock_rate = (1000 * 7 / 8) * cr_table[info.rate_lp] * 753 bw * (info.constellation * 2 + 2) / 754 denominator_tbl[info.guard]; 755 } else { /* High priority */ 756 pre_ber_rate = 757 63000000 * bw * 2 / denominator_tbl[info.guard]; 758 759 post_ber_rate = 1000 * cr_table[info.rate_hp] * bw * 2 / 760 denominator_tbl[info.guard]; 761 762 ucblock_rate = (1000 * 7 / 8) * cr_table[info.rate_hp] * 763 bw * 2 / denominator_tbl[info.guard]; 764 } 765 } 766 767 mes_exp = pre_ber_rate < 8192 ? 8 : intlog2(pre_ber_rate) >> 24; 768 priv->pre_ber_interval = 769 ((1U << mes_exp) * 1000 + (pre_ber_rate / 2)) / 770 pre_ber_rate; 771 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 772 CXD2880_TNRDMD_CFG_DVBT_VBER_PERIOD, 773 mes_exp == 8 ? 0 : mes_exp - 12); 774 775 mes_exp = intlog2(post_ber_rate) >> 24; 776 priv->post_ber_interval = 777 ((1U << mes_exp) * 1000 + (post_ber_rate / 2)) / 778 post_ber_rate; 779 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 780 CXD2880_TNRDMD_CFG_DVBT_BERN_PERIOD, 781 mes_exp); 782 783 mes_exp = intlog2(ucblock_rate) >> 24; 784 priv->ucblock_interval = 785 ((1U << mes_exp) * 1000 + (ucblock_rate / 2)) / 786 ucblock_rate; 787 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 788 CXD2880_TNRDMD_CFG_DVBT_PER_MES, 789 mes_exp); 790 791 return 0; 792 } 793 794 static int cxd2880_set_ber_per_period_t2(struct dvb_frontend *fe) 795 { 796 int ret; 797 struct cxd2880_priv *priv; 798 struct cxd2880_dvbt2_l1pre l1pre; 799 struct cxd2880_dvbt2_l1post l1post; 800 struct cxd2880_dvbt2_plp plp; 801 struct cxd2880_dvbt2_bbheader bbheader; 802 enum cxd2880_dtv_bandwidth bw = CXD2880_DTV_BW_1_7_MHZ; 803 u32 pre_ber_rate = 0; 804 u32 post_ber_rate = 0; 805 u32 ucblock_rate = 0; 806 u32 mes_exp = 0; 807 u32 term_a = 0; 808 u32 term_b = 0; 809 u32 denominator = 0; 810 static const u32 gi_tbl[7] = {32, 64, 128, 256, 8, 152, 76}; 811 static const u8 n_tbl[6] = {8, 2, 4, 16, 1, 1}; 812 static const u8 mode_tbl[6] = {2, 8, 4, 1, 16, 32}; 813 static const u32 kbch_tbl[2][8] = { 814 {6952, 9472, 10552, 11632, 12352, 13072, 5152, 6232}, 815 {32128, 38608, 42960, 48328, 51568, 53760, 0, 0} 816 }; 817 818 if (!fe) { 819 pr_err("invalid arg\n"); 820 return -EINVAL; 821 } 822 823 priv = fe->demodulator_priv; 824 bw = priv->dvbt2_tune_param.bandwidth; 825 826 ret = cxd2880_tnrdmd_dvbt2_mon_l1_pre(&priv->tnrdmd, &l1pre); 827 if (ret) { 828 pr_info("l1 pre error\n"); 829 goto error_ber_setting; 830 } 831 832 ret = cxd2880_tnrdmd_dvbt2_mon_active_plp(&priv->tnrdmd, 833 CXD2880_DVBT2_PLP_DATA, &plp); 834 if (ret) { 835 pr_info("plp info error\n"); 836 goto error_ber_setting; 837 } 838 839 ret = cxd2880_tnrdmd_dvbt2_mon_l1_post(&priv->tnrdmd, &l1post); 840 if (ret) { 841 pr_info("l1 post error\n"); 842 goto error_ber_setting; 843 } 844 845 term_a = 846 (mode_tbl[l1pre.fft_mode] * (1024 + gi_tbl[l1pre.gi])) * 847 (l1pre.num_symbols + n_tbl[l1pre.fft_mode]) + 2048; 848 849 if (l1pre.mixed && l1post.fef_intvl) { 850 term_b = (l1post.fef_length + (l1post.fef_intvl / 2)) / 851 l1post.fef_intvl; 852 } else { 853 term_b = 0; 854 } 855 856 switch (bw) { 857 case CXD2880_DTV_BW_1_7_MHZ: 858 denominator = ((term_a + term_b) * 71 + (131 / 2)) / 131; 859 break; 860 case CXD2880_DTV_BW_5_MHZ: 861 denominator = ((term_a + term_b) * 7 + 20) / 40; 862 break; 863 case CXD2880_DTV_BW_6_MHZ: 864 denominator = ((term_a + term_b) * 7 + 24) / 48; 865 break; 866 case CXD2880_DTV_BW_7_MHZ: 867 denominator = ((term_a + term_b) + 4) / 8; 868 break; 869 case CXD2880_DTV_BW_8_MHZ: 870 default: 871 denominator = ((term_a + term_b) * 7 + 32) / 64; 872 break; 873 } 874 875 if (plp.til_type && plp.til_len) { 876 pre_ber_rate = 877 (plp.num_blocks_max * 1000000 + (denominator / 2)) / 878 denominator; 879 pre_ber_rate = (pre_ber_rate + (plp.til_len / 2)) / 880 plp.til_len; 881 } else { 882 pre_ber_rate = 883 (plp.num_blocks_max * 1000000 + (denominator / 2)) / 884 denominator; 885 } 886 887 post_ber_rate = pre_ber_rate; 888 889 mes_exp = intlog2(pre_ber_rate) >> 24; 890 priv->pre_ber_interval = 891 ((1U << mes_exp) * 1000 + (pre_ber_rate / 2)) / 892 pre_ber_rate; 893 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 894 CXD2880_TNRDMD_CFG_DVBT2_LBER_MES, 895 mes_exp); 896 897 mes_exp = intlog2(post_ber_rate) >> 24; 898 priv->post_ber_interval = 899 ((1U << mes_exp) * 1000 + (post_ber_rate / 2)) / 900 post_ber_rate; 901 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 902 CXD2880_TNRDMD_CFG_DVBT2_BBER_MES, 903 mes_exp); 904 905 ret = cxd2880_tnrdmd_dvbt2_mon_bbheader(&priv->tnrdmd, 906 CXD2880_DVBT2_PLP_DATA, 907 &bbheader); 908 if (ret) { 909 pr_info("bb header error\n"); 910 goto error_ucblock_setting; 911 } 912 913 if (bbheader.plp_mode == CXD2880_DVBT2_PLP_MODE_NM) { 914 if (!bbheader.issy_indicator) { 915 ucblock_rate = 916 (pre_ber_rate * kbch_tbl[plp.fec][plp.plp_cr] + 917 752) / 1504; 918 } else { 919 ucblock_rate = 920 (pre_ber_rate * kbch_tbl[plp.fec][plp.plp_cr] + 921 764) / 1528; 922 } 923 } else if (bbheader.plp_mode == CXD2880_DVBT2_PLP_MODE_HEM) { 924 ucblock_rate = 925 (pre_ber_rate * kbch_tbl[plp.fec][plp.plp_cr] + 748) / 926 1496; 927 } else { 928 pr_info("plp mode is not Normal or HEM\n"); 929 goto error_ucblock_setting; 930 } 931 932 mes_exp = intlog2(ucblock_rate) >> 24; 933 priv->ucblock_interval = 934 ((1U << mes_exp) * 1000 + (ucblock_rate / 2)) / 935 ucblock_rate; 936 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 937 CXD2880_TNRDMD_CFG_DVBT2_PER_MES, 938 mes_exp); 939 940 return 0; 941 942 error_ber_setting: 943 priv->pre_ber_interval = 1000; 944 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 945 CXD2880_TNRDMD_CFG_DVBT2_LBER_MES, 0); 946 947 priv->post_ber_interval = 1000; 948 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 949 CXD2880_TNRDMD_CFG_DVBT2_BBER_MES, 0); 950 951 error_ucblock_setting: 952 priv->ucblock_interval = 1000; 953 cxd2880_tnrdmd_set_cfg(&priv->tnrdmd, 954 CXD2880_TNRDMD_CFG_DVBT2_PER_MES, 8); 955 956 return 0; 957 } 958 959 static int cxd2880_dvbt_tune(struct cxd2880_tnrdmd *tnr_dmd, 960 struct cxd2880_dvbt_tune_param 961 *tune_param) 962 { 963 int ret; 964 965 if (!tnr_dmd || !tune_param) 966 return -EINVAL; 967 968 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 969 return -EINVAL; 970 971 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP && 972 tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 973 return -EINVAL; 974 975 atomic_set(&tnr_dmd->cancel, 0); 976 977 if (tune_param->bandwidth != CXD2880_DTV_BW_5_MHZ && 978 tune_param->bandwidth != CXD2880_DTV_BW_6_MHZ && 979 tune_param->bandwidth != CXD2880_DTV_BW_7_MHZ && 980 tune_param->bandwidth != CXD2880_DTV_BW_8_MHZ) { 981 return -ENOTTY; 982 } 983 984 ret = cxd2880_tnrdmd_dvbt_tune1(tnr_dmd, tune_param); 985 if (ret) 986 return ret; 987 988 usleep_range(CXD2880_TNRDMD_WAIT_AGC_STABLE * 10000, 989 CXD2880_TNRDMD_WAIT_AGC_STABLE * 10000 + 1000); 990 991 return cxd2880_tnrdmd_dvbt_tune2(tnr_dmd, tune_param); 992 } 993 994 static int cxd2880_dvbt2_tune(struct cxd2880_tnrdmd *tnr_dmd, 995 struct cxd2880_dvbt2_tune_param 996 *tune_param) 997 { 998 int ret; 999 1000 if (!tnr_dmd || !tune_param) 1001 return -EINVAL; 1002 1003 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB) 1004 return -EINVAL; 1005 1006 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP && 1007 tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE) 1008 return -EINVAL; 1009 1010 atomic_set(&tnr_dmd->cancel, 0); 1011 1012 if (tune_param->bandwidth != CXD2880_DTV_BW_1_7_MHZ && 1013 tune_param->bandwidth != CXD2880_DTV_BW_5_MHZ && 1014 tune_param->bandwidth != CXD2880_DTV_BW_6_MHZ && 1015 tune_param->bandwidth != CXD2880_DTV_BW_7_MHZ && 1016 tune_param->bandwidth != CXD2880_DTV_BW_8_MHZ) { 1017 return -ENOTTY; 1018 } 1019 1020 if (tune_param->profile != CXD2880_DVBT2_PROFILE_BASE && 1021 tune_param->profile != CXD2880_DVBT2_PROFILE_LITE) 1022 return -EINVAL; 1023 1024 ret = cxd2880_tnrdmd_dvbt2_tune1(tnr_dmd, tune_param); 1025 if (ret) 1026 return ret; 1027 1028 usleep_range(CXD2880_TNRDMD_WAIT_AGC_STABLE * 10000, 1029 CXD2880_TNRDMD_WAIT_AGC_STABLE * 10000 + 1000); 1030 1031 return cxd2880_tnrdmd_dvbt2_tune2(tnr_dmd, tune_param); 1032 } 1033 1034 static int cxd2880_set_frontend(struct dvb_frontend *fe) 1035 { 1036 int ret; 1037 struct dtv_frontend_properties *c; 1038 struct cxd2880_priv *priv; 1039 enum cxd2880_dtv_bandwidth bw = CXD2880_DTV_BW_1_7_MHZ; 1040 1041 if (!fe) { 1042 pr_err("invalid arg\n"); 1043 return -EINVAL; 1044 } 1045 1046 priv = fe->demodulator_priv; 1047 c = &fe->dtv_property_cache; 1048 1049 c->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1050 c->pre_bit_error.stat[0].uvalue = 0; 1051 c->pre_bit_error.len = 1; 1052 c->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1053 c->pre_bit_count.stat[0].uvalue = 0; 1054 c->pre_bit_count.len = 1; 1055 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1056 c->post_bit_error.stat[0].uvalue = 0; 1057 c->post_bit_error.len = 1; 1058 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1059 c->post_bit_count.stat[0].uvalue = 0; 1060 c->post_bit_count.len = 1; 1061 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1062 c->block_error.stat[0].uvalue = 0; 1063 c->block_error.len = 1; 1064 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1065 c->block_count.stat[0].uvalue = 0; 1066 c->block_count.len = 1; 1067 1068 switch (c->bandwidth_hz) { 1069 case 1712000: 1070 bw = CXD2880_DTV_BW_1_7_MHZ; 1071 break; 1072 case 5000000: 1073 bw = CXD2880_DTV_BW_5_MHZ; 1074 break; 1075 case 6000000: 1076 bw = CXD2880_DTV_BW_6_MHZ; 1077 break; 1078 case 7000000: 1079 bw = CXD2880_DTV_BW_7_MHZ; 1080 break; 1081 case 8000000: 1082 bw = CXD2880_DTV_BW_8_MHZ; 1083 break; 1084 default: 1085 return -EINVAL; 1086 } 1087 1088 priv->s = 0; 1089 1090 pr_info("sys:%d freq:%d bw:%d\n", 1091 c->delivery_system, c->frequency, bw); 1092 mutex_lock(priv->spi_mutex); 1093 if (c->delivery_system == SYS_DVBT) { 1094 priv->tnrdmd.sys = CXD2880_DTV_SYS_DVBT; 1095 priv->dvbt_tune_param.center_freq_khz = c->frequency / 1000; 1096 priv->dvbt_tune_param.bandwidth = bw; 1097 priv->dvbt_tune_param.profile = CXD2880_DVBT_PROFILE_HP; 1098 ret = cxd2880_dvbt_tune(&priv->tnrdmd, 1099 &priv->dvbt_tune_param); 1100 } else if (c->delivery_system == SYS_DVBT2) { 1101 priv->tnrdmd.sys = CXD2880_DTV_SYS_DVBT2; 1102 priv->dvbt2_tune_param.center_freq_khz = c->frequency / 1000; 1103 priv->dvbt2_tune_param.bandwidth = bw; 1104 priv->dvbt2_tune_param.data_plp_id = (u16)c->stream_id; 1105 priv->dvbt2_tune_param.profile = CXD2880_DVBT2_PROFILE_BASE; 1106 ret = cxd2880_dvbt2_tune(&priv->tnrdmd, 1107 &priv->dvbt2_tune_param); 1108 } else { 1109 pr_err("invalid system\n"); 1110 mutex_unlock(priv->spi_mutex); 1111 return -EINVAL; 1112 } 1113 mutex_unlock(priv->spi_mutex); 1114 1115 pr_info("tune result %d\n", ret); 1116 1117 return ret; 1118 } 1119 1120 static int cxd2880_get_stats(struct dvb_frontend *fe, 1121 enum fe_status status) 1122 { 1123 struct cxd2880_priv *priv = NULL; 1124 struct dtv_frontend_properties *c = NULL; 1125 u32 pre_bit_err = 0, pre_bit_count = 0; 1126 u32 post_bit_err = 0, post_bit_count = 0; 1127 u32 block_err = 0, block_count = 0; 1128 int ret; 1129 1130 if (!fe) { 1131 pr_err("invalid arg\n"); 1132 return -EINVAL; 1133 } 1134 1135 priv = fe->demodulator_priv; 1136 c = &fe->dtv_property_cache; 1137 1138 if (!(status & FE_HAS_LOCK) || !(status & FE_HAS_CARRIER)) { 1139 c->pre_bit_error.len = 1; 1140 c->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1141 c->pre_bit_count.len = 1; 1142 c->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1143 c->post_bit_error.len = 1; 1144 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1145 c->post_bit_count.len = 1; 1146 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1147 c->block_error.len = 1; 1148 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1149 c->block_count.len = 1; 1150 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1151 1152 return 0; 1153 } 1154 1155 if (time_after(jiffies, priv->pre_ber_update)) { 1156 priv->pre_ber_update = 1157 jiffies + msecs_to_jiffies(priv->pre_ber_interval); 1158 if (c->delivery_system == SYS_DVBT) { 1159 mutex_lock(priv->spi_mutex); 1160 ret = cxd2880_pre_bit_err_t(&priv->tnrdmd, 1161 &pre_bit_err, 1162 &pre_bit_count); 1163 mutex_unlock(priv->spi_mutex); 1164 } else if (c->delivery_system == SYS_DVBT2) { 1165 mutex_lock(priv->spi_mutex); 1166 ret = cxd2880_pre_bit_err_t2(&priv->tnrdmd, 1167 &pre_bit_err, 1168 &pre_bit_count); 1169 mutex_unlock(priv->spi_mutex); 1170 } else { 1171 return -EINVAL; 1172 } 1173 1174 if (!ret) { 1175 c->pre_bit_error.len = 1; 1176 c->pre_bit_error.stat[0].scale = FE_SCALE_COUNTER; 1177 c->pre_bit_error.stat[0].uvalue += pre_bit_err; 1178 c->pre_bit_count.len = 1; 1179 c->pre_bit_count.stat[0].scale = FE_SCALE_COUNTER; 1180 c->pre_bit_count.stat[0].uvalue += pre_bit_count; 1181 } else { 1182 c->pre_bit_error.len = 1; 1183 c->pre_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1184 c->pre_bit_count.len = 1; 1185 c->pre_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1186 pr_debug("pre_bit_error_t failed %d\n", ret); 1187 } 1188 } 1189 1190 if (time_after(jiffies, priv->post_ber_update)) { 1191 priv->post_ber_update = 1192 jiffies + msecs_to_jiffies(priv->post_ber_interval); 1193 if (c->delivery_system == SYS_DVBT) { 1194 mutex_lock(priv->spi_mutex); 1195 ret = cxd2880_post_bit_err_t(&priv->tnrdmd, 1196 &post_bit_err, 1197 &post_bit_count); 1198 mutex_unlock(priv->spi_mutex); 1199 } else if (c->delivery_system == SYS_DVBT2) { 1200 mutex_lock(priv->spi_mutex); 1201 ret = cxd2880_post_bit_err_t2(&priv->tnrdmd, 1202 &post_bit_err, 1203 &post_bit_count); 1204 mutex_unlock(priv->spi_mutex); 1205 } else { 1206 return -EINVAL; 1207 } 1208 1209 if (!ret) { 1210 c->post_bit_error.len = 1; 1211 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER; 1212 c->post_bit_error.stat[0].uvalue += post_bit_err; 1213 c->post_bit_count.len = 1; 1214 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER; 1215 c->post_bit_count.stat[0].uvalue += post_bit_count; 1216 } else { 1217 c->post_bit_error.len = 1; 1218 c->post_bit_error.stat[0].scale = 1219 FE_SCALE_NOT_AVAILABLE; 1220 c->post_bit_count.len = 1; 1221 c->post_bit_count.stat[0].scale = 1222 FE_SCALE_NOT_AVAILABLE; 1223 pr_debug("post_bit_err_t %d\n", ret); 1224 } 1225 } 1226 1227 if (time_after(jiffies, priv->ucblock_update)) { 1228 priv->ucblock_update = 1229 jiffies + msecs_to_jiffies(priv->ucblock_interval); 1230 if (c->delivery_system == SYS_DVBT) { 1231 mutex_lock(priv->spi_mutex); 1232 ret = cxd2880_read_block_err_t(&priv->tnrdmd, 1233 &block_err, 1234 &block_count); 1235 mutex_unlock(priv->spi_mutex); 1236 } else if (c->delivery_system == SYS_DVBT2) { 1237 mutex_lock(priv->spi_mutex); 1238 ret = cxd2880_read_block_err_t2(&priv->tnrdmd, 1239 &block_err, 1240 &block_count); 1241 mutex_unlock(priv->spi_mutex); 1242 } else { 1243 return -EINVAL; 1244 } 1245 if (!ret) { 1246 c->block_error.len = 1; 1247 c->block_error.stat[0].scale = FE_SCALE_COUNTER; 1248 c->block_error.stat[0].uvalue += block_err; 1249 c->block_count.len = 1; 1250 c->block_count.stat[0].scale = FE_SCALE_COUNTER; 1251 c->block_count.stat[0].uvalue += block_count; 1252 } else { 1253 c->block_error.len = 1; 1254 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1255 c->block_count.len = 1; 1256 c->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1257 pr_debug("read_block_err_t %d\n", ret); 1258 } 1259 } 1260 1261 return 0; 1262 } 1263 1264 static int cxd2880_check_l1post_plp(struct dvb_frontend *fe) 1265 { 1266 u8 valid = 0; 1267 u8 plp_not_found; 1268 int ret; 1269 struct cxd2880_priv *priv = NULL; 1270 1271 if (!fe) { 1272 pr_err("invalid arg\n"); 1273 return -EINVAL; 1274 } 1275 1276 priv = fe->demodulator_priv; 1277 1278 ret = cxd2880_tnrdmd_dvbt2_check_l1post_valid(&priv->tnrdmd, 1279 &valid); 1280 if (ret) 1281 return ret; 1282 1283 if (!valid) 1284 return -EAGAIN; 1285 1286 ret = cxd2880_tnrdmd_dvbt2_mon_data_plp_error(&priv->tnrdmd, 1287 &plp_not_found); 1288 if (ret) 1289 return ret; 1290 1291 if (plp_not_found) { 1292 priv->dvbt2_tune_param.tune_info = 1293 CXD2880_TNRDMD_DVBT2_TUNE_INFO_INVALID_PLP_ID; 1294 } else { 1295 priv->dvbt2_tune_param.tune_info = 1296 CXD2880_TNRDMD_DVBT2_TUNE_INFO_OK; 1297 } 1298 1299 return 0; 1300 } 1301 1302 static int cxd2880_read_status(struct dvb_frontend *fe, 1303 enum fe_status *status) 1304 { 1305 int ret; 1306 u8 sync = 0; 1307 u8 lock = 0; 1308 u8 unlock = 0; 1309 struct cxd2880_priv *priv = NULL; 1310 struct dtv_frontend_properties *c = NULL; 1311 1312 if (!fe || !status) { 1313 pr_err("invalid arg\n"); 1314 return -EINVAL; 1315 } 1316 1317 priv = fe->demodulator_priv; 1318 c = &fe->dtv_property_cache; 1319 *status = 0; 1320 1321 if (priv->tnrdmd.state == CXD2880_TNRDMD_STATE_ACTIVE) { 1322 mutex_lock(priv->spi_mutex); 1323 if (c->delivery_system == SYS_DVBT) { 1324 ret = cxd2880_tnrdmd_dvbt_mon_sync_stat(&priv->tnrdmd, 1325 &sync, 1326 &lock, 1327 &unlock); 1328 } else if (c->delivery_system == SYS_DVBT2) { 1329 ret = cxd2880_tnrdmd_dvbt2_mon_sync_stat(&priv->tnrdmd, 1330 &sync, 1331 &lock, 1332 &unlock); 1333 } else { 1334 pr_err("invalid system"); 1335 mutex_unlock(priv->spi_mutex); 1336 return -EINVAL; 1337 } 1338 1339 mutex_unlock(priv->spi_mutex); 1340 if (ret) { 1341 pr_err("failed. sys = %d\n", priv->tnrdmd.sys); 1342 return ret; 1343 } 1344 1345 if (sync == 6) { 1346 *status = FE_HAS_SIGNAL | 1347 FE_HAS_CARRIER; 1348 } 1349 if (lock) 1350 *status |= FE_HAS_VITERBI | 1351 FE_HAS_SYNC | 1352 FE_HAS_LOCK; 1353 } 1354 1355 pr_debug("status %d\n", *status); 1356 1357 if (priv->s == 0 && (*status & FE_HAS_LOCK) && 1358 (*status & FE_HAS_CARRIER)) { 1359 mutex_lock(priv->spi_mutex); 1360 if (c->delivery_system == SYS_DVBT) { 1361 ret = cxd2880_set_ber_per_period_t(fe); 1362 priv->s = *status; 1363 } else if (c->delivery_system == SYS_DVBT2) { 1364 ret = cxd2880_check_l1post_plp(fe); 1365 if (!ret) { 1366 ret = cxd2880_set_ber_per_period_t2(fe); 1367 priv->s = *status; 1368 } 1369 } else { 1370 pr_err("invalid system\n"); 1371 mutex_unlock(priv->spi_mutex); 1372 return -EINVAL; 1373 } 1374 mutex_unlock(priv->spi_mutex); 1375 } 1376 1377 cxd2880_get_stats(fe, *status); 1378 return 0; 1379 } 1380 1381 static int cxd2880_tune(struct dvb_frontend *fe, 1382 bool retune, 1383 unsigned int mode_flags, 1384 unsigned int *delay, 1385 enum fe_status *status) 1386 { 1387 int ret; 1388 1389 if (!fe || !delay || !status) { 1390 pr_err("invalid arg."); 1391 return -EINVAL; 1392 } 1393 1394 if (retune) { 1395 ret = cxd2880_set_frontend(fe); 1396 if (ret) { 1397 pr_err("cxd2880_set_frontend failed %d\n", ret); 1398 return ret; 1399 } 1400 } 1401 1402 *delay = HZ / 5; 1403 1404 return cxd2880_read_status(fe, status); 1405 } 1406 1407 static int cxd2880_get_frontend_t(struct dvb_frontend *fe, 1408 struct dtv_frontend_properties *c) 1409 { 1410 int ret; 1411 struct cxd2880_priv *priv = NULL; 1412 enum cxd2880_dvbt_mode mode = CXD2880_DVBT_MODE_2K; 1413 enum cxd2880_dvbt_guard guard = CXD2880_DVBT_GUARD_1_32; 1414 struct cxd2880_dvbt_tpsinfo tps; 1415 enum cxd2880_tnrdmd_spectrum_sense sense; 1416 u16 snr = 0; 1417 int strength = 0; 1418 1419 if (!fe || !c) { 1420 pr_err("invalid arg\n"); 1421 return -EINVAL; 1422 } 1423 1424 priv = fe->demodulator_priv; 1425 1426 mutex_lock(priv->spi_mutex); 1427 ret = cxd2880_tnrdmd_dvbt_mon_mode_guard(&priv->tnrdmd, 1428 &mode, &guard); 1429 mutex_unlock(priv->spi_mutex); 1430 if (!ret) { 1431 switch (mode) { 1432 case CXD2880_DVBT_MODE_2K: 1433 c->transmission_mode = TRANSMISSION_MODE_2K; 1434 break; 1435 case CXD2880_DVBT_MODE_8K: 1436 c->transmission_mode = TRANSMISSION_MODE_8K; 1437 break; 1438 default: 1439 c->transmission_mode = TRANSMISSION_MODE_2K; 1440 pr_debug("transmission mode is invalid %d\n", mode); 1441 break; 1442 } 1443 switch (guard) { 1444 case CXD2880_DVBT_GUARD_1_32: 1445 c->guard_interval = GUARD_INTERVAL_1_32; 1446 break; 1447 case CXD2880_DVBT_GUARD_1_16: 1448 c->guard_interval = GUARD_INTERVAL_1_16; 1449 break; 1450 case CXD2880_DVBT_GUARD_1_8: 1451 c->guard_interval = GUARD_INTERVAL_1_8; 1452 break; 1453 case CXD2880_DVBT_GUARD_1_4: 1454 c->guard_interval = GUARD_INTERVAL_1_4; 1455 break; 1456 default: 1457 c->guard_interval = GUARD_INTERVAL_1_32; 1458 pr_debug("guard interval is invalid %d\n", 1459 guard); 1460 break; 1461 } 1462 } else { 1463 c->transmission_mode = TRANSMISSION_MODE_2K; 1464 c->guard_interval = GUARD_INTERVAL_1_32; 1465 pr_debug("ModeGuard err %d\n", ret); 1466 } 1467 1468 mutex_lock(priv->spi_mutex); 1469 ret = cxd2880_tnrdmd_dvbt_mon_tps_info(&priv->tnrdmd, &tps); 1470 mutex_unlock(priv->spi_mutex); 1471 if (!ret) { 1472 switch (tps.hierarchy) { 1473 case CXD2880_DVBT_HIERARCHY_NON: 1474 c->hierarchy = HIERARCHY_NONE; 1475 break; 1476 case CXD2880_DVBT_HIERARCHY_1: 1477 c->hierarchy = HIERARCHY_1; 1478 break; 1479 case CXD2880_DVBT_HIERARCHY_2: 1480 c->hierarchy = HIERARCHY_2; 1481 break; 1482 case CXD2880_DVBT_HIERARCHY_4: 1483 c->hierarchy = HIERARCHY_4; 1484 break; 1485 default: 1486 c->hierarchy = HIERARCHY_NONE; 1487 pr_debug("TPSInfo hierarchy is invalid %d\n", 1488 tps.hierarchy); 1489 break; 1490 } 1491 1492 switch (tps.rate_hp) { 1493 case CXD2880_DVBT_CODERATE_1_2: 1494 c->code_rate_HP = FEC_1_2; 1495 break; 1496 case CXD2880_DVBT_CODERATE_2_3: 1497 c->code_rate_HP = FEC_2_3; 1498 break; 1499 case CXD2880_DVBT_CODERATE_3_4: 1500 c->code_rate_HP = FEC_3_4; 1501 break; 1502 case CXD2880_DVBT_CODERATE_5_6: 1503 c->code_rate_HP = FEC_5_6; 1504 break; 1505 case CXD2880_DVBT_CODERATE_7_8: 1506 c->code_rate_HP = FEC_7_8; 1507 break; 1508 default: 1509 c->code_rate_HP = FEC_NONE; 1510 pr_debug("TPSInfo rateHP is invalid %d\n", 1511 tps.rate_hp); 1512 break; 1513 } 1514 switch (tps.rate_lp) { 1515 case CXD2880_DVBT_CODERATE_1_2: 1516 c->code_rate_LP = FEC_1_2; 1517 break; 1518 case CXD2880_DVBT_CODERATE_2_3: 1519 c->code_rate_LP = FEC_2_3; 1520 break; 1521 case CXD2880_DVBT_CODERATE_3_4: 1522 c->code_rate_LP = FEC_3_4; 1523 break; 1524 case CXD2880_DVBT_CODERATE_5_6: 1525 c->code_rate_LP = FEC_5_6; 1526 break; 1527 case CXD2880_DVBT_CODERATE_7_8: 1528 c->code_rate_LP = FEC_7_8; 1529 break; 1530 default: 1531 c->code_rate_LP = FEC_NONE; 1532 pr_debug("TPSInfo rateLP is invalid %d\n", 1533 tps.rate_lp); 1534 break; 1535 } 1536 switch (tps.constellation) { 1537 case CXD2880_DVBT_CONSTELLATION_QPSK: 1538 c->modulation = QPSK; 1539 break; 1540 case CXD2880_DVBT_CONSTELLATION_16QAM: 1541 c->modulation = QAM_16; 1542 break; 1543 case CXD2880_DVBT_CONSTELLATION_64QAM: 1544 c->modulation = QAM_64; 1545 break; 1546 default: 1547 c->modulation = QPSK; 1548 pr_debug("TPSInfo constellation is invalid %d\n", 1549 tps.constellation); 1550 break; 1551 } 1552 } else { 1553 c->hierarchy = HIERARCHY_NONE; 1554 c->code_rate_HP = FEC_NONE; 1555 c->code_rate_LP = FEC_NONE; 1556 c->modulation = QPSK; 1557 pr_debug("TPS info err %d\n", ret); 1558 } 1559 1560 mutex_lock(priv->spi_mutex); 1561 ret = cxd2880_tnrdmd_dvbt_mon_spectrum_sense(&priv->tnrdmd, &sense); 1562 mutex_unlock(priv->spi_mutex); 1563 if (!ret) { 1564 switch (sense) { 1565 case CXD2880_TNRDMD_SPECTRUM_NORMAL: 1566 c->inversion = INVERSION_OFF; 1567 break; 1568 case CXD2880_TNRDMD_SPECTRUM_INV: 1569 c->inversion = INVERSION_ON; 1570 break; 1571 default: 1572 c->inversion = INVERSION_OFF; 1573 pr_debug("spectrum sense is invalid %d\n", sense); 1574 break; 1575 } 1576 } else { 1577 c->inversion = INVERSION_OFF; 1578 pr_debug("spectrum_sense %d\n", ret); 1579 } 1580 1581 mutex_lock(priv->spi_mutex); 1582 ret = cxd2880_tnrdmd_mon_rf_lvl(&priv->tnrdmd, &strength); 1583 mutex_unlock(priv->spi_mutex); 1584 if (!ret) { 1585 c->strength.len = 1; 1586 c->strength.stat[0].scale = FE_SCALE_DECIBEL; 1587 c->strength.stat[0].svalue = strength; 1588 } else { 1589 c->strength.len = 1; 1590 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1591 pr_debug("mon_rf_lvl %d\n", ret); 1592 } 1593 1594 ret = cxd2880_read_snr(fe, &snr); 1595 if (!ret) { 1596 c->cnr.len = 1; 1597 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 1598 c->cnr.stat[0].svalue = snr; 1599 } else { 1600 c->cnr.len = 1; 1601 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1602 pr_debug("read_snr %d\n", ret); 1603 } 1604 1605 return 0; 1606 } 1607 1608 static int cxd2880_get_frontend_t2(struct dvb_frontend *fe, 1609 struct dtv_frontend_properties *c) 1610 { 1611 int ret; 1612 struct cxd2880_priv *priv = NULL; 1613 struct cxd2880_dvbt2_l1pre l1pre; 1614 enum cxd2880_dvbt2_plp_code_rate coderate; 1615 enum cxd2880_dvbt2_plp_constell qam; 1616 enum cxd2880_tnrdmd_spectrum_sense sense; 1617 u16 snr = 0; 1618 int strength = 0; 1619 1620 if (!fe || !c) { 1621 pr_err("invalid arg.\n"); 1622 return -EINVAL; 1623 } 1624 1625 priv = fe->demodulator_priv; 1626 1627 mutex_lock(priv->spi_mutex); 1628 ret = cxd2880_tnrdmd_dvbt2_mon_l1_pre(&priv->tnrdmd, &l1pre); 1629 mutex_unlock(priv->spi_mutex); 1630 if (!ret) { 1631 switch (l1pre.fft_mode) { 1632 case CXD2880_DVBT2_M2K: 1633 c->transmission_mode = TRANSMISSION_MODE_2K; 1634 break; 1635 case CXD2880_DVBT2_M8K: 1636 c->transmission_mode = TRANSMISSION_MODE_8K; 1637 break; 1638 case CXD2880_DVBT2_M4K: 1639 c->transmission_mode = TRANSMISSION_MODE_4K; 1640 break; 1641 case CXD2880_DVBT2_M1K: 1642 c->transmission_mode = TRANSMISSION_MODE_1K; 1643 break; 1644 case CXD2880_DVBT2_M16K: 1645 c->transmission_mode = TRANSMISSION_MODE_16K; 1646 break; 1647 case CXD2880_DVBT2_M32K: 1648 c->transmission_mode = TRANSMISSION_MODE_32K; 1649 break; 1650 default: 1651 c->transmission_mode = TRANSMISSION_MODE_2K; 1652 pr_debug("L1Pre fft_mode is invalid %d\n", 1653 l1pre.fft_mode); 1654 break; 1655 } 1656 switch (l1pre.gi) { 1657 case CXD2880_DVBT2_G1_32: 1658 c->guard_interval = GUARD_INTERVAL_1_32; 1659 break; 1660 case CXD2880_DVBT2_G1_16: 1661 c->guard_interval = GUARD_INTERVAL_1_16; 1662 break; 1663 case CXD2880_DVBT2_G1_8: 1664 c->guard_interval = GUARD_INTERVAL_1_8; 1665 break; 1666 case CXD2880_DVBT2_G1_4: 1667 c->guard_interval = GUARD_INTERVAL_1_4; 1668 break; 1669 case CXD2880_DVBT2_G1_128: 1670 c->guard_interval = GUARD_INTERVAL_1_128; 1671 break; 1672 case CXD2880_DVBT2_G19_128: 1673 c->guard_interval = GUARD_INTERVAL_19_128; 1674 break; 1675 case CXD2880_DVBT2_G19_256: 1676 c->guard_interval = GUARD_INTERVAL_19_256; 1677 break; 1678 default: 1679 c->guard_interval = GUARD_INTERVAL_1_32; 1680 pr_debug("L1Pre guard interval is invalid %d\n", 1681 l1pre.gi); 1682 break; 1683 } 1684 } else { 1685 c->transmission_mode = TRANSMISSION_MODE_2K; 1686 c->guard_interval = GUARD_INTERVAL_1_32; 1687 pr_debug("L1Pre err %d\n", ret); 1688 } 1689 1690 mutex_lock(priv->spi_mutex); 1691 ret = cxd2880_tnrdmd_dvbt2_mon_code_rate(&priv->tnrdmd, 1692 CXD2880_DVBT2_PLP_DATA, 1693 &coderate); 1694 mutex_unlock(priv->spi_mutex); 1695 if (!ret) { 1696 switch (coderate) { 1697 case CXD2880_DVBT2_R1_2: 1698 c->fec_inner = FEC_1_2; 1699 break; 1700 case CXD2880_DVBT2_R3_5: 1701 c->fec_inner = FEC_3_5; 1702 break; 1703 case CXD2880_DVBT2_R2_3: 1704 c->fec_inner = FEC_2_3; 1705 break; 1706 case CXD2880_DVBT2_R3_4: 1707 c->fec_inner = FEC_3_4; 1708 break; 1709 case CXD2880_DVBT2_R4_5: 1710 c->fec_inner = FEC_4_5; 1711 break; 1712 case CXD2880_DVBT2_R5_6: 1713 c->fec_inner = FEC_5_6; 1714 break; 1715 default: 1716 c->fec_inner = FEC_NONE; 1717 pr_debug("CodeRate is invalid %d\n", coderate); 1718 break; 1719 } 1720 } else { 1721 c->fec_inner = FEC_NONE; 1722 pr_debug("CodeRate %d\n", ret); 1723 } 1724 1725 mutex_lock(priv->spi_mutex); 1726 ret = cxd2880_tnrdmd_dvbt2_mon_qam(&priv->tnrdmd, 1727 CXD2880_DVBT2_PLP_DATA, 1728 &qam); 1729 mutex_unlock(priv->spi_mutex); 1730 if (!ret) { 1731 switch (qam) { 1732 case CXD2880_DVBT2_QPSK: 1733 c->modulation = QPSK; 1734 break; 1735 case CXD2880_DVBT2_QAM16: 1736 c->modulation = QAM_16; 1737 break; 1738 case CXD2880_DVBT2_QAM64: 1739 c->modulation = QAM_64; 1740 break; 1741 case CXD2880_DVBT2_QAM256: 1742 c->modulation = QAM_256; 1743 break; 1744 default: 1745 c->modulation = QPSK; 1746 pr_debug("QAM is invalid %d\n", qam); 1747 break; 1748 } 1749 } else { 1750 c->modulation = QPSK; 1751 pr_debug("QAM %d\n", ret); 1752 } 1753 1754 mutex_lock(priv->spi_mutex); 1755 ret = cxd2880_tnrdmd_dvbt2_mon_spectrum_sense(&priv->tnrdmd, &sense); 1756 mutex_unlock(priv->spi_mutex); 1757 if (!ret) { 1758 switch (sense) { 1759 case CXD2880_TNRDMD_SPECTRUM_NORMAL: 1760 c->inversion = INVERSION_OFF; 1761 break; 1762 case CXD2880_TNRDMD_SPECTRUM_INV: 1763 c->inversion = INVERSION_ON; 1764 break; 1765 default: 1766 c->inversion = INVERSION_OFF; 1767 pr_debug("spectrum sense is invalid %d\n", sense); 1768 break; 1769 } 1770 } else { 1771 c->inversion = INVERSION_OFF; 1772 pr_debug("SpectrumSense %d\n", ret); 1773 } 1774 1775 mutex_lock(priv->spi_mutex); 1776 ret = cxd2880_tnrdmd_mon_rf_lvl(&priv->tnrdmd, &strength); 1777 mutex_unlock(priv->spi_mutex); 1778 if (!ret) { 1779 c->strength.len = 1; 1780 c->strength.stat[0].scale = FE_SCALE_DECIBEL; 1781 c->strength.stat[0].svalue = strength; 1782 } else { 1783 c->strength.len = 1; 1784 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1785 pr_debug("mon_rf_lvl %d\n", ret); 1786 } 1787 1788 ret = cxd2880_read_snr(fe, &snr); 1789 if (!ret) { 1790 c->cnr.len = 1; 1791 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 1792 c->cnr.stat[0].svalue = snr; 1793 } else { 1794 c->cnr.len = 1; 1795 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1796 pr_debug("read_snr %d\n", ret); 1797 } 1798 1799 return 0; 1800 } 1801 1802 static int cxd2880_get_frontend(struct dvb_frontend *fe, 1803 struct dtv_frontend_properties *props) 1804 { 1805 int ret; 1806 1807 if (!fe || !props) { 1808 pr_err("invalid arg."); 1809 return -EINVAL; 1810 } 1811 1812 pr_debug("system=%d\n", fe->dtv_property_cache.delivery_system); 1813 switch (fe->dtv_property_cache.delivery_system) { 1814 case SYS_DVBT: 1815 ret = cxd2880_get_frontend_t(fe, props); 1816 break; 1817 case SYS_DVBT2: 1818 ret = cxd2880_get_frontend_t2(fe, props); 1819 break; 1820 default: 1821 ret = -EINVAL; 1822 break; 1823 } 1824 1825 return ret; 1826 } 1827 1828 static enum dvbfe_algo cxd2880_get_frontend_algo(struct dvb_frontend *fe) 1829 { 1830 return DVBFE_ALGO_HW; 1831 } 1832 1833 static struct dvb_frontend_ops cxd2880_dvbt_t2_ops = { 1834 .info = { 1835 .name = "Sony CXD2880", 1836 .frequency_min_hz = 174 * MHz, 1837 .frequency_max_hz = 862 * MHz, 1838 .frequency_stepsize_hz = 1 * kHz, 1839 .caps = FE_CAN_INVERSION_AUTO | 1840 FE_CAN_FEC_1_2 | 1841 FE_CAN_FEC_2_3 | 1842 FE_CAN_FEC_3_4 | 1843 FE_CAN_FEC_4_5 | 1844 FE_CAN_FEC_5_6 | 1845 FE_CAN_FEC_7_8 | 1846 FE_CAN_FEC_AUTO | 1847 FE_CAN_QPSK | 1848 FE_CAN_QAM_16 | 1849 FE_CAN_QAM_32 | 1850 FE_CAN_QAM_64 | 1851 FE_CAN_QAM_128 | 1852 FE_CAN_QAM_256 | 1853 FE_CAN_QAM_AUTO | 1854 FE_CAN_TRANSMISSION_MODE_AUTO | 1855 FE_CAN_GUARD_INTERVAL_AUTO | 1856 FE_CAN_2G_MODULATION | 1857 FE_CAN_RECOVER | 1858 FE_CAN_MUTE_TS, 1859 }, 1860 .delsys = { SYS_DVBT, SYS_DVBT2 }, 1861 1862 .release = cxd2880_release, 1863 .init = cxd2880_init, 1864 .sleep = cxd2880_sleep, 1865 .tune = cxd2880_tune, 1866 .set_frontend = cxd2880_set_frontend, 1867 .get_frontend = cxd2880_get_frontend, 1868 .read_status = cxd2880_read_status, 1869 .read_ber = cxd2880_read_ber, 1870 .read_signal_strength = cxd2880_read_signal_strength, 1871 .read_snr = cxd2880_read_snr, 1872 .read_ucblocks = cxd2880_read_ucblocks, 1873 .get_frontend_algo = cxd2880_get_frontend_algo, 1874 }; 1875 1876 struct dvb_frontend *cxd2880_attach(struct dvb_frontend *fe, 1877 struct cxd2880_config *cfg) 1878 { 1879 int ret; 1880 enum cxd2880_tnrdmd_chip_id chipid = 1881 CXD2880_TNRDMD_CHIP_ID_UNKNOWN; 1882 static struct cxd2880_priv *priv; 1883 u8 data = 0; 1884 1885 if (!fe) { 1886 pr_err("invalid arg.\n"); 1887 return NULL; 1888 } 1889 1890 priv = kzalloc(sizeof(struct cxd2880_priv), GFP_KERNEL); 1891 if (!priv) 1892 return NULL; 1893 1894 priv->spi = cfg->spi; 1895 priv->spi_mutex = cfg->spi_mutex; 1896 priv->spi_device.spi = cfg->spi; 1897 1898 memcpy(&fe->ops, &cxd2880_dvbt_t2_ops, 1899 sizeof(struct dvb_frontend_ops)); 1900 1901 ret = cxd2880_spi_device_initialize(&priv->spi_device, 1902 CXD2880_SPI_MODE_0, 1903 55000000); 1904 if (ret) { 1905 pr_err("spi_device_initialize failed. %d\n", ret); 1906 kfree(priv); 1907 return NULL; 1908 } 1909 1910 ret = cxd2880_spi_device_create_spi(&priv->cxd2880_spi, 1911 &priv->spi_device); 1912 if (ret) { 1913 pr_err("spi_device_create_spi failed. %d\n", ret); 1914 kfree(priv); 1915 return NULL; 1916 } 1917 1918 ret = cxd2880_io_spi_create(&priv->regio, &priv->cxd2880_spi, 0); 1919 if (ret) { 1920 pr_err("io_spi_create failed. %d\n", ret); 1921 kfree(priv); 1922 return NULL; 1923 } 1924 ret = priv->regio.write_reg(&priv->regio, 1925 CXD2880_IO_TGT_SYS, 0x00, 0x00); 1926 if (ret) { 1927 pr_err("set bank to 0x00 failed.\n"); 1928 kfree(priv); 1929 return NULL; 1930 } 1931 ret = priv->regio.read_regs(&priv->regio, 1932 CXD2880_IO_TGT_SYS, 0xfd, &data, 1); 1933 if (ret) { 1934 pr_err("read chip id failed.\n"); 1935 kfree(priv); 1936 return NULL; 1937 } 1938 1939 chipid = (enum cxd2880_tnrdmd_chip_id)data; 1940 if (chipid != CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_0X && 1941 chipid != CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_11) { 1942 pr_err("chip id invalid.\n"); 1943 kfree(priv); 1944 return NULL; 1945 } 1946 1947 fe->demodulator_priv = priv; 1948 pr_info("CXD2880 driver version: Ver %s\n", 1949 CXD2880_TNRDMD_DRIVER_VERSION); 1950 1951 return fe; 1952 } 1953 EXPORT_SYMBOL_GPL(cxd2880_attach); 1954 1955 MODULE_DESCRIPTION("Sony CXD2880 DVB-T2/T tuner + demod driver"); 1956 MODULE_AUTHOR("Sony Semiconductor Solutions Corporation"); 1957 MODULE_LICENSE("GPL v2"); 1958