treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / 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/dvb/frontend.h>
13 #include <asm/types.h>
14
15 #include "dvb-pll.h"
16
17 #define dprintk(fmt, arg...) \
18         printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg)
19
20 struct dvb_pll_priv {
21         /* pll number */
22         int nr;
23
24         /* i2c details */
25         int pll_i2c_address;
26         struct i2c_adapter *i2c;
27
28         /* the PLL descriptor */
29         const struct dvb_pll_desc *pll_desc;
30
31         /* cached frequency/bandwidth */
32         u32 frequency;
33         u32 bandwidth;
34 };
35
36 #define DVB_PLL_MAX 64
37
38 static unsigned int dvb_pll_devcount;
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
791         b1 = kmalloc(1, GFP_KERNEL);
792         if (!b1)
793                 return NULL;
794
795         b1[0] = 0;
796         msg.buf = b1;
797
798         if ((id[dvb_pll_devcount] > DVB_PLL_UNDEFINED) &&
799             (id[dvb_pll_devcount] < ARRAY_SIZE(pll_list)))
800                 pll_desc_id = id[dvb_pll_devcount];
801
802         BUG_ON(pll_desc_id < 1 || pll_desc_id >= ARRAY_SIZE(pll_list));
803
804         desc = pll_list[pll_desc_id];
805
806         if (i2c != NULL) {
807                 if (fe->ops.i2c_gate_ctrl)
808                         fe->ops.i2c_gate_ctrl(fe, 1);
809
810                 ret = i2c_transfer (i2c, &msg, 1);
811                 if (ret != 1) {
812                         kfree(b1);
813                         return NULL;
814                 }
815                 if (fe->ops.i2c_gate_ctrl)
816                              fe->ops.i2c_gate_ctrl(fe, 0);
817         }
818
819         priv = kzalloc(sizeof(struct dvb_pll_priv), GFP_KERNEL);
820         if (!priv) {
821                 kfree(b1);
822                 return NULL;
823         }
824
825         priv->pll_i2c_address = pll_addr;
826         priv->i2c = i2c;
827         priv->pll_desc = desc;
828         priv->nr = dvb_pll_devcount++;
829
830         memcpy(&fe->ops.tuner_ops, &dvb_pll_tuner_ops,
831                sizeof(struct dvb_tuner_ops));
832
833         strscpy(fe->ops.tuner_ops.info.name, desc->name,
834                 sizeof(fe->ops.tuner_ops.info.name));
835
836         fe->ops.tuner_ops.info.frequency_min_hz = desc->min;
837         fe->ops.tuner_ops.info.frequency_max_hz = desc->max;
838
839         dprintk("%s tuner, frequency range: %u...%u\n",
840                 desc->name, desc->min, desc->max);
841
842         if (!desc->initdata)
843                 fe->ops.tuner_ops.init = NULL;
844         if (!desc->sleepdata)
845                 fe->ops.tuner_ops.sleep = NULL;
846
847         fe->tuner_priv = priv;
848
849         if ((debug) || (id[priv->nr] == pll_desc_id)) {
850                 dprintk("dvb-pll[%d]", priv->nr);
851                 if (i2c != NULL)
852                         pr_cont(" %d-%04x", i2c_adapter_id(i2c), pll_addr);
853                 pr_cont(": id# %d (%s) attached, %s\n", pll_desc_id, desc->name,
854                        id[priv->nr] == pll_desc_id ?
855                                 "insmod option" : "autodetected");
856         }
857
858         kfree(b1);
859
860         return fe;
861 }
862 EXPORT_SYMBOL(dvb_pll_attach);
863
864
865 static int
866 dvb_pll_probe(struct i2c_client *client, const struct i2c_device_id *id)
867 {
868         struct dvb_pll_config *cfg;
869         struct dvb_frontend *fe;
870         unsigned int desc_id;
871
872         cfg = client->dev.platform_data;
873         fe = cfg->fe;
874         i2c_set_clientdata(client, fe);
875         desc_id = (unsigned int) id->driver_data;
876
877         if (!dvb_pll_attach(fe, client->addr, client->adapter, desc_id))
878                 return -ENOMEM;
879
880         /*
881          * Unset tuner_ops.release (== dvb_pll_release)
882          * which has been just set in the above dvb_pll_attach(),
883          * because if tuner_ops.release was left defined,
884          * this module would be 'put' twice on exit:
885          * once by dvb_frontend_detach() and another by dvb_module_release().
886          *
887          * dvb_pll_release is instead executed in the i2c driver's .remove(),
888          * keeping dvb_pll_attach untouched for legacy (dvb_attach) drivers.
889          */
890         fe->ops.tuner_ops.release = NULL;
891         dev_info(&client->dev, "DVB Simple Tuner attached.\n");
892         return 0;
893 }
894
895 static int dvb_pll_remove(struct i2c_client *client)
896 {
897         struct dvb_frontend *fe;
898
899         fe = i2c_get_clientdata(client);
900         dvb_pll_release(fe);
901         return 0;
902 }
903
904
905 static const struct i2c_device_id dvb_pll_id[] = {
906         {"dtt7579",             DVB_PLL_THOMSON_DTT7579},
907         {"dtt759x",             DVB_PLL_THOMSON_DTT759X},
908         {"z201",                DVB_PLL_LG_Z201},
909         {"unknown_1",           DVB_PLL_UNKNOWN_1},
910         {"tua6010xs",           DVB_PLL_TUA6010XS},
911         {"env57h1xd5",          DVB_PLL_ENV57H1XD5},
912         {"tua6034",             DVB_PLL_TUA6034},
913         {"tda665x",             DVB_PLL_TDA665X},
914         {"tded4",               DVB_PLL_TDED4},
915         {"tdhu2",               DVB_PLL_TDHU2},
916         {"tbmv",                DVB_PLL_SAMSUNG_TBMV},
917         {"sd1878_tda8261",      DVB_PLL_PHILIPS_SD1878_TDA8261},
918         {"opera1",              DVB_PLL_OPERA1},
919         {"dtos403ih102a",       DVB_PLL_SAMSUNG_DTOS403IH102A},
920         {"tdtc9251dh0",         DVB_PLL_SAMSUNG_TDTC9251DH0},
921         {"tbdu18132",           DVB_PLL_SAMSUNG_TBDU18132},
922         {"tbmu24112",           DVB_PLL_SAMSUNG_TBMU24112},
923         {"tdee4",               DVB_PLL_TDEE4},
924         {"dtt7520x",            DVB_PLL_THOMSON_DTT7520X},
925         {"tua6034_friio",       DVB_PLL_TUA6034_FRIIO},
926         {"tda665x_earthpt1",    DVB_PLL_TDA665X_EARTH_PT1},
927         {}
928 };
929
930
931 MODULE_DEVICE_TABLE(i2c, dvb_pll_id);
932
933 static struct i2c_driver dvb_pll_driver = {
934         .driver = {
935                 .name = "dvb_pll",
936         },
937         .probe    = dvb_pll_probe,
938         .remove   = dvb_pll_remove,
939         .id_table = dvb_pll_id,
940 };
941
942 module_i2c_driver(dvb_pll_driver);
943
944 MODULE_DESCRIPTION("dvb pll library");
945 MODULE_AUTHOR("Gerd Knorr");
946 MODULE_LICENSE("GPL");