si2168.c revision 982c6238cfb88551dc0aa730c94acfae06b25412
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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = 1; 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 = SI2168_FIRMWARE; 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 memcpy(cmd.args, "\x02", 1); 357 cmd.wlen = 1; 358 cmd.rlen = 13; 359 ret = si2168_cmd_execute(s, &cmd); 360 if (ret) 361 goto err; 362 363 cmd.args[0] = 0x05; 364 cmd.args[1] = 0x00; 365 cmd.args[2] = 0xaa; 366 cmd.args[3] = 0x4d; 367 cmd.args[4] = 0x56; 368 cmd.args[5] = 0x40; 369 cmd.args[6] = 0x00; 370 cmd.args[7] = 0x00; 371 cmd.wlen = 8; 372 cmd.rlen = 1; 373 ret = si2168_cmd_execute(s, &cmd); 374 if (ret) 375 goto err; 376 377 /* cold state - try to download firmware */ 378 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n", 379 KBUILD_MODNAME, si2168_ops.info.name); 380 381 /* request the firmware, this will block and timeout */ 382 ret = request_firmware(&fw, fw_file, &s->client->dev); 383 if (ret) { 384 dev_err(&s->client->dev, "%s: firmare file '%s' not found\n", 385 KBUILD_MODNAME, fw_file); 386 goto err; 387 } 388 389 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n", 390 KBUILD_MODNAME, fw_file); 391 392 for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) { 393 len = remaining; 394 if (len > i2c_wr_max) 395 len = i2c_wr_max; 396 397 memcpy(cmd.args, &fw->data[fw->size - remaining], len); 398 cmd.wlen = len; 399 cmd.rlen = 1; 400 ret = si2168_cmd_execute(s, &cmd); 401 if (ret) { 402 dev_err(&s->client->dev, 403 "%s: firmware download failed=%d\n", 404 KBUILD_MODNAME, ret); 405 goto err; 406 } 407 } 408 409 release_firmware(fw); 410 fw = NULL; 411 412 memcpy(cmd.args, "\x01\x01", 2); 413 cmd.wlen = 2; 414 cmd.rlen = 1; 415 ret = si2168_cmd_execute(s, &cmd); 416 if (ret) 417 goto err; 418 419 dev_info(&s->client->dev, "%s: found a '%s' in warm state\n", 420 KBUILD_MODNAME, si2168_ops.info.name); 421 422 s->active = true; 423 424 return 0; 425err: 426 if (fw) 427 release_firmware(fw); 428 429 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 430 return ret; 431} 432 433static int si2168_sleep(struct dvb_frontend *fe) 434{ 435 struct si2168 *s = fe->demodulator_priv; 436 int ret; 437 struct si2168_cmd cmd; 438 439 dev_dbg(&s->client->dev, "%s:\n", __func__); 440 441 s->active = false; 442 443 memcpy(cmd.args, "\x13", 1); 444 cmd.wlen = 1; 445 cmd.rlen = 0; 446 ret = si2168_cmd_execute(s, &cmd); 447 if (ret) 448 goto err; 449 450 return 0; 451err: 452 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 453 return ret; 454} 455 456static int si2168_get_tune_settings(struct dvb_frontend *fe, 457 struct dvb_frontend_tune_settings *s) 458{ 459 s->min_delay_ms = 900; 460 461 return 0; 462} 463 464/* 465 * I2C gate logic 466 * We must use unlocked i2c_transfer() here because I2C lock is already taken 467 * by tuner driver. 468 */ 469static int si2168_select(struct i2c_adapter *adap, void *mux_priv, u32 chan) 470{ 471 struct si2168 *s = mux_priv; 472 int ret; 473 struct i2c_msg gate_open_msg = { 474 .addr = s->client->addr, 475 .flags = 0, 476 .len = 3, 477 .buf = "\xc0\x0d\x01", 478 }; 479 480 mutex_lock(&s->i2c_mutex); 481 482 /* open tuner I2C gate */ 483 ret = __i2c_transfer(s->client->adapter, &gate_open_msg, 1); 484 if (ret != 1) { 485 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 486 KBUILD_MODNAME, ret); 487 if (ret >= 0) 488 ret = -EREMOTEIO; 489 } else { 490 ret = 0; 491 } 492 493 return ret; 494} 495 496static int si2168_deselect(struct i2c_adapter *adap, void *mux_priv, u32 chan) 497{ 498 struct si2168 *s = mux_priv; 499 int ret; 500 struct i2c_msg gate_close_msg = { 501 .addr = s->client->addr, 502 .flags = 0, 503 .len = 3, 504 .buf = "\xc0\x0d\x00", 505 }; 506 507 /* close tuner I2C gate */ 508 ret = __i2c_transfer(s->client->adapter, &gate_close_msg, 1); 509 if (ret != 1) { 510 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 511 KBUILD_MODNAME, ret); 512 if (ret >= 0) 513 ret = -EREMOTEIO; 514 } else { 515 ret = 0; 516 } 517 518 mutex_unlock(&s->i2c_mutex); 519 520 return ret; 521} 522 523static const struct dvb_frontend_ops si2168_ops = { 524 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 525 .info = { 526 .name = "Silicon Labs Si2168", 527 .caps = FE_CAN_FEC_1_2 | 528 FE_CAN_FEC_2_3 | 529 FE_CAN_FEC_3_4 | 530 FE_CAN_FEC_5_6 | 531 FE_CAN_FEC_7_8 | 532 FE_CAN_FEC_AUTO | 533 FE_CAN_QPSK | 534 FE_CAN_QAM_16 | 535 FE_CAN_QAM_32 | 536 FE_CAN_QAM_64 | 537 FE_CAN_QAM_128 | 538 FE_CAN_QAM_256 | 539 FE_CAN_QAM_AUTO | 540 FE_CAN_TRANSMISSION_MODE_AUTO | 541 FE_CAN_GUARD_INTERVAL_AUTO | 542 FE_CAN_HIERARCHY_AUTO | 543 FE_CAN_MUTE_TS | 544 FE_CAN_2G_MODULATION 545 }, 546 547 .get_tune_settings = si2168_get_tune_settings, 548 549 .init = si2168_init, 550 .sleep = si2168_sleep, 551 552 .set_frontend = si2168_set_frontend, 553 554 .read_status = si2168_read_status, 555}; 556 557static int si2168_probe(struct i2c_client *client, 558 const struct i2c_device_id *id) 559{ 560 struct si2168_config *config = client->dev.platform_data; 561 struct si2168 *s; 562 int ret; 563 struct si2168_cmd cmd; 564 565 dev_dbg(&client->dev, "%s:\n", __func__); 566 567 s = kzalloc(sizeof(struct si2168), GFP_KERNEL); 568 if (!s) { 569 ret = -ENOMEM; 570 dev_err(&client->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME); 571 goto err; 572 } 573 574 s->client = client; 575 mutex_init(&s->i2c_mutex); 576 577 /* check if the demod is there */ 578 cmd.wlen = 0; 579 cmd.rlen = 1; 580 ret = si2168_cmd_execute(s, &cmd); 581 if (ret) 582 goto err; 583 584 /* create mux i2c adapter for tuner */ 585 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s, 586 0, 0, 0, si2168_select, si2168_deselect); 587 if (s->adapter == NULL) 588 goto err; 589 590 /* create dvb_frontend */ 591 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 592 s->fe.demodulator_priv = s; 593 594 *config->i2c_adapter = s->adapter; 595 *config->fe = &s->fe; 596 597 i2c_set_clientdata(client, s); 598 599 dev_info(&s->client->dev, 600 "%s: Silicon Labs Si2168 successfully attached\n", 601 KBUILD_MODNAME); 602 return 0; 603err: 604 kfree(s); 605 dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret); 606 return ret; 607} 608 609static int si2168_remove(struct i2c_client *client) 610{ 611 struct si2168 *s = i2c_get_clientdata(client); 612 613 dev_dbg(&client->dev, "%s:\n", __func__); 614 615 i2c_del_mux_adapter(s->adapter); 616 617 s->fe.ops.release = NULL; 618 s->fe.demodulator_priv = NULL; 619 620 kfree(s); 621 622 return 0; 623} 624 625static const struct i2c_device_id si2168_id[] = { 626 {"si2168", 0}, 627 {} 628}; 629MODULE_DEVICE_TABLE(i2c, si2168_id); 630 631static struct i2c_driver si2168_driver = { 632 .driver = { 633 .owner = THIS_MODULE, 634 .name = "si2168", 635 }, 636 .probe = si2168_probe, 637 .remove = si2168_remove, 638 .id_table = si2168_id, 639}; 640 641module_i2c_driver(si2168_driver); 642 643MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 644MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 645MODULE_LICENSE("GPL"); 646MODULE_FIRMWARE(SI2168_FIRMWARE); 647