si2168.c revision 722a042de7c9a893a87d2d853c68473eb4000c05
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] = 0x13; 442 cmd.wlen = 1; 443 cmd.rlen = 0; 444 ret = si2168_cmd_execute(s, &cmd); 445 if (ret) 446 goto err; 447 448 cmd.args[0] = 0xc0; 449 cmd.args[1] = 0x12; 450 cmd.args[2] = 0x00; 451 cmd.args[3] = 0x0c; 452 cmd.args[4] = 0x00; 453 cmd.args[5] = 0x0d; 454 cmd.args[6] = 0x16; 455 cmd.args[7] = 0x00; 456 cmd.args[8] = 0x00; 457 cmd.args[9] = 0x00; 458 cmd.args[10] = 0x00; 459 cmd.args[11] = 0x00; 460 cmd.args[12] = 0x00; 461 cmd.wlen = 13; 462 cmd.rlen = 0; 463 ret = si2168_cmd_execute(s, &cmd); 464 if (ret) 465 goto err; 466 467 cmd.args[0] = 0xc0; 468 cmd.args[1] = 0x06; 469 cmd.args[2] = 0x01; 470 cmd.args[3] = 0x0f; 471 cmd.args[4] = 0x00; 472 cmd.args[5] = 0x20; 473 cmd.args[6] = 0x20; 474 cmd.args[7] = 0x01; 475 cmd.wlen = 8; 476 cmd.rlen = 1; 477 ret = si2168_cmd_execute(s, &cmd); 478 if (ret) 479 goto err; 480 481 cmd.args[0] = 0x02; 482 cmd.wlen = 1; 483 cmd.rlen = 13; 484 ret = si2168_cmd_execute(s, &cmd); 485 if (ret) 486 goto err; 487 488 cmd.args[0] = 0x05; 489 cmd.args[1] = 0x00; 490 cmd.args[2] = 0xaa; 491 cmd.args[3] = 0x4d; 492 cmd.args[4] = 0x56; 493 cmd.args[5] = 0x40; 494 cmd.args[6] = 0x00; 495 cmd.args[7] = 0x00; 496 cmd.wlen = 8; 497 cmd.rlen = 1; 498 ret = si2168_cmd_execute(s, &cmd); 499 if (ret) 500 goto err; 501 502 /* cold state - try to download firmware */ 503 dev_info(&s->client->dev, "%s: found a '%s' in cold state\n", 504 KBUILD_MODNAME, si2168_ops.info.name); 505 506 /* request the firmware, this will block and timeout */ 507 ret = request_firmware(&fw, fw_file, &s->client->dev); 508 if (ret) { 509 dev_err(&s->client->dev, "%s: firmare file '%s' not found\n", 510 KBUILD_MODNAME, fw_file); 511 goto err; 512 } 513 514 dev_info(&s->client->dev, "%s: downloading firmware from file '%s'\n", 515 KBUILD_MODNAME, fw_file); 516 517 for (remaining = fw->size; remaining > 0; remaining -= i2c_wr_max) { 518 len = remaining; 519 if (len > i2c_wr_max) 520 len = i2c_wr_max; 521 522 memcpy(cmd.args, &fw->data[fw->size - remaining], len); 523 cmd.wlen = len; 524 cmd.rlen = 1; 525 ret = si2168_cmd_execute(s, &cmd); 526 if (ret) { 527 dev_err(&s->client->dev, 528 "%s: firmware download failed=%d\n", 529 KBUILD_MODNAME, ret); 530 goto err; 531 } 532 } 533 534 release_firmware(fw); 535 fw = NULL; 536 537 cmd.args[0] = 0x01; 538 cmd.args[1] = 0x01; 539 cmd.wlen = 2; 540 cmd.rlen = 1; 541 ret = si2168_cmd_execute(s, &cmd); 542 if (ret) 543 goto err; 544 545 dev_info(&s->client->dev, "%s: found a '%s' in warm state\n", 546 KBUILD_MODNAME, si2168_ops.info.name); 547 548 s->active = true; 549 550 return 0; 551err: 552 if (fw) 553 release_firmware(fw); 554 555 dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret); 556 return ret; 557} 558 559static int si2168_sleep(struct dvb_frontend *fe) 560{ 561 struct si2168 *s = fe->demodulator_priv; 562 563 dev_dbg(&s->client->dev, "%s:\n", __func__); 564 565 s->active = false; 566 567 return 0; 568} 569 570static int si2168_get_tune_settings(struct dvb_frontend *fe, 571 struct dvb_frontend_tune_settings *s) 572{ 573 s->min_delay_ms = 900; 574 575 return 0; 576} 577 578/* 579 * I2C gate logic 580 * We must use unlocked i2c_transfer() here because I2C lock is already taken 581 * by tuner driver. 582 */ 583static int si2168_select(struct i2c_adapter *adap, void *mux_priv, u32 chan) 584{ 585 struct si2168 *s = mux_priv; 586 int ret; 587 struct i2c_msg gate_open_msg = { 588 .addr = s->client->addr, 589 .flags = 0, 590 .len = 3, 591 .buf = "\xc0\x0d\x01", 592 }; 593 594 mutex_lock(&s->i2c_mutex); 595 596 /* open tuner I2C gate */ 597 ret = __i2c_transfer(s->client->adapter, &gate_open_msg, 1); 598 if (ret != 1) { 599 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 600 KBUILD_MODNAME, ret); 601 if (ret >= 0) 602 ret = -EREMOTEIO; 603 } else { 604 ret = 0; 605 } 606 607 return ret; 608} 609 610static int si2168_deselect(struct i2c_adapter *adap, void *mux_priv, u32 chan) 611{ 612 struct si2168 *s = mux_priv; 613 int ret; 614 struct i2c_msg gate_close_msg = { 615 .addr = s->client->addr, 616 .flags = 0, 617 .len = 3, 618 .buf = "\xc0\x0d\x00", 619 }; 620 621 /* close tuner I2C gate */ 622 ret = __i2c_transfer(s->client->adapter, &gate_close_msg, 1); 623 if (ret != 1) { 624 dev_warn(&s->client->dev, "%s: i2c write failed=%d\n", 625 KBUILD_MODNAME, ret); 626 if (ret >= 0) 627 ret = -EREMOTEIO; 628 } else { 629 ret = 0; 630 } 631 632 mutex_unlock(&s->i2c_mutex); 633 634 return ret; 635} 636 637static const struct dvb_frontend_ops si2168_ops = { 638 .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_A}, 639 .info = { 640 .name = "Silicon Labs Si2168", 641 .caps = FE_CAN_FEC_1_2 | 642 FE_CAN_FEC_2_3 | 643 FE_CAN_FEC_3_4 | 644 FE_CAN_FEC_5_6 | 645 FE_CAN_FEC_7_8 | 646 FE_CAN_FEC_AUTO | 647 FE_CAN_QPSK | 648 FE_CAN_QAM_16 | 649 FE_CAN_QAM_32 | 650 FE_CAN_QAM_64 | 651 FE_CAN_QAM_128 | 652 FE_CAN_QAM_256 | 653 FE_CAN_QAM_AUTO | 654 FE_CAN_TRANSMISSION_MODE_AUTO | 655 FE_CAN_GUARD_INTERVAL_AUTO | 656 FE_CAN_HIERARCHY_AUTO | 657 FE_CAN_MUTE_TS | 658 FE_CAN_2G_MODULATION 659 }, 660 661 .get_tune_settings = si2168_get_tune_settings, 662 663 .init = si2168_init, 664 .sleep = si2168_sleep, 665 666 .set_frontend = si2168_set_frontend, 667 668 .read_status = si2168_read_status, 669}; 670 671static int si2168_probe(struct i2c_client *client, 672 const struct i2c_device_id *id) 673{ 674 struct si2168_config *config = client->dev.platform_data; 675 struct si2168 *s; 676 int ret; 677 struct si2168_cmd cmd; 678 679 dev_dbg(&client->dev, "%s:\n", __func__); 680 681 s = kzalloc(sizeof(struct si2168), GFP_KERNEL); 682 if (!s) { 683 ret = -ENOMEM; 684 dev_err(&client->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME); 685 goto err; 686 } 687 688 s->client = client; 689 mutex_init(&s->i2c_mutex); 690 691 /* check if the demod is there */ 692 cmd.wlen = 0; 693 cmd.rlen = 1; 694 ret = si2168_cmd_execute(s, &cmd); 695 if (ret) 696 goto err; 697 698 /* create mux i2c adapter for tuner */ 699 s->adapter = i2c_add_mux_adapter(client->adapter, &client->dev, s, 700 0, 0, 0, si2168_select, si2168_deselect); 701 if (s->adapter == NULL) 702 goto err; 703 704 /* create dvb_frontend */ 705 memcpy(&s->fe.ops, &si2168_ops, sizeof(struct dvb_frontend_ops)); 706 s->fe.demodulator_priv = s; 707 708 *config->i2c_adapter = s->adapter; 709 *config->fe = &s->fe; 710 711 i2c_set_clientdata(client, s); 712 713 dev_info(&s->client->dev, 714 "%s: Silicon Labs Si2168 successfully attached\n", 715 KBUILD_MODNAME); 716 return 0; 717err: 718 kfree(s); 719 dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret); 720 return ret; 721} 722 723static int si2168_remove(struct i2c_client *client) 724{ 725 struct si2168 *s = i2c_get_clientdata(client); 726 727 dev_dbg(&client->dev, "%s:\n", __func__); 728 729 i2c_del_mux_adapter(s->adapter); 730 731 s->fe.ops.release = NULL; 732 s->fe.demodulator_priv = NULL; 733 734 kfree(s); 735 736 return 0; 737} 738 739static const struct i2c_device_id si2168_id[] = { 740 {"si2168", 0}, 741 {} 742}; 743MODULE_DEVICE_TABLE(i2c, si2168_id); 744 745static struct i2c_driver si2168_driver = { 746 .driver = { 747 .owner = THIS_MODULE, 748 .name = "si2168", 749 }, 750 .probe = si2168_probe, 751 .remove = si2168_remove, 752 .id_table = si2168_id, 753}; 754 755module_i2c_driver(si2168_driver); 756 757MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 758MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver"); 759MODULE_LICENSE("GPL"); 760MODULE_FIRMWARE(SI2168_FIRMWARE); 761