si2168.c revision 668aa63cfcc33e13f2d4c2eef6f65146775b9ed6
1/* 2 * Silicon Labs Si2168 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 "si2168_priv.h" 18 19static const struct dvb_frontend_ops si2168_ops; 20 21/* execute firmware command */ 22static int si2168_cmd_execute(struct si2168 *s, struct si2168_cmd *cmd) 23{ 24 int ret; 25 unsigned long timeout; 26 27 mutex_lock(&s->i2c_mutex); 28 29 if (cmd->wlen) { 30 /* write cmd and args for firmware */ 31 ret = i2c_master_send(s->client, cmd->args, cmd->wlen); 32 if (ret < 0) { 33 goto err_mutex_unlock; 34 } else if (ret != cmd->wlen) { 35 ret = -EREMOTEIO; 36 goto err_mutex_unlock; 37 } 38 } 39 40 if (cmd->rlen) { 41 /* wait cmd execution terminate */ 42 #define TIMEOUT 50 43 timeout = jiffies + msecs_to_jiffies(TIMEOUT); 44 while (!time_after(jiffies, timeout)) { 45 ret = i2c_master_recv(s->client, cmd->args, cmd->rlen); 46 if (ret < 0) { 47 goto err_mutex_unlock; 48 } else if (ret != cmd->rlen) { 49 ret = -EREMOTEIO; 50 goto err_mutex_unlock; 51 } 52 53 /* firmware ready? */ 54 if ((cmd->args[0] >> 7) & 0x01) 55 break; 56 } 57 58 dev_dbg(&s->client->dev, "%s: cmd execution took %d ms\n", 59 __func__, 60 jiffies_to_msecs(jiffies) - 61 (jiffies_to_msecs(timeout) - TIMEOUT)); 62 63 if (!(cmd->args[0] >> 7) & 0x01) { 64 ret = -ETIMEDOUT; 65 goto err_mutex_unlock; 66 } 67 } 68 69 ret = 0; 70 71err_mutex_unlock: 72 mutex_unlock(&s->i2c_mutex); 73 if (ret) 74 goto err; 75 76 return 0; 77err: 78 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 79 return ret; 80} 81 82static int si2168_read_status(struct dvb_frontend *fe, fe_status_t *status) 83{ 84 struct si2168 *s = fe->demodulator_priv; 85 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 86 int ret; 87 struct si2168_cmd cmd; 88 89 *status = 0; 90 91 if (!s->active) { 92 ret = -EAGAIN; 93 goto err; 94 } 95 96 switch (c->delivery_system) { 97 case SYS_DVBT: 98 memcpy(cmd.args, "\xa0\x01", 2); 99 cmd.wlen = 2; 100 cmd.rlen = 13; 101 break; 102 case SYS_DVBC_ANNEX_A: 103 memcpy(cmd.args, "\x90\x01", 2); 104 cmd.wlen = 2; 105 cmd.rlen = 9; 106 break; 107 case SYS_DVBT2: 108 memcpy(cmd.args, "\x50\x01", 2); 109 cmd.wlen = 2; 110 cmd.rlen = 14; 111 break; 112 default: 113 ret = -EINVAL; 114 goto err; 115 } 116 117 ret = si2168_cmd_execute(s, &cmd); 118 if (ret) 119 goto err; 120 121 /* 122 * Possible values seen, in order from strong signal to weak: 123 * 16 0001 0110 full lock 124 * 1e 0001 1110 partial lock 125 * 1a 0001 1010 partial lock 126 * 18 0001 1000 no lock 127 * 128 * [b3:b1] lock bits 129 * [b4] statistics ready? Set in a few secs after lock is gained. 130 */ 131 132 switch ((cmd.args[2] >> 1) & 0x03) { 133 case 0x01: 134 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 135 break; 136 case 0x03: 137 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | 138 FE_HAS_SYNC | FE_HAS_LOCK; 139 break; 140 } 141 142 s->fe_status = *status; 143 144 if (*status & FE_HAS_LOCK) { 145 c->cnr.len = 1; 146 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 147 c->cnr.stat[0].svalue = cmd.args[3] * 1000 / 4; 148 } else { 149 c->cnr.len = 1; 150 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 151 } 152 153 dev_dbg(&s->client->dev, "%s: status=%02x args=%*ph\n", 154 __func__, *status, cmd.rlen, cmd.args); 155 156 return 0; 157err: 158 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 159 return ret; 160} 161 162static int si2168_set_frontend(struct dvb_frontend *fe) 163{ 164 struct si2168 *s = fe->demodulator_priv; 165 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 166 int ret; 167 struct si2168_cmd cmd; 168 u8 bandwidth, delivery_system; 169 170 dev_dbg(&s->client->dev, 171 "%s: delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%u\n", 172 __func__, c->delivery_system, c->modulation, 173 c->frequency, c->bandwidth_hz, c->symbol_rate, 174 c->inversion); 175 176 if (!s->active) { 177 ret = -EAGAIN; 178 goto err; 179 } 180 181 switch (c->delivery_system) { 182 case SYS_DVBT: 183 delivery_system = 0x20; 184 break; 185 case SYS_DVBC_ANNEX_A: 186 delivery_system = 0x30; 187 break; 188 case SYS_DVBT2: 189 delivery_system = 0x70; 190 break; 191 default: 192 ret = -EINVAL; 193 goto err; 194 } 195 196 if (c->bandwidth_hz <= 5000000) 197 bandwidth = 0x05; 198 else if (c->bandwidth_hz <= 6000000) 199 bandwidth = 0x06; 200 else if (c->bandwidth_hz <= 7000000) 201 bandwidth = 0x07; 202 else if (c->bandwidth_hz <= 8000000) 203 bandwidth = 0x08; 204 else if (c->bandwidth_hz <= 9000000) 205 bandwidth = 0x09; 206 else if (c->bandwidth_hz <= 10000000) 207 bandwidth = 0x0a; 208 else 209 bandwidth = 0x0f; 210 211 /* program tuner */ 212 if (fe->ops.tuner_ops.set_params) { 213 ret = fe->ops.tuner_ops.set_params(fe); 214 if (ret) 215 goto err; 216 } 217 218 memcpy(cmd.args, "\x88\x02\x02\x02\x02", 5); 219 cmd.wlen = 5; 220 cmd.rlen = 5; 221 ret = si2168_cmd_execute(s, &cmd); 222 if (ret) 223 goto err; 224 225 /* that has no big effect */ 226 if (c->delivery_system == SYS_DVBT) 227 memcpy(cmd.args, "\x89\x21\x06\x11\xff\x98", 6); 228 else if (c->delivery_system == SYS_DVBC_ANNEX_A) 229 memcpy(cmd.args, "\x89\x21\x06\x11\x89\xf0", 6); 230 else if (c->delivery_system == SYS_DVBT2) 231 memcpy(cmd.args, "\x89\x21\x06\x11\x89\x20", 6); 232 cmd.wlen = 6; 233 cmd.rlen = 3; 234 ret = si2168_cmd_execute(s, &cmd); 235 if (ret) 236 goto err; 237 238 memcpy(cmd.args, "\x51\x03", 2); 239 cmd.wlen = 2; 240 cmd.rlen = 12; 241 ret = si2168_cmd_execute(s, &cmd); 242 if (ret) 243 goto err; 244 245 memcpy(cmd.args, "\x12\x08\x04", 3); 246 cmd.wlen = 3; 247 cmd.rlen = 3; 248 ret = si2168_cmd_execute(s, &cmd); 249 if (ret) 250 goto err; 251 252 memcpy(cmd.args, "\x14\x00\x0c\x10\x12\x00", 6); 253 cmd.wlen = 6; 254 cmd.rlen = 4; 255 ret = si2168_cmd_execute(s, &cmd); 256 if (ret) 257 goto err; 258 259 memcpy(cmd.args, "\x14\x00\x06\x10\x24\x00", 6); 260 cmd.wlen = 6; 261 cmd.rlen = 4; 262 ret = si2168_cmd_execute(s, &cmd); 263 if (ret) 264 goto err; 265 266 memcpy(cmd.args, "\x14\x00\x07\x10\x00\x24", 6); 267 cmd.wlen = 6; 268 cmd.rlen = 4; 269 ret = si2168_cmd_execute(s, &cmd); 270 if (ret) 271 goto err; 272 273 memcpy(cmd.args, "\x14\x00\x0a\x10\x00\x00", 6); 274 cmd.args[4] = delivery_system | bandwidth; 275 cmd.wlen = 6; 276 cmd.rlen = 4; 277 ret = si2168_cmd_execute(s, &cmd); 278 if (ret) 279 goto err; 280 281 memcpy(cmd.args, "\x14\x00\x0f\x10\x10\x00", 6); 282 cmd.wlen = 6; 283 cmd.rlen = 4; 284 ret = si2168_cmd_execute(s, &cmd); 285 if (ret) 286 goto err; 287 288 memcpy(cmd.args, "\x14\x00\x01\x10\x16\x00", 6); 289 cmd.wlen = 6; 290 cmd.rlen = 4; 291 ret = si2168_cmd_execute(s, &cmd); 292 if (ret) 293 goto err; 294 295 memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6); 296 cmd.wlen = 6; 297 cmd.rlen = 4; 298 ret = si2168_cmd_execute(s, &cmd); 299 if (ret) 300 goto err; 301 302 memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6); 303 cmd.wlen = 6; 304 cmd.rlen = 4; 305 ret = si2168_cmd_execute(s, &cmd); 306 if (ret) 307 goto err; 308 309 memcpy(cmd.args, "\x14\x00\x01\x12\x00\x00", 6); 310 cmd.wlen = 6; 311 cmd.rlen = 4; 312 ret = si2168_cmd_execute(s, &cmd); 313 if (ret) 314 goto err; 315 316 memcpy(cmd.args, "\x85", 1); 317 cmd.wlen = 1; 318 cmd.rlen = 1; 319 ret = si2168_cmd_execute(s, &cmd); 320 if (ret) 321 goto err; 322 323 s->delivery_system = c->delivery_system; 324 325 return 0; 326err: 327 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 328 return ret; 329} 330 331static int si2168_init(struct dvb_frontend *fe) 332{ 333 struct si2168 *s = fe->demodulator_priv; 334 int ret, len, remaining; 335 const struct firmware *fw = NULL; 336 u8 *fw_file; 337 const unsigned int i2c_wr_max = 8; 338 struct si2168_cmd cmd; 339 340 dev_dbg(&s->client->dev, "%s:\n", __func__); 341 342 memcpy(cmd.args, "\xc0\x12\x00\x0c\x00\x0d\x16\x00\x00\x00\x00\x00\x00", 13); 343 cmd.wlen = 13; 344 cmd.rlen = 0; 345 ret = si2168_cmd_execute(s, &cmd); 346 if (ret) 347 goto err; 348 349 memcpy(cmd.args, "\xc0\x06\x01\x0f\x00\x20\x20\x01", 8); 350 cmd.wlen = 8; 351 cmd.rlen = 1; 352 ret = si2168_cmd_execute(s, &cmd); 353 if (ret) 354 goto err; 355 356 /* query chip revision */ 357 memcpy(cmd.args, "\x02", 1); 358 cmd.wlen = 1; 359 cmd.rlen = 13; 360 ret = si2168_cmd_execute(s, &cmd); 361 if (ret) 362 goto err; 363 364 cmd.args[0] = 0x05; 365 cmd.args[1] = 0x00; 366 cmd.args[2] = 0xaa; 367 cmd.args[3] = 0x4d; 368 cmd.args[4] = 0x56; 369 cmd.args[5] = 0x40; 370 cmd.args[6] = 0x00; 371 cmd.args[7] = 0x00; 372 cmd.wlen = 8; 373 cmd.rlen = 1; 374 ret = si2168_cmd_execute(s, &cmd); 375 if (ret) 376 goto err; 377 378 if (((cmd.args[1] & 0x0f) == 2) && (cmd.args[3] == '4') && 379 (cmd.args[4] == '0')) 380 fw_file = SI2168_B40_FIRMWARE; 381 else if (((cmd.args[1] & 0x0f) == 1) && (cmd.args[3] == '3') && 382 (cmd.args[4] == '0')) 383 fw_file = SI2168_A30_FIRMWARE; 384 else { 385 dev_err(&s->client->dev, 386 "%s: no firmware file for Si2168-%c%c defined\n", 387 KBUILD_MODNAME, cmd.args[3], cmd.args[4]); 388 ret = -EINVAL; 389 goto err; 390 } 391 392 /* cold state - try to download firmware */ 393 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n", 394 KBUILD_MODNAME, si2168_ops.info.name); 395 396 /* request the firmware, this will block and timeout */ 397 ret = request_firmware(&fw, fw_file, &s->client->dev); 398 if (ret) { 399 /* fallback mechanism to handle old name for 400 SI2168_B40_FIRMWARE */ 401 if (((cmd.args[1] & 0x0f) == 2) && (cmd.args[3] == '4') && 402 (cmd.args[4] == '0')) { 403 fw_file = SI2168_B40_FIRMWARE_FALLBACK; 404 ret = request_firmware(&fw, fw_file, &s->client->dev); 405 } 406 if (ret) { 407 dev_err(&s->client->dev, "%s: firmware file '%s' not found\n", 408 KBUILD_MODNAME, fw_file); 409 goto err; 410 } 411 } 412 413 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n", 414 KBUILD_MODNAME, fw_file); 415 416 for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) { 417 len = remaining; 418 if (len > i2c_wr_max) 419 len = i2c_wr_max; 420 421 memcpy(cmd.args, &fw->data[fw->size - remaining], len); 422 cmd.wlen = len; 423 cmd.rlen = 1; 424 ret = si2168_cmd_execute(s, &cmd); 425 if (ret) { 426 dev_err(&s->client->dev, 427 "%s: firmware download failed=%d\n", 428 KBUILD_MODNAME, ret); 429 goto err; 430 } 431 } 432 433 release_firmware(fw); 434 fw = NULL; 435 436 memcpy(cmd.args, "\x01\x01", 2); 437 cmd.wlen = 2; 438 cmd.rlen = 1; 439 ret = si2168_cmd_execute(s, &cmd); 440 if (ret) 441 goto err; 442 443 dev_info(&s->client->dev, "%s: found a '%s' in warm state\n", 444 KBUILD_MODNAME, si2168_ops.info.name); 445 446 s->active = true; 447 448 return 0; 449err: 450 if (fw) 451 release_firmware(fw); 452 453 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 454 return ret; 455} 456 457static int si2168_sleep(struct dvb_frontend *fe) 458{ 459 struct si2168 *s = fe->demodulator_priv; 460 int ret; 461 struct si2168_cmd cmd; 462 463 dev_dbg(&s->client->dev, "%s:\n", __func__); 464 465 s->active = false; 466 467 memcpy(cmd.args, "\x13", 1); 468 cmd.wlen = 1; 469 cmd.rlen = 0; 470 ret = si2168_cmd_execute(s, &cmd); 471 if (ret) 472 goto err; 473 474 return 0; 475err: 476 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 477 return ret; 478} 479 480static int si2168_get_tune_settings(struct dvb_frontend *fe, 481 struct dvb_frontend_tune_settings *s) 482{ 483 s->min_delay_ms = 900; 484 485 return 0; 486} 487 488/* 489 * I2C gate logic 490 * We must use unlocked i2c_transfer() here because I2C lock is already taken 491 * by tuner driver. 492 */ 493static int si2168_select(struct i2c_adapter *adap, void *mux_priv, u32 chan) 494{ 495 struct si2168 *s = mux_priv; 496 int ret; 497 struct i2c_msg gate_open_msg = { 498 .addr = s->client->addr, 499 .flags = 0, 500 .len = 3, 501 .buf = "\xc0\x0d\x01", 502 }; 503 504 mutex_lock(&s->i2c_mutex); 505 506 /* open tuner I2C gate */ 507 ret = __i2c_transfer(s->client->adapter, &gate_open_msg, 1); 508 if (ret != 1) { 509 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 510 KBUILD_MODNAME, ret); 511 if (ret >= 0) 512 ret = -EREMOTEIO; 513 } else { 514 ret = 0; 515 } 516 517 return ret; 518} 519 520static int si2168_deselect(struct i2c_adapter *adap, void *mux_priv, u32 chan) 521{ 522 struct si2168 *s = mux_priv; 523 int ret; 524 struct i2c_msg gate_close_msg = { 525 .addr = s->client->addr, 526 .flags = 0, 527 .len = 3, 528 .buf = "\xc0\x0d\x00", 529 }; 530 531 /* close tuner I2C gate */ 532 ret = __i2c_transfer(s->client->adapter, &gate_close_msg, 1); 533 if (ret != 1) { 534 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 535 KBUILD_MODNAME, ret); 536 if (ret >= 0) 537 ret = -EREMOTEIO; 538 } else { 539 ret = 0; 540 } 541 542 mutex_unlock(&s->i2c_mutex); 543 544 return ret; 545} 546 547static const struct dvb_frontend_ops si2168_ops = { 548 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 549 .info = { 550 .name = "Silicon Labs Si2168", 551 .caps = FE_CAN_FEC_1_2 | 552 FE_CAN_FEC_2_3 | 553 FE_CAN_FEC_3_4 | 554 FE_CAN_FEC_5_6 | 555 FE_CAN_FEC_7_8 | 556 FE_CAN_FEC_AUTO | 557 FE_CAN_QPSK | 558 FE_CAN_QAM_16 | 559 FE_CAN_QAM_32 | 560 FE_CAN_QAM_64 | 561 FE_CAN_QAM_128 | 562 FE_CAN_QAM_256 | 563 FE_CAN_QAM_AUTO | 564 FE_CAN_TRANSMISSION_MODE_AUTO | 565 FE_CAN_GUARD_INTERVAL_AUTO | 566 FE_CAN_HIERARCHY_AUTO | 567 FE_CAN_MUTE_TS | 568 FE_CAN_2G_MODULATION 569 }, 570 571 .get_tune_settings = si2168_get_tune_settings, 572 573 .init = si2168_init, 574 .sleep = si2168_sleep, 575 576 .set_frontend = si2168_set_frontend, 577 578 .read_status = si2168_read_status, 579}; 580 581static int si2168_probe(struct i2c_client *client, 582 const struct i2c_device_id *id) 583{ 584 struct si2168_config *config = client->dev.platform_data; 585 struct si2168 *s; 586 int ret; 587 struct si2168_cmd cmd; 588 589 dev_dbg(&client->dev, "%s:\n", __func__); 590 591 s = kzalloc(sizeof(struct si2168), GFP_KERNEL); 592 if (!s) { 593 ret = -ENOMEM; 594 dev_err(&client->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME); 595 goto err; 596 } 597 598 s->client = client; 599 mutex_init(&s->i2c_mutex); 600 601 /* check if the demod is there */ 602 cmd.wlen = 0; 603 cmd.rlen = 1; 604 ret = si2168_cmd_execute(s, &cmd); 605 if (ret) 606 goto err; 607 608 /* create mux i2c adapter for tuner */ 609 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s, 610 0, 0, 0, si2168_select, si2168_deselect); 611 if (s->adapter == NULL) 612 goto err; 613 614 /* create dvb_frontend */ 615 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 616 s->fe.demodulator_priv = s; 617 618 *config->i2c_adapter = s->adapter; 619 *config->fe = &s->fe; 620 621 i2c_set_clientdata(client, s); 622 623 dev_info(&s->client->dev, 624 "%s: Silicon Labs Si2168 successfully attached\n", 625 KBUILD_MODNAME); 626 return 0; 627err: 628 kfree(s); 629 dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret); 630 return ret; 631} 632 633static int si2168_remove(struct i2c_client *client) 634{ 635 struct si2168 *s = i2c_get_clientdata(client); 636 637 dev_dbg(&client->dev, "%s:\n", __func__); 638 639 i2c_del_mux_adapter(s->adapter); 640 641 s->fe.ops.release = NULL; 642 s->fe.demodulator_priv = NULL; 643 644 kfree(s); 645 646 return 0; 647} 648 649static const struct i2c_device_id si2168_id[] = { 650 {"si2168", 0}, 651 {} 652}; 653MODULE_DEVICE_TABLE(i2c, si2168_id); 654 655static struct i2c_driver si2168_driver = { 656 .driver = { 657 .owner = THIS_MODULE, 658 .name = "si2168", 659 }, 660 .probe = si2168_probe, 661 .remove = si2168_remove, 662 .id_table = si2168_id, 663}; 664 665module_i2c_driver(si2168_driver); 666 667MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 668MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 669MODULE_LICENSE("GPL"); 670MODULE_FIRMWARE(SI2168_A30_FIRMWARE); 671MODULE_FIRMWARE(SI2168_B40_FIRMWARE); 672