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