1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Silicon Labs Si2168 DVB-T/T2/C demodulator driver 4 * 5 * Copyright (C) 2014 Antti Palosaari <crope@iki.fi> 6 */ 7 8 #include <linux/delay.h> 9 10 #include "si2168_priv.h" 11 12 static const struct dvb_frontend_ops si2168_ops; 13 14 static void cmd_init(struct si2168_cmd *cmd, const u8 *buf, int wlen, int rlen) 15 { 16 memcpy(cmd->args, buf, wlen); 17 cmd->wlen = wlen; 18 cmd->rlen = rlen; 19 } 20 21 /* execute firmware command */ 22 static int si2168_cmd_execute(struct i2c_client *client, struct si2168_cmd *cmd) 23 { 24 struct si2168_dev *dev = i2c_get_clientdata(client); 25 int ret; 26 unsigned long timeout; 27 28 mutex_lock(&dev->i2c_mutex); 29 30 if (cmd->wlen) { 31 /* write cmd and args for firmware */ 32 ret = i2c_master_send(client, cmd->args, cmd->wlen); 33 if (ret < 0) { 34 goto err_mutex_unlock; 35 } else if (ret != cmd->wlen) { 36 ret = -EREMOTEIO; 37 goto err_mutex_unlock; 38 } 39 } 40 41 if (cmd->rlen) { 42 /* wait cmd execution terminate */ 43 #define TIMEOUT 140 44 timeout = jiffies + msecs_to_jiffies(TIMEOUT); 45 while (!time_after(jiffies, timeout)) { 46 ret = i2c_master_recv(client, cmd->args, cmd->rlen); 47 if (ret < 0) { 48 goto err_mutex_unlock; 49 } else if (ret != cmd->rlen) { 50 ret = -EREMOTEIO; 51 goto err_mutex_unlock; 52 } 53 54 /* firmware ready? */ 55 if ((cmd->args[0] >> 7) & 0x01) 56 break; 57 58 usleep_range(2500, 3500); 59 } 60 61 dev_dbg(&client->dev, "cmd execution took %d ms\n", 62 jiffies_to_msecs(jiffies) - 63 (jiffies_to_msecs(timeout) - TIMEOUT)); 64 65 /* error bit set? */ 66 if ((cmd->args[0] >> 6) & 0x01) { 67 ret = -EREMOTEIO; 68 goto err_mutex_unlock; 69 } 70 71 if (!((cmd->args[0] >> 7) & 0x01)) { 72 ret = -ETIMEDOUT; 73 goto err_mutex_unlock; 74 } 75 } 76 77 mutex_unlock(&dev->i2c_mutex); 78 return 0; 79 err_mutex_unlock: 80 mutex_unlock(&dev->i2c_mutex); 81 dev_dbg(&client->dev, "failed=%d\n", ret); 82 return ret; 83 } 84 85 static int si2168_ts_bus_ctrl(struct dvb_frontend *fe, int acquire) 86 { 87 struct i2c_client *client = fe->demodulator_priv; 88 struct si2168_dev *dev = i2c_get_clientdata(client); 89 struct si2168_cmd cmd; 90 int ret = 0; 91 92 dev_dbg(&client->dev, "%s acquire: %d\n", __func__, acquire); 93 94 /* set manual value */ 95 if (dev->ts_mode & SI2168_TS_CLK_MANUAL) { 96 cmd_init(&cmd, "\x14\x00\x0d\x10\xe8\x03", 6, 4); 97 ret = si2168_cmd_execute(client, &cmd); 98 if (ret) 99 return ret; 100 } 101 /* set TS_MODE property */ 102 cmd_init(&cmd, "\x14\x00\x01\x10\x10\x00", 6, 4); 103 if (dev->ts_mode & SI2168_TS_CLK_MANUAL) 104 cmd.args[4] = SI2168_TS_CLK_MANUAL; 105 if (acquire) 106 cmd.args[4] |= dev->ts_mode; 107 else 108 cmd.args[4] |= SI2168_TS_TRISTATE; 109 if (dev->ts_clock_gapped) 110 cmd.args[4] |= 0x40; 111 ret = si2168_cmd_execute(client, &cmd); 112 113 return ret; 114 } 115 116 static int si2168_read_status(struct dvb_frontend *fe, enum fe_status *status) 117 { 118 struct i2c_client *client = fe->demodulator_priv; 119 struct si2168_dev *dev = i2c_get_clientdata(client); 120 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 121 int ret, i; 122 unsigned int utmp, utmp1, utmp2; 123 struct si2168_cmd cmd; 124 125 *status = 0; 126 127 if (!dev->active) { 128 ret = -EAGAIN; 129 goto err; 130 } 131 132 switch (c->delivery_system) { 133 case SYS_DVBT: 134 cmd_init(&cmd, "\xa0\x01", 2, 13); 135 break; 136 case SYS_DVBC_ANNEX_A: 137 cmd_init(&cmd, "\x90\x01", 2, 9); 138 break; 139 case SYS_DVBT2: 140 cmd_init(&cmd, "\x50\x01", 2, 14); 141 break; 142 default: 143 ret = -EINVAL; 144 goto err; 145 } 146 147 ret = si2168_cmd_execute(client, &cmd); 148 if (ret) 149 goto err; 150 151 switch ((cmd.args[2] >> 1) & 0x03) { 152 case 0x01: 153 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 154 break; 155 case 0x03: 156 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | 157 FE_HAS_SYNC | FE_HAS_LOCK; 158 break; 159 } 160 161 dev->fe_status = *status; 162 163 if (*status & FE_HAS_LOCK) { 164 c->cnr.len = 1; 165 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 166 c->cnr.stat[0].svalue = cmd.args[3] * 1000 / 4; 167 } else { 168 c->cnr.len = 1; 169 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 170 } 171 172 dev_dbg(&client->dev, "status=%02x args=%*ph\n", 173 *status, cmd.rlen, cmd.args); 174 175 /* BER */ 176 if (*status & FE_HAS_VITERBI) { 177 cmd_init(&cmd, "\x82\x00", 2, 3); 178 ret = si2168_cmd_execute(client, &cmd); 179 if (ret) 180 goto err; 181 182 /* 183 * Firmware returns [0, 255] mantissa and [0, 8] exponent. 184 * Convert to DVB API: mantissa * 10^(8 - exponent) / 10^8 185 */ 186 utmp = clamp(8 - cmd.args[1], 0, 8); 187 for (i = 0, utmp1 = 1; i < utmp; i++) 188 utmp1 = utmp1 * 10; 189 190 utmp1 = cmd.args[2] * utmp1; 191 utmp2 = 100000000; /* 10^8 */ 192 193 dev_dbg(&client->dev, 194 "post_bit_error=%u post_bit_count=%u ber=%u*10^-%u\n", 195 utmp1, utmp2, cmd.args[2], cmd.args[1]); 196 197 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER; 198 c->post_bit_error.stat[0].uvalue += utmp1; 199 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER; 200 c->post_bit_count.stat[0].uvalue += utmp2; 201 } else { 202 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 203 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 204 } 205 206 /* UCB */ 207 if (*status & FE_HAS_SYNC) { 208 cmd_init(&cmd, "\x84\x01", 2, 3); 209 ret = si2168_cmd_execute(client, &cmd); 210 if (ret) 211 goto err; 212 213 utmp1 = cmd.args[2] << 8 | cmd.args[1] << 0; 214 dev_dbg(&client->dev, "block_error=%u\n", utmp1); 215 216 /* Sometimes firmware returns bogus value */ 217 if (utmp1 == 0xffff) 218 utmp1 = 0; 219 220 c->block_error.stat[0].scale = FE_SCALE_COUNTER; 221 c->block_error.stat[0].uvalue += utmp1; 222 } else { 223 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 224 } 225 226 return 0; 227 err: 228 dev_dbg(&client->dev, "failed=%d\n", ret); 229 return ret; 230 } 231 232 static int si2168_set_frontend(struct dvb_frontend *fe) 233 { 234 struct i2c_client *client = fe->demodulator_priv; 235 struct si2168_dev *dev = i2c_get_clientdata(client); 236 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 237 int ret; 238 struct si2168_cmd cmd; 239 u8 bandwidth, delivery_system; 240 241 dev_dbg(&client->dev, 242 "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%u stream_id=%u\n", 243 c->delivery_system, c->modulation, c->frequency, 244 c->bandwidth_hz, c->symbol_rate, c->inversion, 245 c->stream_id); 246 247 if (!dev->active) { 248 ret = -EAGAIN; 249 goto err; 250 } 251 252 switch (c->delivery_system) { 253 case SYS_DVBT: 254 delivery_system = 0x20; 255 break; 256 case SYS_DVBC_ANNEX_A: 257 delivery_system = 0x30; 258 break; 259 case SYS_DVBT2: 260 delivery_system = 0x70; 261 break; 262 default: 263 ret = -EINVAL; 264 goto err; 265 } 266 267 if (c->bandwidth_hz == 0) { 268 ret = -EINVAL; 269 goto err; 270 } else if (c->bandwidth_hz <= 2000000) 271 bandwidth = 0x02; 272 else if (c->bandwidth_hz <= 5000000) 273 bandwidth = 0x05; 274 else if (c->bandwidth_hz <= 6000000) 275 bandwidth = 0x06; 276 else if (c->bandwidth_hz <= 7000000) 277 bandwidth = 0x07; 278 else if (c->bandwidth_hz <= 8000000) 279 bandwidth = 0x08; 280 else if (c->bandwidth_hz <= 9000000) 281 bandwidth = 0x09; 282 else if (c->bandwidth_hz <= 10000000) 283 bandwidth = 0x0a; 284 else 285 bandwidth = 0x0f; 286 287 /* program tuner */ 288 if (fe->ops.tuner_ops.set_params) { 289 ret = fe->ops.tuner_ops.set_params(fe); 290 if (ret) 291 goto err; 292 } 293 294 cmd_init(&cmd, "\x88\x02\x02\x02\x02", 5, 5); 295 ret = si2168_cmd_execute(client, &cmd); 296 if (ret) 297 goto err; 298 299 /* that has no big effect */ 300 if (c->delivery_system == SYS_DVBT) 301 cmd_init(&cmd, "\x89\x21\x06\x11\xff\x98", 6, 3); 302 else if (c->delivery_system == SYS_DVBC_ANNEX_A) 303 cmd_init(&cmd, "\x89\x21\x06\x11\x89\xf0", 6, 3); 304 else if (c->delivery_system == SYS_DVBT2) 305 cmd_init(&cmd, "\x89\x21\x06\x11\x89\x20", 6, 3); 306 ret = si2168_cmd_execute(client, &cmd); 307 if (ret) 308 goto err; 309 310 if (c->delivery_system == SYS_DVBT2) { 311 /* select PLP */ 312 cmd.args[0] = 0x52; 313 cmd.args[1] = c->stream_id & 0xff; 314 cmd.args[2] = c->stream_id == NO_STREAM_ID_FILTER ? 0 : 1; 315 cmd.wlen = 3; 316 cmd.rlen = 1; 317 ret = si2168_cmd_execute(client, &cmd); 318 if (ret) 319 goto err; 320 } 321 322 cmd_init(&cmd, "\x51\x03", 2, 12); 323 ret = si2168_cmd_execute(client, &cmd); 324 if (ret) 325 goto err; 326 327 cmd_init(&cmd, "\x12\x08\x04", 3, 3); 328 ret = si2168_cmd_execute(client, &cmd); 329 if (ret) 330 goto err; 331 332 cmd_init(&cmd, "\x14\x00\x0c\x10\x12\x00", 6, 4); 333 ret = si2168_cmd_execute(client, &cmd); 334 if (ret) 335 goto err; 336 337 cmd_init(&cmd, "\x14\x00\x06\x10\x24\x00", 6, 4); 338 ret = si2168_cmd_execute(client, &cmd); 339 if (ret) 340 goto err; 341 342 cmd_init(&cmd, "\x14\x00\x07\x10\x00\x24", 6, 4); 343 ret = si2168_cmd_execute(client, &cmd); 344 if (ret) 345 goto err; 346 347 cmd_init(&cmd, "\x14\x00\x0a\x10\x00\x00", 6, 4); 348 cmd.args[4] = delivery_system | bandwidth; 349 if (dev->spectral_inversion) 350 cmd.args[5] |= 1; 351 ret = si2168_cmd_execute(client, &cmd); 352 if (ret) 353 goto err; 354 355 /* set DVB-C symbol rate */ 356 if (c->delivery_system == SYS_DVBC_ANNEX_A) { 357 cmd_init(&cmd, "\x14\x00\x02\x11\x00\x00", 6, 4); 358 cmd.args[4] = ((c->symbol_rate / 1000) >> 0) & 0xff; 359 cmd.args[5] = ((c->symbol_rate / 1000) >> 8) & 0xff; 360 ret = si2168_cmd_execute(client, &cmd); 361 if (ret) 362 goto err; 363 } 364 365 cmd_init(&cmd, "\x14\x00\x0f\x10\x10\x00", 6, 4); 366 ret = si2168_cmd_execute(client, &cmd); 367 if (ret) 368 goto err; 369 370 cmd_init(&cmd, "\x14\x00\x09\x10\xe3\x08", 6, 4); 371 cmd.args[5] |= dev->ts_clock_inv ? 0x00 : 0x10; 372 ret = si2168_cmd_execute(client, &cmd); 373 if (ret) 374 goto err; 375 376 cmd_init(&cmd, "\x14\x00\x08\x10\xd7\x05", 6, 4); 377 cmd.args[5] |= dev->ts_clock_inv ? 0x00 : 0x10; 378 ret = si2168_cmd_execute(client, &cmd); 379 if (ret) 380 goto err; 381 382 cmd_init(&cmd, "\x14\x00\x01\x12\x00\x00", 6, 4); 383 ret = si2168_cmd_execute(client, &cmd); 384 if (ret) 385 goto err; 386 387 cmd_init(&cmd, "\x14\x00\x01\x03\x0c\x00", 6, 4); 388 ret = si2168_cmd_execute(client, &cmd); 389 if (ret) 390 goto err; 391 392 cmd_init(&cmd, "\x85", 1, 1); 393 ret = si2168_cmd_execute(client, &cmd); 394 if (ret) 395 goto err; 396 397 dev->delivery_system = c->delivery_system; 398 399 /* enable ts bus */ 400 ret = si2168_ts_bus_ctrl(fe, 1); 401 if (ret) 402 goto err; 403 404 return 0; 405 err: 406 dev_dbg(&client->dev, "failed=%d\n", ret); 407 return ret; 408 } 409 410 static int si2168_init(struct dvb_frontend *fe) 411 { 412 struct i2c_client *client = fe->demodulator_priv; 413 struct si2168_dev *dev = i2c_get_clientdata(client); 414 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 415 int ret, len, remaining; 416 const struct firmware *fw; 417 struct si2168_cmd cmd; 418 419 dev_dbg(&client->dev, "\n"); 420 421 /* initialize */ 422 cmd_init(&cmd, "\xc0\x12\x00\x0c\x00\x0d\x16\x00\x00\x00\x00\x00\x00", 423 13, 0); 424 ret = si2168_cmd_execute(client, &cmd); 425 if (ret) 426 goto err; 427 428 if (dev->warm) { 429 /* resume */ 430 cmd_init(&cmd, "\xc0\x06\x08\x0f\x00\x20\x21\x01", 8, 1); 431 ret = si2168_cmd_execute(client, &cmd); 432 if (ret) 433 goto err; 434 435 udelay(100); 436 cmd_init(&cmd, "\x85", 1, 1); 437 ret = si2168_cmd_execute(client, &cmd); 438 if (ret) 439 goto err; 440 441 goto warm; 442 } 443 444 /* power up */ 445 cmd_init(&cmd, "\xc0\x06\x01\x0f\x00\x20\x20\x01", 8, 1); 446 ret = si2168_cmd_execute(client, &cmd); 447 if (ret) 448 goto err; 449 450 /* request the firmware, this will block and timeout */ 451 ret = request_firmware(&fw, dev->firmware_name, &client->dev); 452 if (ret) { 453 dev_err(&client->dev, 454 "firmware file '%s' not found\n", 455 dev->firmware_name); 456 goto err_release_firmware; 457 } 458 459 dev_info(&client->dev, "downloading firmware from file '%s'\n", 460 dev->firmware_name); 461 462 if ((fw->size % 17 == 0) && (fw->data[0] > 5)) { 463 /* firmware is in the new format */ 464 for (remaining = fw->size; remaining > 0; remaining -= 17) { 465 len = fw->data[fw->size - remaining]; 466 if (len > SI2168_ARGLEN) { 467 ret = -EINVAL; 468 break; 469 } 470 cmd_init(&cmd, &fw->data[(fw->size - remaining) + 1], 471 len, 1); 472 ret = si2168_cmd_execute(client, &cmd); 473 if (ret) 474 break; 475 } 476 } else if (fw->size % 8 == 0) { 477 /* firmware is in the old format */ 478 for (remaining = fw->size; remaining > 0; remaining -= 8) { 479 cmd_init(&cmd, &fw->data[fw->size - remaining], 8, 1); 480 ret = si2168_cmd_execute(client, &cmd); 481 if (ret) 482 break; 483 } 484 } else { 485 /* bad or unknown firmware format */ 486 ret = -EINVAL; 487 } 488 489 if (ret) { 490 dev_err(&client->dev, "firmware download failed %d\n", ret); 491 goto err_release_firmware; 492 } 493 494 release_firmware(fw); 495 496 cmd_init(&cmd, "\x01\x01", 2, 1); 497 ret = si2168_cmd_execute(client, &cmd); 498 if (ret) 499 goto err; 500 501 /* query firmware version */ 502 cmd_init(&cmd, "\x11", 1, 10); 503 ret = si2168_cmd_execute(client, &cmd); 504 if (ret) 505 goto err; 506 507 dev->version = (cmd.args[9] + '@') << 24 | (cmd.args[6] - '0') << 16 | 508 (cmd.args[7] - '0') << 8 | (cmd.args[8]) << 0; 509 dev_info(&client->dev, "firmware version: %c %d.%d.%d\n", 510 dev->version >> 24 & 0xff, dev->version >> 16 & 0xff, 511 dev->version >> 8 & 0xff, dev->version >> 0 & 0xff); 512 513 /* set ts mode */ 514 ret = si2168_ts_bus_ctrl(fe, 1); 515 if (ret) 516 goto err; 517 518 dev->warm = true; 519 dev->initialized = true; 520 warm: 521 /* Init stats here to indicate which stats are supported */ 522 c->cnr.len = 1; 523 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 524 c->post_bit_error.len = 1; 525 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 526 c->post_bit_count.len = 1; 527 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 528 c->block_error.len = 1; 529 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 530 531 dev->active = true; 532 533 return 0; 534 err_release_firmware: 535 release_firmware(fw); 536 err: 537 dev_dbg(&client->dev, "failed=%d\n", ret); 538 return ret; 539 } 540 541 static int si2168_resume(struct dvb_frontend *fe) 542 { 543 struct i2c_client *client = fe->demodulator_priv; 544 struct si2168_dev *dev = i2c_get_clientdata(client); 545 546 /* 547 * check whether si2168_init() has been called successfully 548 * outside of a resume cycle. Only call it (and load firmware) 549 * in this case. si2168_init() is only called during resume 550 * once the device has actually been used. Otherwise, leave the 551 * device untouched. 552 */ 553 if (dev->initialized) { 554 dev_dbg(&client->dev, "previously initialized, call si2168_init()\n"); 555 return si2168_init(fe); 556 } 557 dev_dbg(&client->dev, "not initialized yet, skipping init on resume\n"); 558 return 0; 559 } 560 561 static int si2168_sleep(struct dvb_frontend *fe) 562 { 563 struct i2c_client *client = fe->demodulator_priv; 564 struct si2168_dev *dev = i2c_get_clientdata(client); 565 int ret; 566 struct si2168_cmd cmd; 567 568 dev_dbg(&client->dev, "\n"); 569 570 dev->active = false; 571 572 /* tri-state data bus */ 573 ret = si2168_ts_bus_ctrl(fe, 0); 574 if (ret) 575 goto err; 576 577 /* Firmware B 4.0-11 and later lose warm state during sleep */ 578 if (dev->version >= ('B' << 24 | 4 << 16 | 0 << 8 | 11 << 0)) 579 dev->warm = false; 580 581 cmd_init(&cmd, "\x13", 1, 0); 582 ret = si2168_cmd_execute(client, &cmd); 583 if (ret) 584 goto err; 585 586 return 0; 587 err: 588 dev_dbg(&client->dev, "failed=%d\n", ret); 589 return ret; 590 } 591 592 static int si2168_get_tune_settings(struct dvb_frontend *fe, 593 struct dvb_frontend_tune_settings *s) 594 { 595 s->min_delay_ms = 900; 596 597 return 0; 598 } 599 600 static int si2168_select(struct i2c_mux_core *muxc, u32 chan) 601 { 602 struct i2c_client *client = i2c_mux_priv(muxc); 603 int ret; 604 struct si2168_cmd cmd; 605 606 /* open I2C gate */ 607 cmd_init(&cmd, "\xc0\x0d\x01", 3, 0); 608 ret = si2168_cmd_execute(client, &cmd); 609 if (ret) 610 goto err; 611 612 return 0; 613 err: 614 dev_dbg(&client->dev, "failed=%d\n", ret); 615 return ret; 616 } 617 618 static int si2168_deselect(struct i2c_mux_core *muxc, u32 chan) 619 { 620 struct i2c_client *client = i2c_mux_priv(muxc); 621 int ret; 622 struct si2168_cmd cmd; 623 624 /* close I2C gate */ 625 cmd_init(&cmd, "\xc0\x0d\x00", 3, 0); 626 ret = si2168_cmd_execute(client, &cmd); 627 if (ret) 628 goto err; 629 630 return 0; 631 err: 632 dev_dbg(&client->dev, "failed=%d\n", ret); 633 return ret; 634 } 635 636 static const struct dvb_frontend_ops si2168_ops = { 637 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 638 .info = { 639 .name = "Silicon Labs Si2168", 640 .frequency_min_hz = 48 * MHz, 641 .frequency_max_hz = 870 * MHz, 642 .frequency_stepsize_hz = 62500, 643 .symbol_rate_min = 1000000, 644 .symbol_rate_max = 7200000, 645 .caps = FE_CAN_FEC_1_2 | 646 FE_CAN_FEC_2_3 | 647 FE_CAN_FEC_3_4 | 648 FE_CAN_FEC_5_6 | 649 FE_CAN_FEC_7_8 | 650 FE_CAN_FEC_AUTO | 651 FE_CAN_QPSK | 652 FE_CAN_QAM_16 | 653 FE_CAN_QAM_32 | 654 FE_CAN_QAM_64 | 655 FE_CAN_QAM_128 | 656 FE_CAN_QAM_256 | 657 FE_CAN_QAM_AUTO | 658 FE_CAN_TRANSMISSION_MODE_AUTO | 659 FE_CAN_GUARD_INTERVAL_AUTO | 660 FE_CAN_HIERARCHY_AUTO | 661 FE_CAN_MUTE_TS | 662 FE_CAN_2G_MODULATION | 663 FE_CAN_MULTISTREAM 664 }, 665 666 .get_tune_settings = si2168_get_tune_settings, 667 668 .init = si2168_init, 669 .sleep = si2168_sleep, 670 .resume = si2168_resume, 671 672 .set_frontend = si2168_set_frontend, 673 674 .read_status = si2168_read_status, 675 }; 676 677 static int si2168_probe(struct i2c_client *client) 678 { 679 struct si2168_config *config = client->dev.platform_data; 680 struct si2168_dev *dev; 681 int ret; 682 struct si2168_cmd cmd; 683 684 dev_dbg(&client->dev, "\n"); 685 686 dev = kzalloc_obj(*dev); 687 if (!dev) { 688 ret = -ENOMEM; 689 goto err; 690 } 691 692 i2c_set_clientdata(client, dev); 693 mutex_init(&dev->i2c_mutex); 694 695 /* Initialize */ 696 cmd_init(&cmd, "\xc0\x12\x00\x0c\x00\x0d\x16\x00\x00\x00\x00\x00\x00", 697 13, 0); 698 ret = si2168_cmd_execute(client, &cmd); 699 if (ret) 700 goto err_kfree; 701 702 /* Power up */ 703 cmd_init(&cmd, "\xc0\x06\x01\x0f\x00\x20\x20\x01", 8, 1); 704 ret = si2168_cmd_execute(client, &cmd); 705 if (ret) 706 goto err_kfree; 707 708 /* Query chip revision */ 709 cmd_init(&cmd, "\x02", 1, 13); 710 ret = si2168_cmd_execute(client, &cmd); 711 if (ret) 712 goto err_kfree; 713 714 dev->chip_id = cmd.args[1] << 24 | cmd.args[2] << 16 | 715 cmd.args[3] << 8 | cmd.args[4] << 0; 716 717 switch (dev->chip_id) { 718 case SI2168_CHIP_ID_A20: 719 dev->firmware_name = SI2168_A20_FIRMWARE; 720 break; 721 case SI2168_CHIP_ID_A30: 722 dev->firmware_name = SI2168_A30_FIRMWARE; 723 break; 724 case SI2168_CHIP_ID_B40: 725 dev->firmware_name = SI2168_B40_FIRMWARE; 726 break; 727 case SI2168_CHIP_ID_D60: 728 dev->firmware_name = SI2168_D60_FIRMWARE; 729 break; 730 default: 731 dev_dbg(&client->dev, "unknown chip version Si21%d-%c%c%c\n", 732 cmd.args[2], cmd.args[1], cmd.args[3], cmd.args[4]); 733 ret = -ENODEV; 734 goto err_kfree; 735 } 736 737 dev->version = (cmd.args[1]) << 24 | (cmd.args[3] - '0') << 16 | 738 (cmd.args[4] - '0') << 8 | (cmd.args[5]) << 0; 739 740 /* create mux i2c adapter for tuner */ 741 dev->muxc = i2c_mux_alloc(client->adapter, &client->dev, 742 1, 0, I2C_MUX_LOCKED, 743 si2168_select, si2168_deselect); 744 if (!dev->muxc) { 745 ret = -ENOMEM; 746 goto err_kfree; 747 } 748 dev->muxc->priv = client; 749 ret = i2c_mux_add_adapter(dev->muxc, 0, 0); 750 if (ret) 751 goto err_kfree; 752 753 /* create dvb_frontend */ 754 memcpy(&dev->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 755 dev->fe.demodulator_priv = client; 756 *config->i2c_adapter = dev->muxc->adapter[0]; 757 *config->fe = &dev->fe; 758 dev->ts_mode = config->ts_mode; 759 dev->ts_clock_inv = config->ts_clock_inv; 760 dev->ts_clock_gapped = config->ts_clock_gapped; 761 dev->spectral_inversion = config->spectral_inversion; 762 763 dev_info(&client->dev, "Silicon Labs Si2168-%c%d%d successfully identified\n", 764 dev->version >> 24 & 0xff, dev->version >> 16 & 0xff, 765 dev->version >> 8 & 0xff); 766 dev_info(&client->dev, "firmware version: %c %d.%d.%d\n", 767 dev->version >> 24 & 0xff, dev->version >> 16 & 0xff, 768 dev->version >> 8 & 0xff, dev->version >> 0 & 0xff); 769 770 return 0; 771 err_kfree: 772 kfree(dev); 773 err: 774 dev_warn(&client->dev, "probe failed = %d\n", ret); 775 return ret; 776 } 777 778 static void si2168_remove(struct i2c_client *client) 779 { 780 struct si2168_dev *dev = i2c_get_clientdata(client); 781 782 dev_dbg(&client->dev, "\n"); 783 784 i2c_mux_del_adapters(dev->muxc); 785 786 dev->fe.ops.release = NULL; 787 dev->fe.demodulator_priv = NULL; 788 789 kfree(dev); 790 } 791 792 static const struct i2c_device_id si2168_id_table[] = { 793 { "si2168" }, 794 {} 795 }; 796 MODULE_DEVICE_TABLE(i2c, si2168_id_table); 797 798 static struct i2c_driver si2168_driver = { 799 .driver = { 800 .name = "si2168", 801 .suppress_bind_attrs = true, 802 }, 803 .probe = si2168_probe, 804 .remove = si2168_remove, 805 .id_table = si2168_id_table, 806 }; 807 808 module_i2c_driver(si2168_driver); 809 810 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 811 MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 812 MODULE_LICENSE("GPL"); 813 MODULE_FIRMWARE(SI2168_A20_FIRMWARE); 814 MODULE_FIRMWARE(SI2168_A30_FIRMWARE); 815 MODULE_FIRMWARE(SI2168_B40_FIRMWARE); 816 MODULE_FIRMWARE(SI2168_D60_FIRMWARE); 817