drivers/media/dvb-frontends/si2168.c

   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
  19 static const struct dvb_frontend_ops si2168_ops;
  20
  21 /* execute firmware command */
  22 static 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
  71 err_mutex_unlock:
  72         mutex_unlock(&s->i2c_mutex);
  73         if (ret)
  74                 goto err;
  75
  76         return 0;
  77 err:
  78         dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret);
  79         return ret;
  80 }
  81
  82 static 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;
 157 err:
 158         dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret);
 159         return ret;
 160 }
 161
 162 static 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;
 326 err:
 327         dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret);
 328         return ret;
 329 }
 330
 331 static 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;
 449 err:
 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
 457 static 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;
 475 err:
 476         dev_dbg(&s->client->dev, "%s: failed=%d\n", __func__, ret);
 477         return ret;
 478 }
 479
 480 static 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  */
 493 static 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
 520 static 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
 547 static 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
 581 static 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;
 627 err:
 628         kfree(s);
 629         dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret);
 630         return ret;
 631 }
 632
 633 static 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
 649 static const struct i2c_device_id si2168_id[] = {
 650         {"si2168", 0},
 651         {}
 652 };
 653 MODULE_DEVICE_TABLE(i2c, si2168_id);
 654
 655 static 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
 665 module_i2c_driver(si2168_driver);
 666
 667 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 668 MODULE_DESCRIPTION("Silicon Labs Si2168 DVB-T/T2/C demodulator driver");
 669 MODULE_LICENSE("GPL");
 670 MODULE_FIRMWARE(SI2168_A30_FIRMWARE);
 671 MODULE_FIRMWARE(SI2168_B40_FIRMWARE);