1 /* 2 * Panasonic MN88473 DVB-T/T2/C demodulator driver 3 * 4 * Copyright (C) 2014 Antti Palosaari <crope@iki.fi> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 */ 16 17 #include "mn88473_priv.h" 18 19 static int mn88473_get_tune_settings(struct dvb_frontend *fe, 20 struct dvb_frontend_tune_settings *s) 21 { 22 s->min_delay_ms = 1000; 23 return 0; 24 } 25 26 static int mn88473_set_frontend(struct dvb_frontend *fe) 27 { 28 struct i2c_client *client = fe->demodulator_priv; 29 struct mn88473_dev *dev = i2c_get_clientdata(client); 30 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 31 int ret, i; 32 unsigned int uitmp; 33 u32 if_frequency; 34 u8 delivery_system_val, if_val[3], *conf_val_ptr; 35 u8 reg_bank2_2d_val, reg_bank0_d2_val; 36 37 dev_dbg(&client->dev, 38 "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%d stream_id=%d\n", 39 c->delivery_system, c->modulation, c->frequency, 40 c->bandwidth_hz, c->symbol_rate, c->inversion, c->stream_id); 41 42 if (!dev->active) { 43 ret = -EAGAIN; 44 goto err; 45 } 46 47 switch (c->delivery_system) { 48 case SYS_DVBT: 49 delivery_system_val = 0x02; 50 reg_bank2_2d_val = 0x23; 51 reg_bank0_d2_val = 0x2a; 52 break; 53 case SYS_DVBT2: 54 delivery_system_val = 0x03; 55 reg_bank2_2d_val = 0x3b; 56 reg_bank0_d2_val = 0x29; 57 break; 58 case SYS_DVBC_ANNEX_A: 59 delivery_system_val = 0x04; 60 reg_bank2_2d_val = 0x3b; 61 reg_bank0_d2_val = 0x29; 62 break; 63 default: 64 ret = -EINVAL; 65 goto err; 66 } 67 68 switch (c->delivery_system) { 69 case SYS_DVBT: 70 case SYS_DVBT2: 71 switch (c->bandwidth_hz) { 72 case 6000000: 73 conf_val_ptr = "\xe9\x55\x55\x1c\x29\x1c\x29"; 74 break; 75 case 7000000: 76 conf_val_ptr = "\xc8\x00\x00\x17\x0a\x17\x0a"; 77 break; 78 case 8000000: 79 conf_val_ptr = "\xaf\x00\x00\x11\xec\x11\xec"; 80 break; 81 default: 82 ret = -EINVAL; 83 goto err; 84 } 85 break; 86 case SYS_DVBC_ANNEX_A: 87 conf_val_ptr = "\x10\xab\x0d\xae\x1d\x9d"; 88 break; 89 default: 90 break; 91 } 92 93 /* Program tuner */ 94 if (fe->ops.tuner_ops.set_params) { 95 ret = fe->ops.tuner_ops.set_params(fe); 96 if (ret) 97 goto err; 98 } 99 100 if (fe->ops.tuner_ops.get_if_frequency) { 101 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency); 102 if (ret) 103 goto err; 104 105 dev_dbg(&client->dev, "get_if_frequency=%u\n", if_frequency); 106 } else { 107 ret = -EINVAL; 108 goto err; 109 } 110 111 /* Calculate IF registers */ 112 uitmp = DIV_ROUND_CLOSEST_ULL((u64) if_frequency * 0x1000000, dev->clk); 113 if_val[0] = (uitmp >> 16) & 0xff; 114 if_val[1] = (uitmp >> 8) & 0xff; 115 if_val[2] = (uitmp >> 0) & 0xff; 116 117 ret = regmap_write(dev->regmap[2], 0x05, 0x00); 118 if (ret) 119 goto err; 120 ret = regmap_write(dev->regmap[2], 0xfb, 0x13); 121 if (ret) 122 goto err; 123 ret = regmap_write(dev->regmap[2], 0xef, 0x13); 124 if (ret) 125 goto err; 126 ret = regmap_write(dev->regmap[2], 0xf9, 0x13); 127 if (ret) 128 goto err; 129 ret = regmap_write(dev->regmap[2], 0x00, 0x18); 130 if (ret) 131 goto err; 132 ret = regmap_write(dev->regmap[2], 0x01, 0x01); 133 if (ret) 134 goto err; 135 ret = regmap_write(dev->regmap[2], 0x02, 0x21); 136 if (ret) 137 goto err; 138 ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val); 139 if (ret) 140 goto err; 141 ret = regmap_write(dev->regmap[2], 0x0b, 0x00); 142 if (ret) 143 goto err; 144 145 for (i = 0; i < sizeof(if_val); i++) { 146 ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]); 147 if (ret) 148 goto err; 149 } 150 151 switch (c->delivery_system) { 152 case SYS_DVBT: 153 case SYS_DVBT2: 154 for (i = 0; i < 7; i++) { 155 ret = regmap_write(dev->regmap[2], 0x13 + i, 156 conf_val_ptr[i]); 157 if (ret) 158 goto err; 159 } 160 break; 161 case SYS_DVBC_ANNEX_A: 162 ret = regmap_bulk_write(dev->regmap[1], 0x10, conf_val_ptr, 6); 163 if (ret) 164 goto err; 165 break; 166 default: 167 break; 168 } 169 170 ret = regmap_write(dev->regmap[2], 0x2d, reg_bank2_2d_val); 171 if (ret) 172 goto err; 173 ret = regmap_write(dev->regmap[2], 0x2e, 0x00); 174 if (ret) 175 goto err; 176 ret = regmap_write(dev->regmap[2], 0x56, 0x0d); 177 if (ret) 178 goto err; 179 ret = regmap_bulk_write(dev->regmap[0], 0x01, 180 "\xba\x13\x80\xba\x91\xdd\xe7\x28", 8); 181 if (ret) 182 goto err; 183 ret = regmap_write(dev->regmap[0], 0x0a, 0x1a); 184 if (ret) 185 goto err; 186 ret = regmap_write(dev->regmap[0], 0x13, 0x1f); 187 if (ret) 188 goto err; 189 ret = regmap_write(dev->regmap[0], 0x19, 0x03); 190 if (ret) 191 goto err; 192 ret = regmap_write(dev->regmap[0], 0x1d, 0xb0); 193 if (ret) 194 goto err; 195 ret = regmap_write(dev->regmap[0], 0x2a, 0x72); 196 if (ret) 197 goto err; 198 ret = regmap_write(dev->regmap[0], 0x2d, 0x00); 199 if (ret) 200 goto err; 201 ret = regmap_write(dev->regmap[0], 0x3c, 0x00); 202 if (ret) 203 goto err; 204 ret = regmap_write(dev->regmap[0], 0x3f, 0xf8); 205 if (ret) 206 goto err; 207 ret = regmap_bulk_write(dev->regmap[0], 0x40, "\xf4\x08", 2); 208 if (ret) 209 goto err; 210 ret = regmap_write(dev->regmap[0], 0xd2, reg_bank0_d2_val); 211 if (ret) 212 goto err; 213 ret = regmap_write(dev->regmap[0], 0xd4, 0x55); 214 if (ret) 215 goto err; 216 ret = regmap_write(dev->regmap[1], 0xbe, 0x08); 217 if (ret) 218 goto err; 219 ret = regmap_write(dev->regmap[0], 0xb2, 0x37); 220 if (ret) 221 goto err; 222 ret = regmap_write(dev->regmap[0], 0xd7, 0x04); 223 if (ret) 224 goto err; 225 226 /* Reset FSM */ 227 ret = regmap_write(dev->regmap[2], 0xf8, 0x9f); 228 if (ret) 229 goto err; 230 231 return 0; 232 err: 233 dev_dbg(&client->dev, "failed=%d\n", ret); 234 return ret; 235 } 236 237 static int mn88473_read_status(struct dvb_frontend *fe, enum fe_status *status) 238 { 239 struct i2c_client *client = fe->demodulator_priv; 240 struct mn88473_dev *dev = i2c_get_clientdata(client); 241 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 242 int ret; 243 unsigned int uitmp; 244 245 if (!dev->active) { 246 ret = -EAGAIN; 247 goto err; 248 } 249 250 *status = 0; 251 252 switch (c->delivery_system) { 253 case SYS_DVBT: 254 ret = regmap_read(dev->regmap[0], 0x62, &uitmp); 255 if (ret) 256 goto err; 257 258 if (!(uitmp & 0xa0)) { 259 if ((uitmp & 0x0f) >= 0x09) 260 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | 261 FE_HAS_VITERBI | FE_HAS_SYNC | 262 FE_HAS_LOCK; 263 else if ((uitmp & 0x0f) >= 0x03) 264 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 265 } 266 break; 267 case SYS_DVBT2: 268 ret = regmap_read(dev->regmap[2], 0x8b, &uitmp); 269 if (ret) 270 goto err; 271 272 if (!(uitmp & 0x40)) { 273 if ((uitmp & 0x0f) >= 0x0d) 274 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | 275 FE_HAS_VITERBI | FE_HAS_SYNC | 276 FE_HAS_LOCK; 277 else if ((uitmp & 0x0f) >= 0x0a) 278 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | 279 FE_HAS_VITERBI; 280 else if ((uitmp & 0x0f) >= 0x07) 281 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 282 } 283 break; 284 case SYS_DVBC_ANNEX_A: 285 ret = regmap_read(dev->regmap[1], 0x85, &uitmp); 286 if (ret) 287 goto err; 288 289 if (!(uitmp & 0x40)) { 290 ret = regmap_read(dev->regmap[1], 0x89, &uitmp); 291 if (ret) 292 goto err; 293 294 if (uitmp & 0x01) 295 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | 296 FE_HAS_VITERBI | FE_HAS_SYNC | 297 FE_HAS_LOCK; 298 } 299 break; 300 default: 301 ret = -EINVAL; 302 goto err; 303 } 304 305 return 0; 306 err: 307 dev_dbg(&client->dev, "failed=%d\n", ret); 308 return ret; 309 } 310 311 static int mn88473_init(struct dvb_frontend *fe) 312 { 313 struct i2c_client *client = fe->demodulator_priv; 314 struct mn88473_dev *dev = i2c_get_clientdata(client); 315 int ret, len, remain; 316 unsigned int uitmp; 317 const struct firmware *fw; 318 const char *name = MN88473_FIRMWARE; 319 320 dev_dbg(&client->dev, "\n"); 321 322 /* Check if firmware is already running */ 323 ret = regmap_read(dev->regmap[0], 0xf5, &uitmp); 324 if (ret) 325 goto err; 326 327 if (!(uitmp & 0x01)) 328 goto warm; 329 330 /* Request the firmware, this will block and timeout */ 331 ret = request_firmware(&fw, name, &client->dev); 332 if (ret) { 333 dev_err(&client->dev, "firmare file '%s' not found\n", name); 334 goto err; 335 } 336 337 dev_info(&client->dev, "downloading firmware from file '%s'\n", name); 338 339 ret = regmap_write(dev->regmap[0], 0xf5, 0x03); 340 if (ret) 341 goto err_release_firmware; 342 343 for (remain = fw->size; remain > 0; remain -= (dev->i2c_wr_max - 1)) { 344 len = min(dev->i2c_wr_max - 1, remain); 345 ret = regmap_bulk_write(dev->regmap[0], 0xf6, 346 &fw->data[fw->size - remain], len); 347 if (ret) { 348 dev_err(&client->dev, "firmware download failed %d\n", 349 ret); 350 goto err_release_firmware; 351 } 352 } 353 354 release_firmware(fw); 355 356 /* Parity check of firmware */ 357 ret = regmap_read(dev->regmap[0], 0xf8, &uitmp); 358 if (ret) 359 goto err; 360 361 if (uitmp & 0x10) { 362 dev_err(&client->dev, "firmware parity check failed\n"); 363 ret = -EINVAL; 364 goto err; 365 } 366 367 ret = regmap_write(dev->regmap[0], 0xf5, 0x00); 368 if (ret) 369 goto err; 370 warm: 371 /* TS config */ 372 ret = regmap_write(dev->regmap[2], 0x09, 0x08); 373 if (ret) 374 goto err; 375 ret = regmap_write(dev->regmap[2], 0x08, 0x1d); 376 if (ret) 377 goto err; 378 379 dev->active = true; 380 381 return 0; 382 err_release_firmware: 383 release_firmware(fw); 384 err: 385 dev_dbg(&client->dev, "failed=%d\n", ret); 386 return ret; 387 } 388 389 static int mn88473_sleep(struct dvb_frontend *fe) 390 { 391 struct i2c_client *client = fe->demodulator_priv; 392 struct mn88473_dev *dev = i2c_get_clientdata(client); 393 int ret; 394 395 dev_dbg(&client->dev, "\n"); 396 397 dev->active = false; 398 399 ret = regmap_write(dev->regmap[2], 0x05, 0x3e); 400 if (ret) 401 goto err; 402 403 return 0; 404 err: 405 dev_dbg(&client->dev, "failed=%d\n", ret); 406 return ret; 407 } 408 409 static const struct dvb_frontend_ops mn88473_ops = { 410 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 411 .info = { 412 .name = "Panasonic MN88473", 413 .symbol_rate_min = 1000000, 414 .symbol_rate_max = 7200000, 415 .caps = FE_CAN_FEC_1_2 | 416 FE_CAN_FEC_2_3 | 417 FE_CAN_FEC_3_4 | 418 FE_CAN_FEC_5_6 | 419 FE_CAN_FEC_7_8 | 420 FE_CAN_FEC_AUTO | 421 FE_CAN_QPSK | 422 FE_CAN_QAM_16 | 423 FE_CAN_QAM_32 | 424 FE_CAN_QAM_64 | 425 FE_CAN_QAM_128 | 426 FE_CAN_QAM_256 | 427 FE_CAN_QAM_AUTO | 428 FE_CAN_TRANSMISSION_MODE_AUTO | 429 FE_CAN_GUARD_INTERVAL_AUTO | 430 FE_CAN_HIERARCHY_AUTO | 431 FE_CAN_MUTE_TS | 432 FE_CAN_2G_MODULATION 433 }, 434 435 .get_tune_settings = mn88473_get_tune_settings, 436 437 .init = mn88473_init, 438 .sleep = mn88473_sleep, 439 440 .set_frontend = mn88473_set_frontend, 441 442 .read_status = mn88473_read_status, 443 }; 444 445 static int mn88473_probe(struct i2c_client *client, 446 const struct i2c_device_id *id) 447 { 448 struct mn88473_config *config = client->dev.platform_data; 449 struct mn88473_dev *dev; 450 int ret; 451 unsigned int uitmp; 452 static const struct regmap_config regmap_config = { 453 .reg_bits = 8, 454 .val_bits = 8, 455 }; 456 457 dev_dbg(&client->dev, "\n"); 458 459 /* Caller really need to provide pointer for frontend we create */ 460 if (config->fe == NULL) { 461 dev_err(&client->dev, "frontend pointer not defined\n"); 462 ret = -EINVAL; 463 goto err; 464 } 465 466 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 467 if (dev == NULL) { 468 ret = -ENOMEM; 469 goto err; 470 } 471 472 if (config->i2c_wr_max) 473 dev->i2c_wr_max = config->i2c_wr_max; 474 else 475 dev->i2c_wr_max = ~0; 476 477 if (config->xtal) 478 dev->clk = config->xtal; 479 else 480 dev->clk = 25000000; 481 dev->client[0] = client; 482 dev->regmap[0] = regmap_init_i2c(dev->client[0], ®map_config); 483 if (IS_ERR(dev->regmap[0])) { 484 ret = PTR_ERR(dev->regmap[0]); 485 goto err_kfree; 486 } 487 488 /* Check demod answers with correct chip id */ 489 ret = regmap_read(dev->regmap[0], 0xff, &uitmp); 490 if (ret) 491 goto err_regmap_0_regmap_exit; 492 493 dev_dbg(&client->dev, "chip id=%02x\n", uitmp); 494 495 if (uitmp != 0x03) { 496 ret = -ENODEV; 497 goto err_regmap_0_regmap_exit; 498 } 499 500 /* 501 * Chip has three I2C addresses for different register banks. Used 502 * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients, 503 * 0x1a and 0x1c, in order to get own I2C client for each register bank. 504 * 505 * Also, register bank 2 do not support sequential I/O. Only single 506 * register write or read is allowed to that bank. 507 */ 508 dev->client[1] = i2c_new_dummy(client->adapter, 0x1a); 509 if (dev->client[1] == NULL) { 510 ret = -ENODEV; 511 dev_err(&client->dev, "I2C registration failed\n"); 512 if (ret) 513 goto err_regmap_0_regmap_exit; 514 } 515 dev->regmap[1] = regmap_init_i2c(dev->client[1], ®map_config); 516 if (IS_ERR(dev->regmap[1])) { 517 ret = PTR_ERR(dev->regmap[1]); 518 goto err_client_1_i2c_unregister_device; 519 } 520 i2c_set_clientdata(dev->client[1], dev); 521 522 dev->client[2] = i2c_new_dummy(client->adapter, 0x1c); 523 if (dev->client[2] == NULL) { 524 ret = -ENODEV; 525 dev_err(&client->dev, "2nd I2C registration failed\n"); 526 if (ret) 527 goto err_regmap_1_regmap_exit; 528 } 529 dev->regmap[2] = regmap_init_i2c(dev->client[2], ®map_config); 530 if (IS_ERR(dev->regmap[2])) { 531 ret = PTR_ERR(dev->regmap[2]); 532 goto err_client_2_i2c_unregister_device; 533 } 534 i2c_set_clientdata(dev->client[2], dev); 535 536 /* Sleep because chip is active by default */ 537 ret = regmap_write(dev->regmap[2], 0x05, 0x3e); 538 if (ret) 539 goto err_client_2_i2c_unregister_device; 540 541 /* Create dvb frontend */ 542 memcpy(&dev->frontend.ops, &mn88473_ops, sizeof(dev->frontend.ops)); 543 dev->frontend.demodulator_priv = client; 544 *config->fe = &dev->frontend; 545 i2c_set_clientdata(client, dev); 546 547 dev_info(&client->dev, "Panasonic MN88473 successfully identified\n"); 548 549 return 0; 550 551 err_client_2_i2c_unregister_device: 552 i2c_unregister_device(dev->client[2]); 553 err_regmap_1_regmap_exit: 554 regmap_exit(dev->regmap[1]); 555 err_client_1_i2c_unregister_device: 556 i2c_unregister_device(dev->client[1]); 557 err_regmap_0_regmap_exit: 558 regmap_exit(dev->regmap[0]); 559 err_kfree: 560 kfree(dev); 561 err: 562 dev_dbg(&client->dev, "failed=%d\n", ret); 563 return ret; 564 } 565 566 static int mn88473_remove(struct i2c_client *client) 567 { 568 struct mn88473_dev *dev = i2c_get_clientdata(client); 569 570 dev_dbg(&client->dev, "\n"); 571 572 regmap_exit(dev->regmap[2]); 573 i2c_unregister_device(dev->client[2]); 574 575 regmap_exit(dev->regmap[1]); 576 i2c_unregister_device(dev->client[1]); 577 578 regmap_exit(dev->regmap[0]); 579 580 kfree(dev); 581 582 return 0; 583 } 584 585 static const struct i2c_device_id mn88473_id_table[] = { 586 {"mn88473", 0}, 587 {} 588 }; 589 MODULE_DEVICE_TABLE(i2c, mn88473_id_table); 590 591 static struct i2c_driver mn88473_driver = { 592 .driver = { 593 .name = "mn88473", 594 .suppress_bind_attrs = true, 595 }, 596 .probe = mn88473_probe, 597 .remove = mn88473_remove, 598 .id_table = mn88473_id_table, 599 }; 600 601 module_i2c_driver(mn88473_driver); 602 603 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 604 MODULE_DESCRIPTION("Panasonic MN88473 DVB-T/T2/C demodulator driver"); 605 MODULE_LICENSE("GPL"); 606 MODULE_FIRMWARE(MN88473_FIRMWARE); 607