si2168.c revision 4de0ed7cf7a49384f3438a39543fb85d6dcd3bfc
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 cmd.args[0] = 0xa0; 99 cmd.args[1] = 0x01; 100 cmd.wlen = 2; 101 cmd.rlen = 13; 102 break; 103 case SYS_DVBC_ANNEX_A: 104 cmd.args[0] = 0x90; 105 cmd.args[1] = 0x01; 106 cmd.wlen = 2; 107 cmd.rlen = 9; 108 break; 109 case SYS_DVBT2: 110 cmd.args[0] = 0x50; 111 cmd.args[1] = 0x01; 112 cmd.wlen = 2; 113 cmd.rlen = 14; 114 break; 115 default: 116 ret = -EINVAL; 117 goto err; 118 } 119 120 ret = si2168_cmd_execute(s, &cmd); 121 if (ret) 122 goto err; 123 124 /* 125 * Possible values seen, in order from strong signal to weak: 126 * 16 0001 0110 full lock 127 * 1e 0001 1110 partial lock 128 * 1a 0001 1010 partial lock 129 * 18 0001 1000 no lock 130 * 131 * [b3:b1] lock bits 132 * [b4] statistics ready? Set in a few secs after lock is gained. 133 */ 134 135 switch ((cmd.args[2] >> 1) & 0x03) { 136 case 0x01: 137 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 138 break; 139 case 0x03: 140 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | 141 FE_HAS_SYNC | FE_HAS_LOCK; 142 break; 143 } 144 145 s->fe_status = *status; 146 147 dev_dbg(&s->client->dev, "%s: status=%02x args=%*ph\n", 148 __func__, *status, cmd.rlen, cmd.args); 149 150 return 0; 151err: 152 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 153 return ret; 154} 155 156static int si2168_set_frontend(struct dvb_frontend *fe) 157{ 158 struct si2168 *s = fe->demodulator_priv; 159 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 160 int ret; 161 struct si2168_cmd cmd; 162 u8 bandwidth, delivery_system; 163 164 dev_dbg(&s->client->dev, 165 "%s: delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%u\n", 166 __func__, c->delivery_system, c->modulation, 167 c->frequency, c->bandwidth_hz, c->symbol_rate, 168 c->inversion); 169 170 if (!s->active) { 171 ret = -EAGAIN; 172 goto err; 173 } 174 175 switch (c->delivery_system) { 176 case SYS_DVBT: 177 delivery_system = 0x20; 178 break; 179 case SYS_DVBC_ANNEX_A: 180 delivery_system = 0x30; 181 break; 182 case SYS_DVBT2: 183 delivery_system = 0x70; 184 break; 185 default: 186 ret = -EINVAL; 187 goto err; 188 } 189 190 if (c->bandwidth_hz <= 5000000) 191 bandwidth = 0x05; 192 else if (c->bandwidth_hz <= 6000000) 193 bandwidth = 0x06; 194 else if (c->bandwidth_hz <= 7000000) 195 bandwidth = 0x07; 196 else if (c->bandwidth_hz <= 8000000) 197 bandwidth = 0x08; 198 else if (c->bandwidth_hz <= 9000000) 199 bandwidth = 0x09; 200 else if (c->bandwidth_hz <= 10000000) 201 bandwidth = 0x0a; 202 else 203 bandwidth = 0x0f; 204 205 /* program tuner */ 206 if (fe->ops.tuner_ops.set_params) { 207 ret = fe->ops.tuner_ops.set_params(fe); 208 if (ret) 209 goto err; 210 } 211 212 memcpy(cmd.args, "\x88\x02\x02\x02\x02", 5); 213 cmd.wlen = 5; 214 cmd.rlen = 5; 215 ret = si2168_cmd_execute(s, &cmd); 216 if (ret) 217 goto err; 218 219 /* that has no big effect */ 220 if (c->delivery_system == SYS_DVBT) 221 memcpy(cmd.args, "\x89\x21\x06\x11\xff\x98", 6); 222 else if (c->delivery_system == SYS_DVBC_ANNEX_A) 223 memcpy(cmd.args, "\x89\x21\x06\x11\x89\xf0", 6); 224 else if (c->delivery_system == SYS_DVBT2) 225 memcpy(cmd.args, "\x89\x21\x06\x11\x89\x20", 6); 226 cmd.wlen = 6; 227 cmd.rlen = 3; 228 ret = si2168_cmd_execute(s, &cmd); 229 if (ret) 230 goto err; 231 232 memcpy(cmd.args, "\x51\x03", 2); 233 cmd.wlen = 2; 234 cmd.rlen = 12; 235 ret = si2168_cmd_execute(s, &cmd); 236 if (ret) 237 goto err; 238 239 memcpy(cmd.args, "\x12\x08\x04", 3); 240 cmd.wlen = 3; 241 cmd.rlen = 3; 242 ret = si2168_cmd_execute(s, &cmd); 243 if (ret) 244 goto err; 245 246 memcpy(cmd.args, "\x14\x00\x01\x04\x00\x00", 6); 247 cmd.wlen = 6; 248 cmd.rlen = 1; 249 ret = si2168_cmd_execute(s, &cmd); 250 if (ret) 251 goto err; 252 253 memcpy(cmd.args, "\x14\x00\x03\x10\x17\x00", 6); 254 cmd.wlen = 6; 255 cmd.rlen = 1; 256 ret = si2168_cmd_execute(s, &cmd); 257 if (ret) 258 goto err; 259 260 memcpy(cmd.args, "\x14\x00\x02\x10\x15\x00", 6); 261 cmd.wlen = 6; 262 cmd.rlen = 1; 263 ret = si2168_cmd_execute(s, &cmd); 264 if (ret) 265 goto err; 266 267 memcpy(cmd.args, "\x14\x00\x0c\x10\x12\x00", 6); 268 cmd.wlen = 6; 269 cmd.rlen = 1; 270 ret = si2168_cmd_execute(s, &cmd); 271 if (ret) 272 goto err; 273 274 memcpy(cmd.args, "\x14\x00\x06\x10\x24\x00", 6); 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\x0b\x10\x88\x13", 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\x07\x10\x00\x24", 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\x0a\x10\x00\x00", 6); 296 cmd.args[4] = delivery_system | bandwidth; 297 cmd.wlen = 6; 298 cmd.rlen = 1; 299 ret = si2168_cmd_execute(s, &cmd); 300 if (ret) 301 goto err; 302 303 memcpy(cmd.args, "\x14\x00\x04\x10\x15\x00", 6); 304 cmd.wlen = 6; 305 cmd.rlen = 1; 306 ret = si2168_cmd_execute(s, &cmd); 307 if (ret) 308 goto err; 309 310 memcpy(cmd.args, "\x14\x00\x05\x10\xa1\x00", 6); 311 cmd.wlen = 6; 312 cmd.rlen = 1; 313 ret = si2168_cmd_execute(s, &cmd); 314 if (ret) 315 goto err; 316 317 memcpy(cmd.args, "\x14\x00\x0f\x10\x10\x00", 6); 318 cmd.wlen = 6; 319 cmd.rlen = 1; 320 ret = si2168_cmd_execute(s, &cmd); 321 if (ret) 322 goto err; 323 324 memcpy(cmd.args, "\x14\x00\x0d\x10\xd0\x02", 6); 325 cmd.wlen = 6; 326 cmd.rlen = 1; 327 ret = si2168_cmd_execute(s, &cmd); 328 if (ret) 329 goto err; 330 331 memcpy(cmd.args, "\x14\x00\x01\x10\x00\x00", 6); 332 cmd.wlen = 6; 333 cmd.rlen = 1; 334 ret = si2168_cmd_execute(s, &cmd); 335 if (ret) 336 goto err; 337 338 memcpy(cmd.args, "\x14\x00\x09\x10\xe3\x18", 6); 339 cmd.wlen = 6; 340 cmd.rlen = 1; 341 ret = si2168_cmd_execute(s, &cmd); 342 if (ret) 343 goto err; 344 345 memcpy(cmd.args, "\x14\x00\x08\x10\xd7\x15", 6); 346 cmd.wlen = 6; 347 cmd.rlen = 1; 348 ret = si2168_cmd_execute(s, &cmd); 349 if (ret) 350 goto err; 351 352 memcpy(cmd.args, "\x14\x00\x04\x03\x00\x00", 6); 353 cmd.wlen = 6; 354 cmd.rlen = 1; 355 ret = si2168_cmd_execute(s, &cmd); 356 if (ret) 357 goto err; 358 359 memcpy(cmd.args, "\x14\x00\x03\x03\x00\x00", 6); 360 cmd.wlen = 6; 361 cmd.rlen = 1; 362 ret = si2168_cmd_execute(s, &cmd); 363 if (ret) 364 goto err; 365 366 memcpy(cmd.args, "\x14\x00\x08\x03\x00\x00", 6); 367 cmd.wlen = 6; 368 cmd.rlen = 1; 369 ret = si2168_cmd_execute(s, &cmd); 370 if (ret) 371 goto err; 372 373 memcpy(cmd.args, "\x14\x00\x07\x03\x01\x02", 6); 374 cmd.wlen = 6; 375 cmd.rlen = 1; 376 ret = si2168_cmd_execute(s, &cmd); 377 if (ret) 378 goto err; 379 380 memcpy(cmd.args, "\x14\x00\x06\x03\x00\x00", 6); 381 cmd.wlen = 6; 382 cmd.rlen = 1; 383 ret = si2168_cmd_execute(s, &cmd); 384 if (ret) 385 goto err; 386 387 memcpy(cmd.args, "\x14\x00\x05\x03\x00\x00", 6); 388 cmd.wlen = 6; 389 cmd.rlen = 1; 390 ret = si2168_cmd_execute(s, &cmd); 391 if (ret) 392 goto err; 393 394 memcpy(cmd.args, "\x14\x00\x01\x03\x0c\x40", 6); 395 cmd.wlen = 6; 396 cmd.rlen = 1; 397 ret = si2168_cmd_execute(s, &cmd); 398 if (ret) 399 goto err; 400 401 memcpy(cmd.args, "\x14\x00\x01\x10\x16\x00", 6); 402 cmd.wlen = 6; 403 cmd.rlen = 1; 404 ret = si2168_cmd_execute(s, &cmd); 405 if (ret) 406 goto err; 407 408 memcpy(cmd.args, "\x14\x00\x01\x12\x00\x00", 6); 409 cmd.wlen = 6; 410 cmd.rlen = 1; 411 ret = si2168_cmd_execute(s, &cmd); 412 if (ret) 413 goto err; 414 415 cmd.args[0] = 0x85; 416 cmd.wlen = 1; 417 cmd.rlen = 1; 418 ret = si2168_cmd_execute(s, &cmd); 419 if (ret) 420 goto err; 421 422 s->delivery_system = c->delivery_system; 423 424 return 0; 425err: 426 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 427 return ret; 428} 429 430static int si2168_init(struct dvb_frontend *fe) 431{ 432 struct si2168 *s = fe->demodulator_priv; 433 int ret, len, remaining; 434 const struct firmware *fw = NULL; 435 u8 *fw_file = SI2168_FIRMWARE; 436 const unsigned int i2c_wr_max = 8; 437 struct si2168_cmd cmd; 438 439 dev_dbg(&s->client->dev, "%s:\n", __func__); 440 441 cmd.args[0] = 0xc0; 442 cmd.args[1] = 0x12; 443 cmd.args[2] = 0x00; 444 cmd.args[3] = 0x0c; 445 cmd.args[4] = 0x00; 446 cmd.args[5] = 0x0d; 447 cmd.args[6] = 0x16; 448 cmd.args[7] = 0x00; 449 cmd.args[8] = 0x00; 450 cmd.args[9] = 0x00; 451 cmd.args[10] = 0x00; 452 cmd.args[11] = 0x00; 453 cmd.args[12] = 0x00; 454 cmd.wlen = 13; 455 cmd.rlen = 0; 456 ret = si2168_cmd_execute(s, &cmd); 457 if (ret) 458 goto err; 459 460 cmd.args[0] = 0xc0; 461 cmd.args[1] = 0x06; 462 cmd.args[2] = 0x01; 463 cmd.args[3] = 0x0f; 464 cmd.args[4] = 0x00; 465 cmd.args[5] = 0x20; 466 cmd.args[6] = 0x20; 467 cmd.args[7] = 0x01; 468 cmd.wlen = 8; 469 cmd.rlen = 1; 470 ret = si2168_cmd_execute(s, &cmd); 471 if (ret) 472 goto err; 473 474 cmd.args[0] = 0x02; 475 cmd.wlen = 1; 476 cmd.rlen = 13; 477 ret = si2168_cmd_execute(s, &cmd); 478 if (ret) 479 goto err; 480 481 cmd.args[0] = 0x05; 482 cmd.args[1] = 0x00; 483 cmd.args[2] = 0xaa; 484 cmd.args[3] = 0x4d; 485 cmd.args[4] = 0x56; 486 cmd.args[5] = 0x40; 487 cmd.args[6] = 0x00; 488 cmd.args[7] = 0x00; 489 cmd.wlen = 8; 490 cmd.rlen = 1; 491 ret = si2168_cmd_execute(s, &cmd); 492 if (ret) 493 goto err; 494 495 /* cold state - try to download firmware */ 496 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n", 497 KBUILD_MODNAME, si2168_ops.info.name); 498 499 /* request the firmware, this will block and timeout */ 500 ret = request_firmware(&fw, fw_file, &s->client->dev); 501 if (ret) { 502 dev_err(&s->client->dev, "%s: firmare file '%s' not found\n", 503 KBUILD_MODNAME, fw_file); 504 goto err; 505 } 506 507 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n", 508 KBUILD_MODNAME, fw_file); 509 510 for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) { 511 len = remaining; 512 if (len > i2c_wr_max) 513 len = i2c_wr_max; 514 515 memcpy(cmd.args, &fw->data[fw->size - remaining], len); 516 cmd.wlen = len; 517 cmd.rlen = 1; 518 ret = si2168_cmd_execute(s, &cmd); 519 if (ret) { 520 dev_err(&s->client->dev, 521 "%s: firmware download failed=%d\n", 522 KBUILD_MODNAME, ret); 523 goto err; 524 } 525 } 526 527 release_firmware(fw); 528 fw = NULL; 529 530 cmd.args[0] = 0x01; 531 cmd.args[1] = 0x01; 532 cmd.wlen = 2; 533 cmd.rlen = 1; 534 ret = si2168_cmd_execute(s, &cmd); 535 if (ret) 536 goto err; 537 538 dev_info(&s->client->dev, "%s: found a '%s' in warm state\n", 539 KBUILD_MODNAME, si2168_ops.info.name); 540 541 s->active = true; 542 543 return 0; 544err: 545 if (fw) 546 release_firmware(fw); 547 548 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 549 return ret; 550} 551 552static int si2168_sleep(struct dvb_frontend *fe) 553{ 554 struct si2168 *s = fe->demodulator_priv; 555 int ret; 556 struct si2168_cmd cmd; 557 558 dev_dbg(&s->client->dev, "%s:\n", __func__); 559 560 s->active = false; 561 562 memcpy(cmd.args, "\x13", 1); 563 cmd.wlen = 1; 564 cmd.rlen = 0; 565 ret = si2168_cmd_execute(s, &cmd); 566 if (ret) 567 goto err; 568 569 return 0; 570err: 571 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 572 return ret; 573} 574 575static int si2168_get_tune_settings(struct dvb_frontend *fe, 576 struct dvb_frontend_tune_settings *s) 577{ 578 s->min_delay_ms = 900; 579 580 return 0; 581} 582 583/* 584 * I2C gate logic 585 * We must use unlocked i2c_transfer() here because I2C lock is already taken 586 * by tuner driver. 587 */ 588static int si2168_select(struct i2c_adapter *adap, void *mux_priv, u32 chan) 589{ 590 struct si2168 *s = mux_priv; 591 int ret; 592 struct i2c_msg gate_open_msg = { 593 .addr = s->client->addr, 594 .flags = 0, 595 .len = 3, 596 .buf = "\xc0\x0d\x01", 597 }; 598 599 mutex_lock(&s->i2c_mutex); 600 601 /* open tuner I2C gate */ 602 ret = __i2c_transfer(s->client->adapter, &gate_open_msg, 1); 603 if (ret != 1) { 604 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 605 KBUILD_MODNAME, ret); 606 if (ret >= 0) 607 ret = -EREMOTEIO; 608 } else { 609 ret = 0; 610 } 611 612 return ret; 613} 614 615static int si2168_deselect(struct i2c_adapter *adap, void *mux_priv, u32 chan) 616{ 617 struct si2168 *s = mux_priv; 618 int ret; 619 struct i2c_msg gate_close_msg = { 620 .addr = s->client->addr, 621 .flags = 0, 622 .len = 3, 623 .buf = "\xc0\x0d\x00", 624 }; 625 626 /* close tuner I2C gate */ 627 ret = __i2c_transfer(s->client->adapter, &gate_close_msg, 1); 628 if (ret != 1) { 629 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 630 KBUILD_MODNAME, ret); 631 if (ret >= 0) 632 ret = -EREMOTEIO; 633 } else { 634 ret = 0; 635 } 636 637 mutex_unlock(&s->i2c_mutex); 638 639 return ret; 640} 641 642static const struct dvb_frontend_ops si2168_ops = { 643 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 644 .info = { 645 .name = "Silicon Labs Si2168", 646 .caps = FE_CAN_FEC_1_2 | 647 FE_CAN_FEC_2_3 | 648 FE_CAN_FEC_3_4 | 649 FE_CAN_FEC_5_6 | 650 FE_CAN_FEC_7_8 | 651 FE_CAN_FEC_AUTO | 652 FE_CAN_QPSK | 653 FE_CAN_QAM_16 | 654 FE_CAN_QAM_32 | 655 FE_CAN_QAM_64 | 656 FE_CAN_QAM_128 | 657 FE_CAN_QAM_256 | 658 FE_CAN_QAM_AUTO | 659 FE_CAN_TRANSMISSION_MODE_AUTO | 660 FE_CAN_GUARD_INTERVAL_AUTO | 661 FE_CAN_HIERARCHY_AUTO | 662 FE_CAN_MUTE_TS | 663 FE_CAN_2G_MODULATION 664 }, 665 666 .get_tune_settings = si2168_get_tune_settings, 667 668 .init = si2168_init, 669 .sleep = si2168_sleep, 670 671 .set_frontend = si2168_set_frontend, 672 673 .read_status = si2168_read_status, 674}; 675 676static int si2168_probe(struct i2c_client *client, 677 const struct i2c_device_id *id) 678{ 679 struct si2168_config *config = client->dev.platform_data; 680 struct si2168 *s; 681 int ret; 682 struct si2168_cmd cmd; 683 684 dev_dbg(&client->dev, "%s:\n", __func__); 685 686 s = kzalloc(sizeof(struct si2168), GFP_KERNEL); 687 if (!s) { 688 ret = -ENOMEM; 689 dev_err(&client->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME); 690 goto err; 691 } 692 693 s->client = client; 694 mutex_init(&s->i2c_mutex); 695 696 /* check if the demod is there */ 697 cmd.wlen = 0; 698 cmd.rlen = 1; 699 ret = si2168_cmd_execute(s, &cmd); 700 if (ret) 701 goto err; 702 703 /* create mux i2c adapter for tuner */ 704 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s, 705 0, 0, 0, si2168_select, si2168_deselect); 706 if (s->adapter == NULL) 707 goto err; 708 709 /* create dvb_frontend */ 710 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 711 s->fe.demodulator_priv = s; 712 713 *config->i2c_adapter = s->adapter; 714 *config->fe = &s->fe; 715 716 i2c_set_clientdata(client, s); 717 718 dev_info(&s->client->dev, 719 "%s: Silicon Labs Si2168 successfully attached\n", 720 KBUILD_MODNAME); 721 return 0; 722err: 723 kfree(s); 724 dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret); 725 return ret; 726} 727 728static int si2168_remove(struct i2c_client *client) 729{ 730 struct si2168 *s = i2c_get_clientdata(client); 731 732 dev_dbg(&client->dev, "%s:\n", __func__); 733 734 i2c_del_mux_adapter(s->adapter); 735 736 s->fe.ops.release = NULL; 737 s->fe.demodulator_priv = NULL; 738 739 kfree(s); 740 741 return 0; 742} 743 744static const struct i2c_device_id si2168_id[] = { 745 {"si2168", 0}, 746 {} 747}; 748MODULE_DEVICE_TABLE(i2c, si2168_id); 749 750static struct i2c_driver si2168_driver = { 751 .driver = { 752 .owner = THIS_MODULE, 753 .name = "si2168", 754 }, 755 .probe = si2168_probe, 756 .remove = si2168_remove, 757 .id_table = si2168_id, 758}; 759 760module_i2c_driver(si2168_driver); 761 762MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 763MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 764MODULE_LICENSE("GPL"); 765MODULE_FIRMWARE(SI2168_FIRMWARE); 766