drivers/media/dvb-frontends/dvb-pll.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * descriptions + helper functions for simple dvb plls.
   4  *
   5  * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/slab.h>
  11 #include <linux/module.h>
  12 #include <linux/idr.h>
  13 #include <linux/dvb/frontend.h>
  14 #include <asm/types.h>
  15
  16 #include "dvb-pll.h"
  17
  18 #define dprintk(fmt, arg...) \
  19         printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg)
  20
  21 struct dvb_pll_priv {
  22         /* pll number */
  23         int nr;
  24
  25         /* i2c details */
  26         int pll_i2c_address;
  27         struct i2c_adapter *i2c;
  28
  29         /* the PLL descriptor */
  30         const struct dvb_pll_desc *pll_desc;
  31
  32         /* cached frequency/bandwidth */
  33         u32 frequency;
  34         u32 bandwidth;
  35 };
  36
  37 #define DVB_PLL_MAX 64
  38 static DEFINE_IDA(pll_ida);
  39
  40 static int debug;
  41 module_param(debug, int, 0644);
  42 MODULE_PARM_DESC(debug, "enable verbose debug messages");
  43
  44 static unsigned int id[DVB_PLL_MAX] =
  45         { [ 0 ... (DVB_PLL_MAX-1) ] = DVB_PLL_UNDEFINED };
  46 module_param_array(id, int, NULL, 0644);
  47 MODULE_PARM_DESC(id, "force pll id to use (DEBUG ONLY)");
  48
  49 /* ----------------------------------------------------------- */
  50
  51 struct dvb_pll_desc {
  52         const char *name;
  53         u32  min;
  54         u32  max;
  55         u32  iffreq;
  56         void (*set)(struct dvb_frontend *fe, u8 *buf);
  57         u8   *initdata;
  58         u8   *initdata2;
  59         u8   *sleepdata;
  60         int  count;
  61         struct {
  62                 u32 limit;
  63                 u32 stepsize;
  64                 u8  config;
  65                 u8  cb;
  66         } entries[];
  67 };
  68
  69 /* ----------------------------------------------------------- */
  70 /* descriptions                                                */
  71
  72 static const struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
  73         .name  = "Thomson dtt7579",
  74         .min   = 177 * MHz,
  75         .max   = 858 * MHz,
  76         .iffreq= 36166667,
  77         .sleepdata = (u8[]){ 2, 0xb4, 0x03 },
  78         .count = 4,
  79         .entries = {
  80                 {  443250000, 166667, 0xb4, 0x02 },
  81                 {  542000000, 166667, 0xb4, 0x08 },
  82                 {  771000000, 166667, 0xbc, 0x08 },
  83                 {  999999999, 166667, 0xf4, 0x08 },
  84         },
  85 };
  86
  87 static void thomson_dtt759x_bw(struct dvb_frontend *fe, u8 *buf)
  88 {
  89         u32 bw = fe->dtv_property_cache.bandwidth_hz;
  90         if (bw == 7000000)
  91                 buf[3] |= 0x10;
  92 }
  93
  94 static const struct dvb_pll_desc dvb_pll_thomson_dtt759x = {
  95         .name  = "Thomson dtt759x",
  96         .min   = 177 * MHz,
  97         .max   = 896 * MHz,
  98         .set   = thomson_dtt759x_bw,
  99         .iffreq= 36166667,
 100         .sleepdata = (u8[]){ 2, 0x84, 0x03 },
 101         .count = 5,
 102         .entries = {
 103                 {  264000000, 166667, 0xb4, 0x02 },
 104                 {  470000000, 166667, 0xbc, 0x02 },
 105                 {  735000000, 166667, 0xbc, 0x08 },
 106                 {  835000000, 166667, 0xf4, 0x08 },
 107                 {  999999999, 166667, 0xfc, 0x08 },
 108         },
 109 };
 110
 111 static void thomson_dtt7520x_bw(struct dvb_frontend *fe, u8 *buf)
 112 {
 113         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 114         if (bw == 8000000)
 115                 buf[3] ^= 0x10;
 116 }
 117
 118 static const struct dvb_pll_desc dvb_pll_thomson_dtt7520x = {
 119         .name  = "Thomson dtt7520x",
 120         .min   = 185 * MHz,
 121         .max   = 900 * MHz,
 122         .set   = thomson_dtt7520x_bw,
 123         .iffreq = 36166667,
 124         .count = 7,
 125         .entries = {
 126                 {  305000000, 166667, 0xb4, 0x12 },
 127                 {  405000000, 166667, 0xbc, 0x12 },
 128                 {  445000000, 166667, 0xbc, 0x12 },
 129                 {  465000000, 166667, 0xf4, 0x18 },
 130                 {  735000000, 166667, 0xfc, 0x18 },
 131                 {  835000000, 166667, 0xbc, 0x18 },
 132                 {  999999999, 166667, 0xfc, 0x18 },
 133         },
 134 };
 135
 136 static const struct dvb_pll_desc dvb_pll_lg_z201 = {
 137         .name  = "LG z201",
 138         .min   = 174 * MHz,
 139         .max   = 862 * MHz,
 140         .iffreq= 36166667,
 141         .sleepdata = (u8[]){ 2, 0xbc, 0x03 },
 142         .count = 5,
 143         .entries = {
 144                 {  157500000, 166667, 0xbc, 0x01 },
 145                 {  443250000, 166667, 0xbc, 0x02 },
 146                 {  542000000, 166667, 0xbc, 0x04 },
 147                 {  830000000, 166667, 0xf4, 0x04 },
 148                 {  999999999, 166667, 0xfc, 0x04 },
 149         },
 150 };
 151
 152 static const struct dvb_pll_desc dvb_pll_unknown_1 = {
 153         .name  = "unknown 1", /* used by dntv live dvb-t */
 154         .min   = 174 * MHz,
 155         .max   = 862 * MHz,
 156         .iffreq= 36166667,
 157         .count = 9,
 158         .entries = {
 159                 {  150000000, 166667, 0xb4, 0x01 },
 160                 {  173000000, 166667, 0xbc, 0x01 },
 161                 {  250000000, 166667, 0xb4, 0x02 },
 162                 {  400000000, 166667, 0xbc, 0x02 },
 163                 {  420000000, 166667, 0xf4, 0x02 },
 164                 {  470000000, 166667, 0xfc, 0x02 },
 165                 {  600000000, 166667, 0xbc, 0x08 },
 166                 {  730000000, 166667, 0xf4, 0x08 },
 167                 {  999999999, 166667, 0xfc, 0x08 },
 168         },
 169 };
 170
 171 /* Infineon TUA6010XS
 172  * used in Thomson Cable Tuner
 173  */
 174 static const struct dvb_pll_desc dvb_pll_tua6010xs = {
 175         .name  = "Infineon TUA6010XS",
 176         .min   = 44250 * kHz,
 177         .max   = 858 * MHz,
 178         .iffreq= 36125000,
 179         .count = 3,
 180         .entries = {
 181                 {  115750000, 62500, 0x8e, 0x03 },
 182                 {  403250000, 62500, 0x8e, 0x06 },
 183                 {  999999999, 62500, 0x8e, 0x85 },
 184         },
 185 };
 186
 187 /* Panasonic env57h1xd5 (some Philips PLL ?) */
 188 static const struct dvb_pll_desc dvb_pll_env57h1xd5 = {
 189         .name  = "Panasonic ENV57H1XD5",
 190         .min   = 44250 * kHz,
 191         .max   = 858 * MHz,
 192         .iffreq= 36125000,
 193         .count = 4,
 194         .entries = {
 195                 {  153000000, 166667, 0xc2, 0x41 },
 196                 {  470000000, 166667, 0xc2, 0x42 },
 197                 {  526000000, 166667, 0xc2, 0x84 },
 198                 {  999999999, 166667, 0xc2, 0xa4 },
 199         },
 200 };
 201
 202 /* Philips TDA6650/TDA6651
 203  * used in Panasonic ENV77H11D5
 204  */
 205 static void tda665x_bw(struct dvb_frontend *fe, u8 *buf)
 206 {
 207         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 208         if (bw == 8000000)
 209                 buf[3] |= 0x08;
 210 }
 211
 212 static const struct dvb_pll_desc dvb_pll_tda665x = {
 213         .name  = "Philips TDA6650/TDA6651",
 214         .min   = 44250 * kHz,
 215         .max   = 858 * MHz,
 216         .set   = tda665x_bw,
 217         .iffreq= 36166667,
 218         .initdata = (u8[]){ 4, 0x0b, 0xf5, 0x85, 0xab },
 219         .count = 12,
 220         .entries = {
 221                 {   93834000, 166667, 0xca, 0x61 /* 011 0 0 0  01 */ },
 222                 {  123834000, 166667, 0xca, 0xa1 /* 101 0 0 0  01 */ },
 223                 {  161000000, 166667, 0xca, 0xa1 /* 101 0 0 0  01 */ },
 224                 {  163834000, 166667, 0xca, 0xc2 /* 110 0 0 0  10 */ },
 225                 {  253834000, 166667, 0xca, 0x62 /* 011 0 0 0  10 */ },
 226                 {  383834000, 166667, 0xca, 0xa2 /* 101 0 0 0  10 */ },
 227                 {  443834000, 166667, 0xca, 0xc2 /* 110 0 0 0  10 */ },
 228                 {  444000000, 166667, 0xca, 0xc4 /* 110 0 0 1  00 */ },
 229                 {  583834000, 166667, 0xca, 0x64 /* 011 0 0 1  00 */ },
 230                 {  793834000, 166667, 0xca, 0xa4 /* 101 0 0 1  00 */ },
 231                 {  444834000, 166667, 0xca, 0xc4 /* 110 0 0 1  00 */ },
 232                 {  861000000, 166667, 0xca, 0xe4 /* 111 0 0 1  00 */ },
 233         }
 234 };
 235
 236 /* Infineon TUA6034
 237  * used in LG TDTP E102P
 238  */
 239 static void tua6034_bw(struct dvb_frontend *fe, u8 *buf)
 240 {
 241         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 242         if (bw == 7000000)
 243                 buf[3] |= 0x08;
 244 }
 245
 246 static const struct dvb_pll_desc dvb_pll_tua6034 = {
 247         .name  = "Infineon TUA6034",
 248         .min   = 44250 * kHz,
 249         .max   = 858 * MHz,
 250         .iffreq= 36166667,
 251         .count = 3,
 252         .set   = tua6034_bw,
 253         .entries = {
 254                 {  174500000, 62500, 0xce, 0x01 },
 255                 {  230000000, 62500, 0xce, 0x02 },
 256                 {  999999999, 62500, 0xce, 0x04 },
 257         },
 258 };
 259
 260 /* ALPS TDED4
 261  * used in Nebula-Cards and USB boxes
 262  */
 263 static void tded4_bw(struct dvb_frontend *fe, u8 *buf)
 264 {
 265         u32 bw = fe->dtv_property_cache.bandwidth_hz;
 266         if (bw == 8000000)
 267                 buf[3] |= 0x04;
 268 }
 269
 270 static const struct dvb_pll_desc dvb_pll_tded4 = {
 271         .name = "ALPS TDED4",
 272         .min =  47 * MHz,
 273         .max = 863 * MHz,
 274         .iffreq= 36166667,
 275         .set   = tded4_bw,
 276         .count = 4,
 277         .entries = {
 278                 { 153000000, 166667, 0x85, 0x01 },
 279                 { 470000000, 166667, 0x85, 0x02 },
 280                 { 823000000, 166667, 0x85, 0x08 },
 281                 { 999999999, 166667, 0x85, 0x88 },
 282         }
 283 };
 284
 285 /* ALPS TDHU2
 286  * used in AverTVHD MCE A180
 287  */
 288 static const struct dvb_pll_desc dvb_pll_tdhu2 = {
 289         .name = "ALPS TDHU2",
 290         .min =  54 * MHz,
 291         .max = 864 * MHz,
 292         .iffreq= 44000000,
 293         .count = 4,
 294         .entries = {
 295                 { 162000000, 62500, 0x85, 0x01 },
 296                 { 426000000, 62500, 0x85, 0x02 },
 297                 { 782000000, 62500, 0x85, 0x08 },
 298                 { 999999999, 62500, 0x85, 0x88 },
 299         }
 300 };
 301
 302 /* Samsung TBMV30111IN / TBMV30712IN1
 303  * used in Air2PC ATSC - 2nd generation (nxt2002)
 304  */
 305 static const struct dvb_pll_desc dvb_pll_samsung_tbmv = {
 306         .name = "Samsung TBMV30111IN / TBMV30712IN1",
 307         .min =  54 * MHz,
 308         .max = 860 * MHz,
 309         .iffreq= 44000000,
 310         .count = 6,
 311         .entries = {
 312                 { 172000000, 166667, 0xb4, 0x01 },
 313                 { 214000000, 166667, 0xb4, 0x02 },
 314                 { 467000000, 166667, 0xbc, 0x02 },
 315                 { 721000000, 166667, 0xbc, 0x08 },
 316                 { 841000000, 166667, 0xf4, 0x08 },
 317                 { 999999999, 166667, 0xfc, 0x02 },
 318         }
 319 };
 320
 321 /*
 322  * Philips SD1878 Tuner.
 323  */
 324 static const struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261 = {
 325         .name  = "Philips SD1878",
 326         .min   =  950 * MHz,
 327         .max   = 2150 * MHz,
 328         .iffreq= 249, /* zero-IF, offset 249 is to round up */
 329         .count = 4,
 330         .entries = {
 331                 { 1250000, 500, 0xc4, 0x00},
 332                 { 1450000, 500, 0xc4, 0x40},
 333                 { 2050000, 500, 0xc4, 0x80},
 334                 { 2150000, 500, 0xc4, 0xc0},
 335         },
 336 };
 337
 338 static void opera1_bw(struct dvb_frontend *fe, u8 *buf)
 339 {
 340         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 341         struct dvb_pll_priv *priv = fe->tuner_priv;
 342         u32 b_w  = (c->symbol_rate * 27) / 32000;
 343         struct i2c_msg msg = {
 344                 .addr = priv->pll_i2c_address,
 345                 .flags = 0,
 346                 .buf = buf,
 347                 .len = 4
 348         };
 349         int result;
 350         u8 lpf;
 351
 352         if (fe->ops.i2c_gate_ctrl)
 353                 fe->ops.i2c_gate_ctrl(fe, 1);
 354
 355         result = i2c_transfer(priv->i2c, &msg, 1);
 356         if (result != 1)
 357                 pr_err("%s: i2c_transfer failed:%d",
 358                         __func__, result);
 359
 360         if (b_w <= 10000)
 361                 lpf = 0xc;
 362         else if (b_w <= 12000)
 363                 lpf = 0x2;
 364         else if (b_w <= 14000)
 365                 lpf = 0xa;
 366         else if (b_w <= 16000)
 367                 lpf = 0x6;
 368         else if (b_w <= 18000)
 369                 lpf = 0xe;
 370         else if (b_w <= 20000)
 371                 lpf = 0x1;
 372         else if (b_w <= 22000)
 373                 lpf = 0x9;
 374         else if (b_w <= 24000)
 375                 lpf = 0x5;
 376         else if (b_w <= 26000)
 377                 lpf = 0xd;
 378         else if (b_w <= 28000)
 379                 lpf = 0x3;
 380                 else
 381                 lpf = 0xb;
 382         buf[2] ^= 0x1c; /* Flip bits 3-5 */
 383         /* Set lpf */
 384         buf[2] |= ((lpf >> 2) & 0x3) << 3;
 385         buf[3] |= (lpf & 0x3) << 2;
 386
 387         return;
 388 }
 389
 390 static const struct dvb_pll_desc dvb_pll_opera1 = {
 391         .name  = "Opera Tuner",
 392         .min   =  900 * MHz,
 393         .max   = 2250 * MHz,
 394         .initdata = (u8[]){ 4, 0x08, 0xe5, 0xe1, 0x00 },
 395         .initdata2 = (u8[]){ 4, 0x08, 0xe5, 0xe5, 0x00 },
 396         .iffreq= 0,
 397         .set   = opera1_bw,
 398         .count = 8,
 399         .entries = {
 400                 { 1064000, 500, 0xf9, 0xc2 },
 401                 { 1169000, 500, 0xf9, 0xe2 },
 402                 { 1299000, 500, 0xf9, 0x20 },
 403                 { 1444000, 500, 0xf9, 0x40 },
 404                 { 1606000, 500, 0xf9, 0x60 },
 405                 { 1777000, 500, 0xf9, 0x80 },
 406                 { 1941000, 500, 0xf9, 0xa0 },
 407                 { 2250000, 500, 0xf9, 0xc0 },
 408         }
 409 };
 410
 411 static void samsung_dtos403ih102a_set(struct dvb_frontend *fe, u8 *buf)
 412 {
 413         struct dvb_pll_priv *priv = fe->tuner_priv;
 414         struct i2c_msg msg = {
 415                 .addr = priv->pll_i2c_address,
 416                 .flags = 0,
 417                 .buf = buf,
 418                 .len = 4
 419         };
 420         int result;
 421
 422         if (fe->ops.i2c_gate_ctrl)
 423                 fe->ops.i2c_gate_ctrl(fe, 1);
 424
 425         result = i2c_transfer(priv->i2c, &msg, 1);
 426         if (result != 1)
 427                 pr_err("%s: i2c_transfer failed:%d",
 428                         __func__, result);
 429
 430         buf[2] = 0x9e;
 431         buf[3] = 0x90;
 432
 433         return;
 434 }
 435
 436 /* unknown pll used in Samsung DTOS403IH102A DVB-C tuner */
 437 static const struct dvb_pll_desc dvb_pll_samsung_dtos403ih102a = {
 438         .name   = "Samsung DTOS403IH102A",
 439         .min    = 44250 * kHz,
 440         .max    = 858 * MHz,
 441         .iffreq =  36125000,
 442         .count  = 8,
 443         .set    = samsung_dtos403ih102a_set,
 444         .entries = {
 445                 { 135000000, 62500, 0xbe, 0x01 },
 446                 { 177000000, 62500, 0xf6, 0x01 },
 447                 { 370000000, 62500, 0xbe, 0x02 },
 448                 { 450000000, 62500, 0xf6, 0x02 },
 449                 { 466000000, 62500, 0xfe, 0x02 },
 450                 { 538000000, 62500, 0xbe, 0x08 },
 451                 { 826000000, 62500, 0xf6, 0x08 },
 452                 { 999999999, 62500, 0xfe, 0x08 },
 453         }
 454 };
 455
 456 /* Samsung TDTC9251DH0 DVB-T NIM, as used on AirStar 2 */
 457 static const struct dvb_pll_desc dvb_pll_samsung_tdtc9251dh0 = {
 458         .name   = "Samsung TDTC9251DH0",
 459         .min    =  48 * MHz,
 460         .max    = 863 * MHz,
 461         .iffreq =  36166667,
 462         .count  = 3,
 463         .entries = {
 464                 { 157500000, 166667, 0xcc, 0x09 },
 465                 { 443000000, 166667, 0xcc, 0x0a },
 466                 { 863000000, 166667, 0xcc, 0x08 },
 467         }
 468 };
 469
 470 /* Samsung TBDU18132 DVB-S NIM with TSA5059 PLL, used in SkyStar2 DVB-S 2.3 */
 471 static const struct dvb_pll_desc dvb_pll_samsung_tbdu18132 = {
 472         .name = "Samsung TBDU18132",
 473         .min    =  950 * MHz,
 474         .max    = 2150 * MHz, /* guesses */
 475         .iffreq = 0,
 476         .count = 2,
 477         .entries = {
 478                 { 1550000, 125, 0x84, 0x82 },
 479                 { 4095937, 125, 0x84, 0x80 },
 480         }
 481         /* TSA5059 PLL has a 17 bit divisor rather than the 15 bits supported
 482          * by this driver.  The two extra bits are 0x60 in the third byte.  15
 483          * bits is enough for over 4 GHz, which is enough to cover the range
 484          * of this tuner.  We could use the additional divisor bits by adding
 485          * more entries, e.g.
 486          { 0x0ffff * 125 + 125/2, 125, 0x84 | 0x20, },
 487          { 0x17fff * 125 + 125/2, 125, 0x84 | 0x40, },
 488          { 0x1ffff * 125 + 125/2, 125, 0x84 | 0x60, }, */
 489 };
 490
 491 /* Samsung TBMU24112 DVB-S NIM with SL1935 zero-IF tuner */
 492 static const struct dvb_pll_desc dvb_pll_samsung_tbmu24112 = {
 493         .name = "Samsung TBMU24112",
 494         .min    =  950 * MHz,
 495         .max    = 2150 * MHz, /* guesses */
 496         .iffreq = 0,
 497         .count = 2,
 498         .entries = {
 499                 { 1500000, 125, 0x84, 0x18 },
 500                 { 9999999, 125, 0x84, 0x08 },
 501         }
 502 };
 503
 504 /* Alps TDEE4 DVB-C NIM, used on Cablestar 2 */
 505 /* byte 4 : 1  *   *   AGD R3  R2  R1  R0
 506  * byte 5 : C1 *   RE  RTS BS4 BS3 BS2 BS1
 507  * AGD = 1, R3 R2 R1 R0 = 0 1 0 1 => byte 4 = 1**10101 = 0x95
 508  * Range(MHz)  C1 *  RE RTS BS4 BS3 BS2 BS1  Byte 5
 509  *  47 - 153   0  *  0   0   0   0   0   1   0x01
 510  * 153 - 430   0  *  0   0   0   0   1   0   0x02
 511  * 430 - 822   0  *  0   0   1   0   0   0   0x08
 512  * 822 - 862   1  *  0   0   1   0   0   0   0x88 */
 513 static const struct dvb_pll_desc dvb_pll_alps_tdee4 = {
 514         .name = "ALPS TDEE4",
 515         .min    =  47 * MHz,
 516         .max    = 862 * MHz,
 517         .iffreq =  36125000,
 518         .count = 4,
 519         .entries = {
 520                 { 153000000, 62500, 0x95, 0x01 },
 521                 { 430000000, 62500, 0x95, 0x02 },
 522                 { 822000000, 62500, 0x95, 0x08 },
 523                 { 999999999, 62500, 0x95, 0x88 },
 524         }
 525 };
 526
 527 /* Infineon TUA6034 ISDB-T, used in Friio */
 528 /* CP cur. 50uA, AGC takeover: 103dBuV, PORT3 on */
 529 static const struct dvb_pll_desc dvb_pll_tua6034_friio = {
 530         .name   = "Infineon TUA6034 ISDB-T (Friio)",
 531         .min    =  90 * MHz,
 532         .max    = 770 * MHz,
 533         .iffreq =  57000000,
 534         .initdata = (u8[]){ 4, 0x9a, 0x50, 0xb2, 0x08 },
 535         .sleepdata = (u8[]){ 4, 0x9a, 0x70, 0xb3, 0x0b },
 536         .count = 3,
 537         .entries = {
 538                 { 170000000, 142857, 0xba, 0x09 },
 539                 { 470000000, 142857, 0xba, 0x0a },
 540                 { 770000000, 142857, 0xb2, 0x08 },
 541         }
 542 };
 543
 544 /* Philips TDA6651 ISDB-T, used in Earthsoft PT1 */
 545 static const struct dvb_pll_desc dvb_pll_tda665x_earth_pt1 = {
 546         .name   = "Philips TDA6651 ISDB-T (EarthSoft PT1)",
 547         .min    =  90 * MHz,
 548         .max    = 770 * MHz,
 549         .iffreq =  57000000,
 550         .initdata = (u8[]){ 5, 0x0e, 0x7f, 0xc1, 0x80, 0x80 },
 551         .count = 10,
 552         .entries = {
 553                 { 140000000, 142857, 0xc1, 0x81 },
 554                 { 170000000, 142857, 0xc1, 0xa1 },
 555                 { 220000000, 142857, 0xc1, 0x62 },
 556                 { 330000000, 142857, 0xc1, 0xa2 },
 557                 { 402000000, 142857, 0xc1, 0xe2 },
 558                 { 450000000, 142857, 0xc1, 0x64 },
 559                 { 550000000, 142857, 0xc1, 0x84 },
 560                 { 600000000, 142857, 0xc1, 0xa4 },
 561                 { 700000000, 142857, 0xc1, 0xc4 },
 562                 { 770000000, 142857, 0xc1, 0xe4 },
 563         }
 564 };
 565
 566 /* ----------------------------------------------------------- */
 567
 568 static const struct dvb_pll_desc *pll_list[] = {
 569         [DVB_PLL_UNDEFINED]              = NULL,
 570         [DVB_PLL_THOMSON_DTT7579]        = &dvb_pll_thomson_dtt7579,
 571         [DVB_PLL_THOMSON_DTT759X]        = &dvb_pll_thomson_dtt759x,
 572         [DVB_PLL_THOMSON_DTT7520X]       = &dvb_pll_thomson_dtt7520x,
 573         [DVB_PLL_LG_Z201]                = &dvb_pll_lg_z201,
 574         [DVB_PLL_UNKNOWN_1]              = &dvb_pll_unknown_1,
 575         [DVB_PLL_TUA6010XS]              = &dvb_pll_tua6010xs,
 576         [DVB_PLL_ENV57H1XD5]             = &dvb_pll_env57h1xd5,
 577         [DVB_PLL_TUA6034]                = &dvb_pll_tua6034,
 578         [DVB_PLL_TDA665X]                = &dvb_pll_tda665x,
 579         [DVB_PLL_TDED4]                  = &dvb_pll_tded4,
 580         [DVB_PLL_TDEE4]                  = &dvb_pll_alps_tdee4,
 581         [DVB_PLL_TDHU2]                  = &dvb_pll_tdhu2,
 582         [DVB_PLL_SAMSUNG_TBMV]           = &dvb_pll_samsung_tbmv,
 583         [DVB_PLL_PHILIPS_SD1878_TDA8261] = &dvb_pll_philips_sd1878_tda8261,
 584         [DVB_PLL_OPERA1]                 = &dvb_pll_opera1,
 585         [DVB_PLL_SAMSUNG_DTOS403IH102A]  = &dvb_pll_samsung_dtos403ih102a,
 586         [DVB_PLL_SAMSUNG_TDTC9251DH0]    = &dvb_pll_samsung_tdtc9251dh0,
 587         [DVB_PLL_SAMSUNG_TBDU18132]      = &dvb_pll_samsung_tbdu18132,
 588         [DVB_PLL_SAMSUNG_TBMU24112]      = &dvb_pll_samsung_tbmu24112,
 589         [DVB_PLL_TUA6034_FRIIO]          = &dvb_pll_tua6034_friio,
 590         [DVB_PLL_TDA665X_EARTH_PT1]      = &dvb_pll_tda665x_earth_pt1,
 591 };
 592
 593 /* ----------------------------------------------------------- */
 594 /* code                                                        */
 595
 596 static int dvb_pll_configure(struct dvb_frontend *fe, u8 *buf,
 597                              const u32 frequency)
 598 {
 599         struct dvb_pll_priv *priv = fe->tuner_priv;
 600         const struct dvb_pll_desc *desc = priv->pll_desc;
 601         u32 div;
 602         int i;
 603
 604         for (i = 0; i < desc->count; i++) {
 605                 if (frequency > desc->entries[i].limit)
 606                         continue;
 607                 break;
 608         }
 609
 610         if (debug)
 611                 dprintk("pll: %s: freq=%d | i=%d/%d\n", desc->name,
 612                        frequency, i, desc->count);
 613         if (i == desc->count)
 614                 return -EINVAL;
 615
 616         div = (frequency + desc->iffreq +
 617                desc->entries[i].stepsize/2) / desc->entries[i].stepsize;
 618         buf[0] = div >> 8;
 619         buf[1] = div & 0xff;
 620         buf[2] = desc->entries[i].config;
 621         buf[3] = desc->entries[i].cb;
 622
 623         if (desc->set)
 624                 desc->set(fe, buf);
 625
 626         if (debug)
 627                 dprintk("pll: %s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
 628                        desc->name, div, buf[0], buf[1], buf[2], buf[3]);
 629
 630         // calculate the frequency we set it to
 631         return (div * desc->entries[i].stepsize) - desc->iffreq;
 632 }
 633
 634 static void dvb_pll_release(struct dvb_frontend *fe)
 635 {
 636         kfree(fe->tuner_priv);
 637         fe->tuner_priv = NULL;
 638 }
 639
 640 static int dvb_pll_sleep(struct dvb_frontend *fe)
 641 {
 642         struct dvb_pll_priv *priv = fe->tuner_priv;
 643
 644         if (priv->i2c == NULL)
 645                 return -EINVAL;
 646
 647         if (priv->pll_desc->sleepdata) {
 648                 struct i2c_msg msg = { .flags = 0,
 649                         .addr = priv->pll_i2c_address,
 650                         .buf = priv->pll_desc->sleepdata + 1,
 651                         .len = priv->pll_desc->sleepdata[0] };
 652
 653                 int result;
 654
 655                 if (fe->ops.i2c_gate_ctrl)
 656                         fe->ops.i2c_gate_ctrl(fe, 1);
 657                 if ((result = i2c_transfer(priv->i2c, &msg, 1)) != 1) {
 658                         return result;
 659                 }
 660                 return 0;
 661         }
 662         /* Shouldn't be called when initdata is NULL, maybe BUG()? */
 663         return -EINVAL;
 664 }
 665
 666 static int dvb_pll_set_params(struct dvb_frontend *fe)
 667 {
 668         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 669         struct dvb_pll_priv *priv = fe->tuner_priv;
 670         u8 buf[4];
 671         struct i2c_msg msg =
 672                 { .addr = priv->pll_i2c_address, .flags = 0,
 673                   .buf = buf, .len = sizeof(buf) };
 674         int result;
 675         u32 frequency = 0;
 676
 677         if (priv->i2c == NULL)
 678                 return -EINVAL;
 679
 680         result = dvb_pll_configure(fe, buf, c->frequency);
 681         if (result < 0)
 682                 return result;
 683         else
 684                 frequency = result;
 685
 686         if (fe->ops.i2c_gate_ctrl)
 687                 fe->ops.i2c_gate_ctrl(fe, 1);
 688         if ((result = i2c_transfer(priv->i2c, &msg, 1)) != 1) {
 689                 return result;
 690         }
 691
 692         priv->frequency = frequency;
 693         priv->bandwidth = c->bandwidth_hz;
 694
 695         return 0;
 696 }
 697
 698 static int dvb_pll_calc_regs(struct dvb_frontend *fe,
 699                              u8 *buf, int buf_len)
 700 {
 701         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 702         struct dvb_pll_priv *priv = fe->tuner_priv;
 703         int result;
 704         u32 frequency = 0;
 705
 706         if (buf_len < 5)
 707                 return -EINVAL;
 708
 709         result = dvb_pll_configure(fe, buf + 1, c->frequency);
 710         if (result < 0)
 711                 return result;
 712         else
 713                 frequency = result;
 714
 715         buf[0] = priv->pll_i2c_address;
 716
 717         priv->frequency = frequency;
 718         priv->bandwidth = c->bandwidth_hz;
 719
 720         return 5;
 721 }
 722
 723 static int dvb_pll_get_frequency(struct dvb_frontend *fe, u32 *frequency)
 724 {
 725         struct dvb_pll_priv *priv = fe->tuner_priv;
 726         *frequency = priv->frequency;
 727         return 0;
 728 }
 729
 730 static int dvb_pll_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
 731 {
 732         struct dvb_pll_priv *priv = fe->tuner_priv;
 733         *bandwidth = priv->bandwidth;
 734         return 0;
 735 }
 736
 737 static int dvb_pll_init(struct dvb_frontend *fe)
 738 {
 739         struct dvb_pll_priv *priv = fe->tuner_priv;
 740
 741         if (priv->i2c == NULL)
 742                 return -EINVAL;
 743
 744         if (priv->pll_desc->initdata) {
 745                 struct i2c_msg msg = { .flags = 0,
 746                         .addr = priv->pll_i2c_address,
 747                         .buf = priv->pll_desc->initdata + 1,
 748                         .len = priv->pll_desc->initdata[0] };
 749
 750                 int result;
 751                 if (fe->ops.i2c_gate_ctrl)
 752                         fe->ops.i2c_gate_ctrl(fe, 1);
 753                 result = i2c_transfer(priv->i2c, &msg, 1);
 754                 if (result != 1)
 755                         return result;
 756                 if (priv->pll_desc->initdata2) {
 757                         msg.buf = priv->pll_desc->initdata2 + 1;
 758                         msg.len = priv->pll_desc->initdata2[0];
 759                         if (fe->ops.i2c_gate_ctrl)
 760                                 fe->ops.i2c_gate_ctrl(fe, 1);
 761                         result = i2c_transfer(priv->i2c, &msg, 1);
 762                         if (result != 1)
 763                                 return result;
 764                 }
 765                 return 0;
 766         }
 767         /* Shouldn't be called when initdata is NULL, maybe BUG()? */
 768         return -EINVAL;
 769 }
 770
 771 static const struct dvb_tuner_ops dvb_pll_tuner_ops = {
 772         .release = dvb_pll_release,
 773         .sleep = dvb_pll_sleep,
 774         .init = dvb_pll_init,
 775         .set_params = dvb_pll_set_params,
 776         .calc_regs = dvb_pll_calc_regs,
 777         .get_frequency = dvb_pll_get_frequency,
 778         .get_bandwidth = dvb_pll_get_bandwidth,
 779 };
 780
 781 struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
 782                                     struct i2c_adapter *i2c,
 783                                     unsigned int pll_desc_id)
 784 {
 785         u8 *b1;
 786         struct i2c_msg msg = { .addr = pll_addr, .flags = I2C_M_RD, .len = 1 };
 787         struct dvb_pll_priv *priv = NULL;
 788         int ret;
 789         const struct dvb_pll_desc *desc;
 790         int nr;
 791
 792         b1 = kmalloc(1, GFP_KERNEL);
 793         if (!b1)
 794                 return NULL;
 795
 796         b1[0] = 0;
 797         msg.buf = b1;
 798
 799         nr = ida_simple_get(&pll_ida, 0, DVB_PLL_MAX, GFP_KERNEL);
 800         if (nr < 0) {
 801                 kfree(b1);
 802                 return NULL;
 803         }
 804
 805         if (id[nr] > DVB_PLL_UNDEFINED && id[nr] < ARRAY_SIZE(pll_list))
 806                 pll_desc_id = id[nr];
 807
 808         BUG_ON(pll_desc_id < 1 || pll_desc_id >= ARRAY_SIZE(pll_list));
 809
 810         desc = pll_list[pll_desc_id];
 811
 812         if (i2c != NULL) {
 813                 if (fe->ops.i2c_gate_ctrl)
 814                         fe->ops.i2c_gate_ctrl(fe, 1);
 815
 816                 ret = i2c_transfer (i2c, &msg, 1);
 817                 if (ret != 1)
 818                         goto out;
 819                 if (fe->ops.i2c_gate_ctrl)
 820                              fe->ops.i2c_gate_ctrl(fe, 0);
 821         }
 822
 823         priv = kzalloc(sizeof(struct dvb_pll_priv), GFP_KERNEL);
 824         if (!priv)
 825                 goto out;
 826
 827         priv->pll_i2c_address = pll_addr;
 828         priv->i2c = i2c;
 829         priv->pll_desc = desc;
 830         priv->nr = nr;
 831
 832         memcpy(&fe->ops.tuner_ops, &dvb_pll_tuner_ops,
 833                sizeof(struct dvb_tuner_ops));
 834
 835         strscpy(fe->ops.tuner_ops.info.name, desc->name,
 836                 sizeof(fe->ops.tuner_ops.info.name));
 837
 838         fe->ops.tuner_ops.info.frequency_min_hz = desc->min;
 839         fe->ops.tuner_ops.info.frequency_max_hz = desc->max;
 840
 841         dprintk("%s tuner, frequency range: %u...%u\n",
 842                 desc->name, desc->min, desc->max);
 843
 844         if (!desc->initdata)
 845                 fe->ops.tuner_ops.init = NULL;
 846         if (!desc->sleepdata)
 847                 fe->ops.tuner_ops.sleep = NULL;
 848
 849         fe->tuner_priv = priv;
 850
 851         if ((debug) || (id[priv->nr] == pll_desc_id)) {
 852                 dprintk("dvb-pll[%d]", priv->nr);
 853                 if (i2c != NULL)
 854                         pr_cont(" %d-%04x", i2c_adapter_id(i2c), pll_addr);
 855                 pr_cont(": id# %d (%s) attached, %s\n", pll_desc_id, desc->name,
 856                        id[priv->nr] == pll_desc_id ?
 857                                 "insmod option" : "autodetected");
 858         }
 859
 860         kfree(b1);
 861
 862         return fe;
 863 out:
 864         kfree(b1);
 865         ida_simple_remove(&pll_ida, nr);
 866
 867         return NULL;
 868 }
 869 EXPORT_SYMBOL_GPL(dvb_pll_attach);
 870
 871
 872 static int
 873 dvb_pll_probe(struct i2c_client *client)
 874 {
 875         const struct i2c_device_id *id = i2c_client_get_device_id(client);
 876         struct dvb_pll_config *cfg;
 877         struct dvb_frontend *fe;
 878         unsigned int desc_id;
 879
 880         cfg = client->dev.platform_data;
 881         fe = cfg->fe;
 882         i2c_set_clientdata(client, fe);
 883         desc_id = (unsigned int) id->driver_data;
 884
 885         if (!dvb_pll_attach(fe, client->addr, client->adapter, desc_id))
 886                 return -ENOMEM;
 887
 888         /*
 889          * Unset tuner_ops.release (== dvb_pll_release)
 890          * which has been just set in the above dvb_pll_attach(),
 891          * because if tuner_ops.release was left defined,
 892          * this module would be 'put' twice on exit:
 893          * once by dvb_frontend_detach() and another by dvb_module_release().
 894          *
 895          * dvb_pll_release is instead executed in the i2c driver's .remove(),
 896          * keeping dvb_pll_attach untouched for legacy (dvb_attach) drivers.
 897          */
 898         fe->ops.tuner_ops.release = NULL;
 899         dev_info(&client->dev, "DVB Simple Tuner attached.\n");
 900         return 0;
 901 }
 902
 903 static void dvb_pll_remove(struct i2c_client *client)
 904 {
 905         struct dvb_frontend *fe = i2c_get_clientdata(client);
 906         struct dvb_pll_priv *priv = fe->tuner_priv;
 907
 908         ida_simple_remove(&pll_ida, priv->nr);
 909         dvb_pll_release(fe);
 910 }
 911
 912
 913 static const struct i2c_device_id dvb_pll_id[] = {
 914         {"dtt7579",             DVB_PLL_THOMSON_DTT7579},
 915         {"dtt759x",             DVB_PLL_THOMSON_DTT759X},
 916         {"z201",                DVB_PLL_LG_Z201},
 917         {"unknown_1",           DVB_PLL_UNKNOWN_1},
 918         {"tua6010xs",           DVB_PLL_TUA6010XS},
 919         {"env57h1xd5",          DVB_PLL_ENV57H1XD5},
 920         {"tua6034",             DVB_PLL_TUA6034},
 921         {"tda665x",             DVB_PLL_TDA665X},
 922         {"tded4",               DVB_PLL_TDED4},
 923         {"tdhu2",               DVB_PLL_TDHU2},
 924         {"tbmv",                DVB_PLL_SAMSUNG_TBMV},
 925         {"sd1878_tda8261",      DVB_PLL_PHILIPS_SD1878_TDA8261},
 926         {"opera1",              DVB_PLL_OPERA1},
 927         {"dtos403ih102a",       DVB_PLL_SAMSUNG_DTOS403IH102A},
 928         {"tdtc9251dh0",         DVB_PLL_SAMSUNG_TDTC9251DH0},
 929         {"tbdu18132",           DVB_PLL_SAMSUNG_TBDU18132},
 930         {"tbmu24112",           DVB_PLL_SAMSUNG_TBMU24112},
 931         {"tdee4",               DVB_PLL_TDEE4},
 932         {"dtt7520x",            DVB_PLL_THOMSON_DTT7520X},
 933         {"tua6034_friio",       DVB_PLL_TUA6034_FRIIO},
 934         {"tda665x_earthpt1",    DVB_PLL_TDA665X_EARTH_PT1},
 935         {}
 936 };
 937
 938
 939 MODULE_DEVICE_TABLE(i2c, dvb_pll_id);
 940
 941 static struct i2c_driver dvb_pll_driver = {
 942         .driver = {
 943                 .name = "dvb_pll",
 944         },
 945         .probe    = dvb_pll_probe,
 946         .remove   = dvb_pll_remove,
 947         .id_table = dvb_pll_id,
 948 };
 949
 950 module_i2c_driver(dvb_pll_driver);
 951
 952 MODULE_DESCRIPTION("dvb pll library");
 953 MODULE_AUTHOR("Gerd Knorr");
 954 MODULE_LICENSE("GPL");