drivers/media/tuners/m88ts2022.c

   1 /*
   2  * Montage M88TS2022 silicon tuner driver
   3  *
   4  * Copyright (C) 2013 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  *    You should have received a copy of the GNU General Public License along
  17  *    with this program; if not, write to the Free Software Foundation, Inc.,
  18  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Some calculations are taken from existing TS2020 driver.
  21  */
  22
  23 #include "m88ts2022_priv.h"
  24
  25 /* write multiple registers */
  26 static int m88ts2022_wr_regs(struct m88ts2022_priv *priv,
  27                 u8 reg, const u8 *val, int len)
  28 {
  29 #define MAX_WR_LEN 3
  30 #define MAX_WR_XFER_LEN (MAX_WR_LEN + 1)
  31         int ret;
  32         u8 buf[MAX_WR_XFER_LEN];
  33         struct i2c_msg msg[1] = {
  34                 {
  35                         .addr = priv->client->addr,
  36                         .flags = 0,
  37                         .len = 1 + len,
  38                         .buf = buf,
  39                 }
  40         };
  41
  42         if (WARN_ON(len > MAX_WR_LEN))
  43                 return -EINVAL;
  44
  45         buf[0] = reg;
  46         memcpy(&buf[1], val, len);
  47
  48         ret = i2c_transfer(priv->client->adapter, msg, 1);
  49         if (ret == 1) {
  50                 ret = 0;
  51         } else {
  52                 dev_warn(&priv->client->dev,
  53                                 "%s: i2c wr failed=%d reg=%02x len=%d\n",
  54                                 KBUILD_MODNAME, ret, reg, len);
  55                 ret = -EREMOTEIO;
  56         }
  57
  58         return ret;
  59 }
  60
  61 /* read multiple registers */
  62 static int m88ts2022_rd_regs(struct m88ts2022_priv *priv, u8 reg,
  63                 u8 *val, int len)
  64 {
  65 #define MAX_RD_LEN 1
  66 #define MAX_RD_XFER_LEN (MAX_RD_LEN)
  67         int ret;
  68         u8 buf[MAX_RD_XFER_LEN];
  69         struct i2c_msg msg[2] = {
  70                 {
  71                         .addr = priv->client->addr,
  72                         .flags = 0,
  73                         .len = 1,
  74                         .buf = &reg,
  75                 }, {
  76                         .addr = priv->client->addr,
  77                         .flags = I2C_M_RD,
  78                         .len = len,
  79                         .buf = buf,
  80                 }
  81         };
  82
  83         if (WARN_ON(len > MAX_RD_LEN))
  84                 return -EINVAL;
  85
  86         ret = i2c_transfer(priv->client->adapter, msg, 2);
  87         if (ret == 2) {
  88                 memcpy(val, buf, len);
  89                 ret = 0;
  90         } else {
  91                 dev_warn(&priv->client->dev,
  92                                 "%s: i2c rd failed=%d reg=%02x len=%d\n",
  93                                 KBUILD_MODNAME, ret, reg, len);
  94                 ret = -EREMOTEIO;
  95         }
  96
  97         return ret;
  98 }
  99
 100 /* write single register */
 101 static int m88ts2022_wr_reg(struct m88ts2022_priv *priv, u8 reg, u8 val)
 102 {
 103         return m88ts2022_wr_regs(priv, reg, &val, 1);
 104 }
 105
 106 /* read single register */
 107 static int m88ts2022_rd_reg(struct m88ts2022_priv *priv, u8 reg, u8 *val)
 108 {
 109         return m88ts2022_rd_regs(priv, reg, val, 1);
 110 }
 111
 112 /* write single register with mask */
 113 static int m88ts2022_wr_reg_mask(struct m88ts2022_priv *priv,
 114                 u8 reg, u8 val, u8 mask)
 115 {
 116         int ret;
 117         u8 u8tmp;
 118
 119         /* no need for read if whole reg is written */
 120         if (mask != 0xff) {
 121                 ret = m88ts2022_rd_regs(priv, reg, &u8tmp, 1);
 122                 if (ret)
 123                         return ret;
 124
 125                 val &= mask;
 126                 u8tmp &= ~mask;
 127                 val |= u8tmp;
 128         }
 129
 130         return m88ts2022_wr_regs(priv, reg, &val, 1);
 131 }
 132
 133 static int m88ts2022_cmd(struct dvb_frontend *fe,
 134                 int op, int sleep, u8 reg, u8 mask, u8 val, u8 *reg_val)
 135 {
 136         struct m88ts2022_priv *priv = fe->tuner_priv;
 137         int ret, i;
 138         u8 u8tmp;
 139         struct m88ts2022_reg_val reg_vals[] = {
 140                 {0x51, 0x1f - op},
 141                 {0x51, 0x1f},
 142                 {0x50, 0x00 + op},
 143                 {0x50, 0x00},
 144         };
 145
 146         for (i = 0; i < 2; i++) {
 147                 dev_dbg(&priv->client->dev,
 148                                 "%s: i=%d op=%02x reg=%02x mask=%02x val=%02x\n",
 149                                 __func__, i, op, reg, mask, val);
 150
 151                 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
 152                         ret = m88ts2022_wr_reg(priv, reg_vals[i].reg,
 153                                         reg_vals[i].val);
 154                         if (ret)
 155                                 goto err;
 156                 }
 157
 158                 usleep_range(sleep * 1000, sleep * 10000);
 159
 160                 ret = m88ts2022_rd_reg(priv, reg, &u8tmp);
 161                 if (ret)
 162                         goto err;
 163
 164                 if ((u8tmp & mask) != val)
 165                         break;
 166         }
 167
 168         if (reg_val)
 169                 *reg_val = u8tmp;
 170 err:
 171         return ret;
 172 }
 173
 174 static int m88ts2022_set_params(struct dvb_frontend *fe)
 175 {
 176         struct m88ts2022_priv *priv = fe->tuner_priv;
 177         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 178         int ret;
 179         unsigned int frequency_khz, frequency_offset_khz, f_3db_hz;
 180         unsigned int f_ref_khz, f_vco_khz, div_ref, div_out, pll_n, gdiv28;
 181         u8 buf[3], u8tmp, cap_code, lpf_gm, lpf_mxdiv, div_max, div_min;
 182         u16 u16tmp;
 183         dev_dbg(&priv->client->dev,
 184                         "%s: frequency=%d symbol_rate=%d rolloff=%d\n",
 185                         __func__, c->frequency, c->symbol_rate, c->rolloff);
 186         /*
 187          * Integer-N PLL synthesizer
 188          * kHz is used for all calculations to keep calculations within 32-bit
 189          */
 190         f_ref_khz = DIV_ROUND_CLOSEST(priv->cfg.clock, 1000);
 191         div_ref = DIV_ROUND_CLOSEST(f_ref_khz, 2000);
 192
 193         if (c->symbol_rate < 5000000)
 194                 frequency_offset_khz = 3000; /* 3 MHz */
 195         else
 196                 frequency_offset_khz = 0;
 197
 198         frequency_khz = c->frequency + frequency_offset_khz;
 199
 200         if (frequency_khz < 1103000) {
 201                 div_out = 4;
 202                 u8tmp = 0x1b;
 203         } else {
 204                 div_out = 2;
 205                 u8tmp = 0x0b;
 206         }
 207
 208         buf[0] = u8tmp;
 209         buf[1] = 0x40;
 210         ret = m88ts2022_wr_regs(priv, 0x10, buf, 2);
 211         if (ret)
 212                 goto err;
 213
 214         f_vco_khz = frequency_khz * div_out;
 215         pll_n = f_vco_khz * div_ref / f_ref_khz;
 216         pll_n += pll_n % 2;
 217         priv->frequency_khz = pll_n * f_ref_khz / div_ref / div_out;
 218
 219         if (pll_n < 4095)
 220                 u16tmp = pll_n - 1024;
 221         else if (pll_n < 6143)
 222                 u16tmp = pll_n + 1024;
 223         else
 224                 u16tmp = pll_n + 3072;
 225
 226         buf[0] = (u16tmp >> 8) & 0x3f;
 227         buf[1] = (u16tmp >> 0) & 0xff;
 228         buf[2] = div_ref - 8;
 229         ret = m88ts2022_wr_regs(priv, 0x01, buf, 3);
 230         if (ret)
 231                 goto err;
 232
 233         dev_dbg(&priv->client->dev,
 234                         "%s: frequency=%u offset=%d f_vco_khz=%u pll_n=%u div_ref=%u div_out=%u\n",
 235                         __func__, priv->frequency_khz,
 236                         priv->frequency_khz - c->frequency, f_vco_khz, pll_n,
 237                         div_ref, div_out);
 238
 239         ret = m88ts2022_cmd(fe, 0x10, 5, 0x15, 0x40, 0x00, NULL);
 240         if (ret)
 241                 goto err;
 242
 243         ret = m88ts2022_rd_reg(priv, 0x14, &u8tmp);
 244         if (ret)
 245                 goto err;
 246
 247         u8tmp &= 0x7f;
 248         if (u8tmp < 64) {
 249                 ret = m88ts2022_wr_reg_mask(priv, 0x10, 0x80, 0x80);
 250                 if (ret)
 251                         goto err;
 252
 253                 ret = m88ts2022_wr_reg(priv, 0x11, 0x6f);
 254                 if (ret)
 255                         goto err;
 256
 257                 ret = m88ts2022_cmd(fe, 0x10, 5, 0x15, 0x40, 0x00, NULL);
 258                 if (ret)
 259                         goto err;
 260         }
 261
 262         ret = m88ts2022_rd_reg(priv, 0x14, &u8tmp);
 263         if (ret)
 264                 goto err;
 265
 266         u8tmp &= 0x1f;
 267         if (u8tmp > 19) {
 268                 ret = m88ts2022_wr_reg_mask(priv, 0x10, 0x00, 0x02);
 269                 if (ret)
 270                         goto err;
 271         }
 272
 273         ret = m88ts2022_cmd(fe, 0x08, 5, 0x3c, 0xff, 0x00, NULL);
 274         if (ret)
 275                 goto err;
 276
 277         ret = m88ts2022_wr_reg(priv, 0x25, 0x00);
 278         if (ret)
 279                 goto err;
 280
 281         ret = m88ts2022_wr_reg(priv, 0x27, 0x70);
 282         if (ret)
 283                 goto err;
 284
 285         ret = m88ts2022_wr_reg(priv, 0x41, 0x09);
 286         if (ret)
 287                 goto err;
 288
 289         ret = m88ts2022_wr_reg(priv, 0x08, 0x0b);
 290         if (ret)
 291                 goto err;
 292
 293         /* filters */
 294         gdiv28 = DIV_ROUND_CLOSEST(f_ref_khz * 1694U, 1000000U);
 295
 296         ret = m88ts2022_wr_reg(priv, 0x04, gdiv28);
 297         if (ret)
 298                 goto err;
 299
 300         ret = m88ts2022_cmd(fe, 0x04, 2, 0x26, 0xff, 0x00, &u8tmp);
 301         if (ret)
 302                 goto err;
 303
 304         cap_code = u8tmp & 0x3f;
 305
 306         ret = m88ts2022_wr_reg(priv, 0x41, 0x0d);
 307         if (ret)
 308                 goto err;
 309
 310         ret = m88ts2022_cmd(fe, 0x04, 2, 0x26, 0xff, 0x00, &u8tmp);
 311         if (ret)
 312                 goto err;
 313
 314         u8tmp &= 0x3f;
 315         cap_code = (cap_code + u8tmp) / 2;
 316         gdiv28 = gdiv28 * 207 / (cap_code * 2 + 151);
 317         div_max = gdiv28 * 135 / 100;
 318         div_min = gdiv28 * 78 / 100;
 319         div_max = clamp_val(div_max, 0U, 63U);
 320
 321         f_3db_hz = c->symbol_rate * 135UL / 200UL;
 322         f_3db_hz +=  2000000U + (frequency_offset_khz * 1000U);
 323         f_3db_hz = clamp(f_3db_hz, 7000000U, 40000000U);
 324
 325 #define LPF_COEFF 3200U
 326         lpf_gm = DIV_ROUND_CLOSEST(f_3db_hz * gdiv28, LPF_COEFF * f_ref_khz);
 327         lpf_gm = clamp_val(lpf_gm, 1U, 23U);
 328
 329         lpf_mxdiv = DIV_ROUND_CLOSEST(lpf_gm * LPF_COEFF * f_ref_khz, f_3db_hz);
 330         if (lpf_mxdiv < div_min)
 331                 lpf_mxdiv = DIV_ROUND_CLOSEST(++lpf_gm * LPF_COEFF * f_ref_khz, f_3db_hz);
 332         lpf_mxdiv = clamp_val(lpf_mxdiv, 0U, div_max);
 333
 334         ret = m88ts2022_wr_reg(priv, 0x04, lpf_mxdiv);
 335         if (ret)
 336                 goto err;
 337
 338         ret = m88ts2022_wr_reg(priv, 0x06, lpf_gm);
 339         if (ret)
 340                 goto err;
 341
 342         ret = m88ts2022_cmd(fe, 0x04, 2, 0x26, 0xff, 0x00, &u8tmp);
 343         if (ret)
 344                 goto err;
 345
 346         cap_code = u8tmp & 0x3f;
 347
 348         ret = m88ts2022_wr_reg(priv, 0x41, 0x09);
 349         if (ret)
 350                 goto err;
 351
 352         ret = m88ts2022_cmd(fe, 0x04, 2, 0x26, 0xff, 0x00, &u8tmp);
 353         if (ret)
 354                 goto err;
 355
 356         u8tmp &= 0x3f;
 357         cap_code = (cap_code + u8tmp) / 2;
 358
 359         u8tmp = cap_code | 0x80;
 360         ret = m88ts2022_wr_reg(priv, 0x25, u8tmp);
 361         if (ret)
 362                 goto err;
 363
 364         ret = m88ts2022_wr_reg(priv, 0x27, 0x30);
 365         if (ret)
 366                 goto err;
 367
 368         ret = m88ts2022_wr_reg(priv, 0x08, 0x09);
 369         if (ret)
 370                 goto err;
 371
 372         ret = m88ts2022_cmd(fe, 0x01, 20, 0x21, 0xff, 0x00, NULL);
 373         if (ret)
 374                 goto err;
 375 err:
 376         if (ret)
 377                 dev_dbg(&priv->client->dev, "%s: failed=%d\n", __func__, ret);
 378
 379         return ret;
 380 }
 381
 382 static int m88ts2022_init(struct dvb_frontend *fe)
 383 {
 384         struct m88ts2022_priv *priv = fe->tuner_priv;
 385         int ret, i;
 386         u8 u8tmp;
 387         static const struct m88ts2022_reg_val reg_vals[] = {
 388                 {0x7d, 0x9d},
 389                 {0x7c, 0x9a},
 390                 {0x7a, 0x76},
 391                 {0x3b, 0x01},
 392                 {0x63, 0x88},
 393                 {0x61, 0x85},
 394                 {0x22, 0x30},
 395                 {0x30, 0x40},
 396                 {0x20, 0x23},
 397                 {0x24, 0x02},
 398                 {0x12, 0xa0},
 399         };
 400         dev_dbg(&priv->client->dev, "%s:\n", __func__);
 401
 402         ret = m88ts2022_wr_reg(priv, 0x00, 0x01);
 403         if (ret)
 404                 goto err;
 405
 406         ret = m88ts2022_wr_reg(priv, 0x00, 0x03);
 407         if (ret)
 408                 goto err;
 409
 410         switch (priv->cfg.clock_out) {
 411         case M88TS2022_CLOCK_OUT_DISABLED:
 412                 u8tmp = 0x60;
 413                 break;
 414         case M88TS2022_CLOCK_OUT_ENABLED:
 415                 u8tmp = 0x70;
 416                 ret = m88ts2022_wr_reg(priv, 0x05, priv->cfg.clock_out_div);
 417                 if (ret)
 418                         goto err;
 419                 break;
 420         case M88TS2022_CLOCK_OUT_ENABLED_XTALOUT:
 421                 u8tmp = 0x6c;
 422                 break;
 423         default:
 424                 goto err;
 425         }
 426
 427         ret = m88ts2022_wr_reg(priv, 0x42, u8tmp);
 428         if (ret)
 429                 goto err;
 430
 431         if (priv->cfg.loop_through)
 432                 u8tmp = 0xec;
 433         else
 434                 u8tmp = 0x6c;
 435
 436         ret = m88ts2022_wr_reg(priv, 0x62, u8tmp);
 437         if (ret)
 438                 goto err;
 439
 440         for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
 441                 ret = m88ts2022_wr_reg(priv, reg_vals[i].reg, reg_vals[i].val);
 442                 if (ret)
 443                         goto err;
 444         }
 445 err:
 446         if (ret)
 447                 dev_dbg(&priv->client->dev, "%s: failed=%d\n", __func__, ret);
 448         return ret;
 449 }
 450
 451 static int m88ts2022_sleep(struct dvb_frontend *fe)
 452 {
 453         struct m88ts2022_priv *priv = fe->tuner_priv;
 454         int ret;
 455         dev_dbg(&priv->client->dev, "%s:\n", __func__);
 456
 457         ret = m88ts2022_wr_reg(priv, 0x00, 0x00);
 458         if (ret)
 459                 goto err;
 460 err:
 461         if (ret)
 462                 dev_dbg(&priv->client->dev, "%s: failed=%d\n", __func__, ret);
 463         return ret;
 464 }
 465
 466 static int m88ts2022_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 467 {
 468         struct m88ts2022_priv *priv = fe->tuner_priv;
 469         dev_dbg(&priv->client->dev, "%s:\n", __func__);
 470
 471         *frequency = priv->frequency_khz;
 472         return 0;
 473 }
 474
 475 static int m88ts2022_get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
 476 {
 477         struct m88ts2022_priv *priv = fe->tuner_priv;
 478         dev_dbg(&priv->client->dev, "%s:\n", __func__);
 479
 480         *frequency = 0; /* Zero-IF */
 481         return 0;
 482 }
 483
 484 static int m88ts2022_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
 485 {
 486         struct m88ts2022_priv *priv = fe->tuner_priv;
 487         int ret;
 488         u8 u8tmp;
 489         u16 gain, u16tmp;
 490         unsigned int gain1, gain2, gain3;
 491
 492         ret = m88ts2022_rd_reg(priv, 0x3d, &u8tmp);
 493         if (ret)
 494                 goto err;
 495
 496         gain1 = (u8tmp >> 0) & 0x1f;
 497         gain1 = clamp(gain1, 0U, 15U);
 498
 499         ret = m88ts2022_rd_reg(priv, 0x21, &u8tmp);
 500         if (ret)
 501                 goto err;
 502
 503         gain2 = (u8tmp >> 0) & 0x1f;
 504         gain2 = clamp(gain2, 2U, 16U);
 505
 506         ret = m88ts2022_rd_reg(priv, 0x66, &u8tmp);
 507         if (ret)
 508                 goto err;
 509
 510         gain3 = (u8tmp >> 3) & 0x07;
 511         gain3 = clamp(gain3, 0U, 6U);
 512
 513         gain = gain1 * 265 + gain2 * 338 + gain3 * 285;
 514
 515         /* scale value to 0x0000-0xffff */
 516         u16tmp = (0xffff - gain);
 517         u16tmp = clamp_val(u16tmp, 59000U, 61500U);
 518
 519         *strength = (u16tmp - 59000) * 0xffff / (61500 - 59000);
 520 err:
 521         if (ret)
 522                 dev_dbg(&priv->client->dev, "%s: failed=%d\n", __func__, ret);
 523         return ret;
 524 }
 525
 526 static const struct dvb_tuner_ops m88ts2022_tuner_ops = {
 527         .info = {
 528                 .name          = "Montage M88TS2022",
 529                 .frequency_min = 950000,
 530                 .frequency_max = 2150000,
 531         },
 532
 533         .init = m88ts2022_init,
 534         .sleep = m88ts2022_sleep,
 535         .set_params = m88ts2022_set_params,
 536
 537         .get_frequency = m88ts2022_get_frequency,
 538         .get_if_frequency = m88ts2022_get_if_frequency,
 539         .get_rf_strength = m88ts2022_get_rf_strength,
 540 };
 541
 542 static int m88ts2022_probe(struct i2c_client *client,
 543                 const struct i2c_device_id *id)
 544 {
 545         struct m88ts2022_config *cfg = client->dev.platform_data;
 546         struct dvb_frontend *fe = cfg->fe;
 547         struct m88ts2022_priv *priv;
 548         int ret;
 549         u8 chip_id, u8tmp;
 550
 551         priv = kzalloc(sizeof(struct m88ts2022_priv), GFP_KERNEL);
 552         if (!priv) {
 553                 ret = -ENOMEM;
 554                 dev_err(&client->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
 555                 goto err;
 556         }
 557
 558         memcpy(&priv->cfg, cfg, sizeof(struct m88ts2022_config));
 559         priv->client = client;
 560
 561         /* check if the tuner is there */
 562         ret = m88ts2022_rd_reg(priv, 0x00, &u8tmp);
 563         if (ret)
 564                 goto err;
 565
 566         if ((u8tmp & 0x03) == 0x00) {
 567                 ret = m88ts2022_wr_reg(priv, 0x00, 0x01);
 568                 if (ret < 0)
 569                         goto err;
 570
 571                 usleep_range(2000, 50000);
 572         }
 573
 574         ret = m88ts2022_wr_reg(priv, 0x00, 0x03);
 575         if (ret)
 576                 goto err;
 577
 578         usleep_range(2000, 50000);
 579
 580         ret = m88ts2022_rd_reg(priv, 0x00, &chip_id);
 581         if (ret)
 582                 goto err;
 583
 584         dev_dbg(&priv->client->dev, "%s: chip_id=%02x\n", __func__, chip_id);
 585
 586         switch (chip_id) {
 587         case 0xc3:
 588         case 0x83:
 589                 break;
 590         default:
 591                 goto err;
 592         }
 593
 594         switch (priv->cfg.clock_out) {
 595         case M88TS2022_CLOCK_OUT_DISABLED:
 596                 u8tmp = 0x60;
 597                 break;
 598         case M88TS2022_CLOCK_OUT_ENABLED:
 599                 u8tmp = 0x70;
 600                 ret = m88ts2022_wr_reg(priv, 0x05, priv->cfg.clock_out_div);
 601                 if (ret)
 602                         goto err;
 603                 break;
 604         case M88TS2022_CLOCK_OUT_ENABLED_XTALOUT:
 605                 u8tmp = 0x6c;
 606                 break;
 607         default:
 608                 goto err;
 609         }
 610
 611         ret = m88ts2022_wr_reg(priv, 0x42, u8tmp);
 612         if (ret)
 613                 goto err;
 614
 615         if (priv->cfg.loop_through)
 616                 u8tmp = 0xec;
 617         else
 618                 u8tmp = 0x6c;
 619
 620         ret = m88ts2022_wr_reg(priv, 0x62, u8tmp);
 621         if (ret)
 622                 goto err;
 623
 624         /* sleep */
 625         ret = m88ts2022_wr_reg(priv, 0x00, 0x00);
 626         if (ret)
 627                 goto err;
 628
 629         dev_info(&priv->client->dev,
 630                         "%s: Montage M88TS2022 successfully identified\n",
 631                         KBUILD_MODNAME);
 632
 633         fe->tuner_priv = priv;
 634         memcpy(&fe->ops.tuner_ops, &m88ts2022_tuner_ops,
 635                         sizeof(struct dvb_tuner_ops));
 636
 637         i2c_set_clientdata(client, priv);
 638         return 0;
 639 err:
 640         dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret);
 641         kfree(priv);
 642         return ret;
 643 }
 644
 645 static int m88ts2022_remove(struct i2c_client *client)
 646 {
 647         struct m88ts2022_priv *priv = i2c_get_clientdata(client);
 648         struct dvb_frontend *fe = priv->cfg.fe;
 649         dev_dbg(&client->dev, "%s:\n", __func__);
 650
 651         memset(&fe->ops.tuner_ops, 0, sizeof(struct dvb_tuner_ops));
 652         fe->tuner_priv = NULL;
 653         kfree(priv);
 654
 655         return 0;
 656 }
 657
 658 static const struct i2c_device_id m88ts2022_id[] = {
 659         {"m88ts2022", 0},
 660         {}
 661 };
 662 MODULE_DEVICE_TABLE(i2c, m88ts2022_id);
 663
 664 static struct i2c_driver m88ts2022_driver = {
 665         .driver = {
 666                 .owner  = THIS_MODULE,
 667                 .name   = "m88ts2022",
 668         },
 669         .probe          = m88ts2022_probe,
 670         .remove         = m88ts2022_remove,
 671         .id_table       = m88ts2022_id,
 672 };
 673
 674 module_i2c_driver(m88ts2022_driver);
 675
 676 MODULE_DESCRIPTION("Montage M88TS2022 silicon tuner driver");
 677 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 678 MODULE_LICENSE("GPL");