?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm/slab.c: proper prototypes
[wrt350n-kernel.git] / drivers / media / dvb / frontends / dvb-pll.c
blob5f96ffda91ad230414b818fe06f4d639c7ed966d
1 /*
2 * descriptions + helper functions for simple dvb plls.
3 *
4 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
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
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <linux/module.h>
22 #include <linux/dvb/frontend.h>
23 #include <asm/types.h>
24
25 #include "dvb-pll.h"
26
27 /* ----------------------------------------------------------- */
28 /* descriptions */
29
30 /* Set AGC TOP value to 103 dBuV:
31 0x80 = Control Byte
32 0x40 = 250 uA charge pump (irrelevant)
33 0x18 = Aux Byte to follow
34 0x06 = 64.5 kHz divider (irrelevant)
35 0x01 = Disable Vt (aka sleep)
36
37 0x00 = AGC Time constant 2s Iagc = 300 nA (vs 0x80 = 9 nA)
38 0x50 = AGC Take over point = 103 dBuV */
39 static u8 tua603x_agc103[] = { 2, 0x80|0x40|0x18|0x06|0x01, 0x00|0x50 };
40
41 struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
42 .name = "Thomson dtt7579",
43 .min = 177000000,
44 .max = 858000000,
45 .iffreq= 36166667,
46 .sleepdata = (u8[]){ 2, 0xb4, 0x03 },
47 .count = 4,
48 .entries = {
49 { 443250000, 166667, 0xb4, 0x02 },
50 { 542000000, 166667, 0xb4, 0x08 },
51 { 771000000, 166667, 0xbc, 0x08 },
52 { 999999999, 166667, 0xf4, 0x08 },
53 },
54 };
55 EXPORT_SYMBOL(dvb_pll_thomson_dtt7579);
56
57 struct dvb_pll_desc dvb_pll_thomson_dtt7610 = {
58 .name = "Thomson dtt7610",
59 .min = 44000000,
60 .max = 958000000,
61 .iffreq= 44000000,
62 .count = 3,
63 .entries = {
64 { 157250000, 62500, 0x8e, 0x39 },
65 { 454000000, 62500, 0x8e, 0x3a },
66 { 999999999, 62500, 0x8e, 0x3c },
67 },
68 };
69 EXPORT_SYMBOL(dvb_pll_thomson_dtt7610);
70
71 static void thomson_dtt759x_bw(u8 *buf, u32 freq, int bandwidth)
72 {
73 if (BANDWIDTH_7_MHZ == bandwidth)
74 buf[3] |= 0x10;
75 }
76
77 struct dvb_pll_desc dvb_pll_thomson_dtt759x = {
78 .name = "Thomson dtt759x",
79 .min = 177000000,
80 .max = 896000000,
81 .setbw = thomson_dtt759x_bw,
82 .iffreq= 36166667,
83 .sleepdata = (u8[]){ 2, 0x84, 0x03 },
84 .count = 5,
85 .entries = {
86 { 264000000, 166667, 0xb4, 0x02 },
87 { 470000000, 166667, 0xbc, 0x02 },
88 { 735000000, 166667, 0xbc, 0x08 },
89 { 835000000, 166667, 0xf4, 0x08 },
90 { 999999999, 166667, 0xfc, 0x08 },
91 },
92 };
93 EXPORT_SYMBOL(dvb_pll_thomson_dtt759x);
94
95 struct dvb_pll_desc dvb_pll_lg_z201 = {
96 .name = "LG z201",
97 .min = 174000000,
98 .max = 862000000,
99 .iffreq= 36166667,
100 .sleepdata = (u8[]){ 2, 0xbc, 0x03 },
101 .count = 5,
102 .entries = {
103 { 157500000, 166667, 0xbc, 0x01 },
104 { 443250000, 166667, 0xbc, 0x02 },
105 { 542000000, 166667, 0xbc, 0x04 },
106 { 830000000, 166667, 0xf4, 0x04 },
107 { 999999999, 166667, 0xfc, 0x04 },
108 },
109 };
110 EXPORT_SYMBOL(dvb_pll_lg_z201);
111
112 struct dvb_pll_desc dvb_pll_microtune_4042 = {
113 .name = "Microtune 4042 FI5",
114 .min = 57000000,
115 .max = 858000000,
116 .iffreq= 44000000,
117 .count = 3,
118 .entries = {
119 { 162000000, 62500, 0x8e, 0xa1 },
120 { 457000000, 62500, 0x8e, 0x91 },
121 { 999999999, 62500, 0x8e, 0x31 },
122 },
123 };
124 EXPORT_SYMBOL(dvb_pll_microtune_4042);
125
126 struct dvb_pll_desc dvb_pll_thomson_dtt761x = {
127 /* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
128 .name = "Thomson dtt761x",
129 .min = 57000000,
130 .max = 863000000,
131 .iffreq= 44000000,
132 .count = 3,
133 .initdata = tua603x_agc103,
134 .entries = {
135 { 147000000, 62500, 0x8e, 0x39 },
136 { 417000000, 62500, 0x8e, 0x3a },
137 { 999999999, 62500, 0x8e, 0x3c },
138 },
139 };
140 EXPORT_SYMBOL(dvb_pll_thomson_dtt761x);
141
142 struct dvb_pll_desc dvb_pll_unknown_1 = {
143 .name = "unknown 1", /* used by dntv live dvb-t */
144 .min = 174000000,
145 .max = 862000000,
146 .iffreq= 36166667,
147 .count = 9,
148 .entries = {
149 { 150000000, 166667, 0xb4, 0x01 },
150 { 173000000, 166667, 0xbc, 0x01 },
151 { 250000000, 166667, 0xb4, 0x02 },
152 { 400000000, 166667, 0xbc, 0x02 },
153 { 420000000, 166667, 0xf4, 0x02 },
154 { 470000000, 166667, 0xfc, 0x02 },
155 { 600000000, 166667, 0xbc, 0x08 },
156 { 730000000, 166667, 0xf4, 0x08 },
157 { 999999999, 166667, 0xfc, 0x08 },
158 },
159 };
160 EXPORT_SYMBOL(dvb_pll_unknown_1);
161
162 /* Infineon TUA6010XS
163 * used in Thomson Cable Tuner
164 */
165 struct dvb_pll_desc dvb_pll_tua6010xs = {
166 .name = "Infineon TUA6010XS",
167 .min = 44250000,
168 .max = 858000000,
169 .iffreq= 36125000,
170 .count = 3,
171 .entries = {
172 { 115750000, 62500, 0x8e, 0x03 },
173 { 403250000, 62500, 0x8e, 0x06 },
174 { 999999999, 62500, 0x8e, 0x85 },
175 },
176 };
177 EXPORT_SYMBOL(dvb_pll_tua6010xs);
178
179 /* Panasonic env57h1xd5 (some Philips PLL ?) */
180 struct dvb_pll_desc dvb_pll_env57h1xd5 = {
181 .name = "Panasonic ENV57H1XD5",
182 .min = 44250000,
183 .max = 858000000,
184 .iffreq= 36125000,
185 .count = 4,
186 .entries = {
187 { 153000000, 166667, 0xc2, 0x41 },
188 { 470000000, 166667, 0xc2, 0x42 },
189 { 526000000, 166667, 0xc2, 0x84 },
190 { 999999999, 166667, 0xc2, 0xa4 },
191 },
192 };
193 EXPORT_SYMBOL(dvb_pll_env57h1xd5);
194
195 /* Philips TDA6650/TDA6651
196 * used in Panasonic ENV77H11D5
197 */
198 static void tda665x_bw(u8 *buf, u32 freq, int bandwidth)
199 {
200 if (bandwidth == BANDWIDTH_8_MHZ)
201 buf[3] |= 0x08;
202 }
203
204 struct dvb_pll_desc dvb_pll_tda665x = {
205 .name = "Philips TDA6650/TDA6651",
206 .min = 44250000,
207 .max = 858000000,
208 .setbw = tda665x_bw,
209 .iffreq= 36166667,
210 .count = 12,
211 .entries = {
212 { 93834000, 166667, 0xca, 0x61 /* 011 0 0 0 01 */ },
213 { 123834000, 166667, 0xca, 0xa1 /* 101 0 0 0 01 */ },
214 { 161000000, 166667, 0xca, 0xa1 /* 101 0 0 0 01 */ },
215 { 163834000, 166667, 0xca, 0xc2 /* 110 0 0 0 10 */ },
216 { 253834000, 166667, 0xca, 0x62 /* 011 0 0 0 10 */ },
217 { 383834000, 166667, 0xca, 0xa2 /* 101 0 0 0 10 */ },
218 { 443834000, 166667, 0xca, 0xc2 /* 110 0 0 0 10 */ },
219 { 444000000, 166667, 0xca, 0xc4 /* 110 0 0 1 00 */ },
220 { 583834000, 166667, 0xca, 0x64 /* 011 0 0 1 00 */ },
221 { 793834000, 166667, 0xca, 0xa4 /* 101 0 0 1 00 */ },
222 { 444834000, 166667, 0xca, 0xc4 /* 110 0 0 1 00 */ },
223 { 861000000, 166667, 0xca, 0xe4 /* 111 0 0 1 00 */ },
224 }
225 };
226 EXPORT_SYMBOL(dvb_pll_tda665x);
227
228 /* Infineon TUA6034
229 * used in LG TDTP E102P
230 */
231 static void tua6034_bw(u8 *buf, u32 freq, int bandwidth)
232 {
233 if (BANDWIDTH_7_MHZ != bandwidth)
234 buf[3] |= 0x08;
235 }
236
237 struct dvb_pll_desc dvb_pll_tua6034 = {
238 .name = "Infineon TUA6034",
239 .min = 44250000,
240 .max = 858000000,
241 .iffreq= 36166667,
242 .count = 3,
243 .setbw = tua6034_bw,
244 .entries = {
245 { 174500000, 62500, 0xce, 0x01 },
246 { 230000000, 62500, 0xce, 0x02 },
247 { 999999999, 62500, 0xce, 0x04 },
248 },
249 };
250 EXPORT_SYMBOL(dvb_pll_tua6034);
251
252 /* Infineon TUA6034
253 * used in LG TDVS-H061F, LG TDVS-H062F and LG TDVS-H064F
254 */
255 struct dvb_pll_desc dvb_pll_lg_tdvs_h06xf = {
256 .name = "LG TDVS-H06xF",
257 .min = 54000000,
258 .max = 863000000,
259 .iffreq= 44000000,
260 .initdata = tua603x_agc103,
261 .count = 3,
262 .entries = {
263 { 165000000, 62500, 0xce, 0x01 },
264 { 450000000, 62500, 0xce, 0x02 },
265 { 999999999, 62500, 0xce, 0x04 },
266 },
267 };
268 EXPORT_SYMBOL(dvb_pll_lg_tdvs_h06xf);
269
270 /* Philips FMD1216ME
271 * used in Medion Hybrid PCMCIA card and USB Box
272 */
273 static void fmd1216me_bw(u8 *buf, u32 freq, int bandwidth)
274 {
275 if (bandwidth == BANDWIDTH_8_MHZ && freq >= 158870000)
276 buf[3] |= 0x08;
277 }
278
279 struct dvb_pll_desc dvb_pll_fmd1216me = {
280 .name = "Philips FMD1216ME",
281 .min = 50870000,
282 .max = 858000000,
283 .iffreq= 36125000,
284 .setbw = fmd1216me_bw,
285 .count = 7,
286 .entries = {
287 { 143870000, 166667, 0xbc, 0x41 },
288 { 158870000, 166667, 0xf4, 0x41 },
289 { 329870000, 166667, 0xbc, 0x42 },
290 { 441870000, 166667, 0xf4, 0x42 },
291 { 625870000, 166667, 0xbc, 0x44 },
292 { 803870000, 166667, 0xf4, 0x44 },
293 { 999999999, 166667, 0xfc, 0x44 },
294 }
295 };
296 EXPORT_SYMBOL(dvb_pll_fmd1216me);
297
298 /* ALPS TDED4
299 * used in Nebula-Cards and USB boxes
300 */
301 static void tded4_bw(u8 *buf, u32 freq, int bandwidth)
302 {
303 if (bandwidth == BANDWIDTH_8_MHZ)
304 buf[3] |= 0x04;
305 }
306
307 struct dvb_pll_desc dvb_pll_tded4 = {
308 .name = "ALPS TDED4",
309 .min = 47000000,
310 .max = 863000000,
311 .iffreq= 36166667,
312 .setbw = tded4_bw,
313 .count = 4,
314 .entries = {
315 { 153000000, 166667, 0x85, 0x01 },
316 { 470000000, 166667, 0x85, 0x02 },
317 { 823000000, 166667, 0x85, 0x08 },
318 { 999999999, 166667, 0x85, 0x88 },
319 }
320 };
321 EXPORT_SYMBOL(dvb_pll_tded4);
322
323 /* ALPS TDHU2
324 * used in AverTVHD MCE A180
325 */
326 struct dvb_pll_desc dvb_pll_tdhu2 = {
327 .name = "ALPS TDHU2",
328 .min = 54000000,
329 .max = 864000000,
330 .iffreq= 44000000,
331 .count = 4,
332 .entries = {
333 { 162000000, 62500, 0x85, 0x01 },
334 { 426000000, 62500, 0x85, 0x02 },
335 { 782000000, 62500, 0x85, 0x08 },
336 { 999999999, 62500, 0x85, 0x88 },
337 }
338 };
339 EXPORT_SYMBOL(dvb_pll_tdhu2);
340
341 /* Philips TUV1236D
342 * used in ATI HDTV Wonder
343 */
344 struct dvb_pll_desc dvb_pll_tuv1236d = {
345 .name = "Philips TUV1236D",
346 .min = 54000000,
347 .max = 864000000,
348 .iffreq= 44000000,
349 .count = 3,
350 .entries = {
351 { 157250000, 62500, 0xc6, 0x41 },
352 { 454000000, 62500, 0xc6, 0x42 },
353 { 999999999, 62500, 0xc6, 0x44 },
354 },
355 };
356 EXPORT_SYMBOL(dvb_pll_tuv1236d);
357
358 /* Samsung TBMV30111IN / TBMV30712IN1
359 * used in Air2PC ATSC - 2nd generation (nxt2002)
360 */
361 struct dvb_pll_desc dvb_pll_samsung_tbmv = {
362 .name = "Samsung TBMV30111IN / TBMV30712IN1",
363 .min = 54000000,
364 .max = 860000000,
365 .iffreq= 44000000,
366 .count = 6,
367 .entries = {
368 { 172000000, 166667, 0xb4, 0x01 },
369 { 214000000, 166667, 0xb4, 0x02 },
370 { 467000000, 166667, 0xbc, 0x02 },
371 { 721000000, 166667, 0xbc, 0x08 },
372 { 841000000, 166667, 0xf4, 0x08 },
373 { 999999999, 166667, 0xfc, 0x02 },
374 }
375 };
376 EXPORT_SYMBOL(dvb_pll_samsung_tbmv);
377
378 /*
379 * Philips SD1878 Tuner.
380 */
381 struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261 = {
382 .name = "Philips SD1878",
383 .min = 950000,
384 .max = 2150000,
385 .iffreq= 249, /* zero-IF, offset 249 is to round up */
386 .count = 4,
387 .entries = {
388 { 1250000, 500, 0xc4, 0x00},
389 { 1550000, 500, 0xc4, 0x40},
390 { 2050000, 500, 0xc4, 0x80},
391 { 2150000, 500, 0xc4, 0xc0},
392 },
393 };
394 EXPORT_SYMBOL(dvb_pll_philips_sd1878_tda8261);
395
396 /*
397 * Philips TD1316 Tuner.
398 */
399 static void td1316_bw(u8 *buf, u32 freq, int bandwidth)
400 {
401 u8 band;
402
403 /* determine band */
404 if (freq < 161000000)
405 band = 1;
406 else if (freq < 444000000)
407 band = 2;
408 else
409 band = 4;
410
411 buf[3] |= band;
412
413 /* setup PLL filter */
414 if (bandwidth == BANDWIDTH_8_MHZ)
415 buf[3] |= 1 << 3;
416 }
417
418 struct dvb_pll_desc dvb_pll_philips_td1316 = {
419 .name = "Philips TD1316",
420 .min = 87000000,
421 .max = 895000000,
422 .iffreq= 36166667,
423 .setbw = td1316_bw,
424 .count = 9,
425 .entries = {
426 { 93834000, 166667, 0xca, 0x60},
427 { 123834000, 166667, 0xca, 0xa0},
428 { 163834000, 166667, 0xca, 0xc0},
429 { 253834000, 166667, 0xca, 0x60},
430 { 383834000, 166667, 0xca, 0xa0},
431 { 443834000, 166667, 0xca, 0xc0},
432 { 583834000, 166667, 0xca, 0x60},
433 { 793834000, 166667, 0xca, 0xa0},
434 { 858834000, 166667, 0xca, 0xe0},
435 },
436 };
437 EXPORT_SYMBOL(dvb_pll_philips_td1316);
438
439 /* FE6600 used on DViCO Hybrid */
440 struct dvb_pll_desc dvb_pll_thomson_fe6600 = {
441 .name = "Thomson FE6600",
442 .min = 44250000,
443 .max = 858000000,
444 .iffreq= 36125000,
445 .count = 4,
446 .entries = {
447 { 250000000, 166667, 0xb4, 0x12 },
448 { 455000000, 166667, 0xfe, 0x11 },
449 { 775500000, 166667, 0xbc, 0x18 },
450 { 999999999, 166667, 0xf4, 0x18 },
451 }
452 };
453 EXPORT_SYMBOL(dvb_pll_thomson_fe6600);
454 static void opera1_bw(u8 *buf, u32 freq, int bandwidth)
455 {
456 if (bandwidth == BANDWIDTH_8_MHZ)
457 buf[2] |= 0x08;
458 }
459
460 struct dvb_pll_desc dvb_pll_opera1 = {
461 .name = "Opera Tuner",
462 .min = 900000,
463 .max = 2250000,
464 .iffreq= 0,
465 .setbw = opera1_bw,
466 .count = 8,
467 .entries = {
468 { 1064000, 500, 0xe5, 0xc6 },
469 { 1169000, 500, 0xe5, 0xe6 },
470 { 1299000, 500, 0xe5, 0x24 },
471 { 1444000, 500, 0xe5, 0x44 },
472 { 1606000, 500, 0xe5, 0x64 },
473 { 1777000, 500, 0xe5, 0x84 },
474 { 1941000, 500, 0xe5, 0xa4 },
475 { 2250000, 500, 0xe5, 0xc4 },
476 }
477 };
478 EXPORT_SYMBOL(dvb_pll_opera1);
479
480 struct dvb_pll_priv {
481 /* i2c details */
482 int pll_i2c_address;
483 struct i2c_adapter *i2c;
484
485 /* the PLL descriptor */
486 struct dvb_pll_desc *pll_desc;
487
488 /* cached frequency/bandwidth */
489 u32 frequency;
490 u32 bandwidth;
491 };
492
493 /* ----------------------------------------------------------- */
494 /* code */
495
496 static int debug = 0;
497 module_param(debug, int, 0644);
498 MODULE_PARM_DESC(debug, "enable verbose debug messages");
499
500 int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf,
501 u32 freq, int bandwidth)
502 {
503 u32 div;
504 int i;
505
506 if (freq != 0 && (freq < desc->min || freq > desc->max))
507 return -EINVAL;
508
509 for (i = 0; i < desc->count; i++) {
510 if (freq > desc->entries[i].limit)
511 continue;
512 break;
513 }
514 if (debug)
515 printk("pll: %s: freq=%d bw=%d | i=%d/%d\n",
516 desc->name, freq, bandwidth, i, desc->count);
517 if (i == desc->count)
518 return -EINVAL;
519
520 div = (freq + desc->iffreq + desc->entries[i].stepsize/2) /
521 desc->entries[i].stepsize;
522 buf[0] = div >> 8;
523 buf[1] = div & 0xff;
524 buf[2] = desc->entries[i].config;
525 buf[3] = desc->entries[i].cb;
526
527 if (desc->setbw)
528 desc->setbw(buf, freq, bandwidth);
529
530 if (debug)
531 printk("pll: %s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
532 desc->name, div, buf[0], buf[1], buf[2], buf[3]);
533
534 // calculate the frequency we set it to
535 return (div * desc->entries[i].stepsize) - desc->iffreq;
536 }
537 EXPORT_SYMBOL(dvb_pll_configure);
538
539 static int dvb_pll_release(struct dvb_frontend *fe)
540 {
541 kfree(fe->tuner_priv);
542 fe->tuner_priv = NULL;
543 return 0;
544 }
545
546 static int dvb_pll_sleep(struct dvb_frontend *fe)
547 {
548 struct dvb_pll_priv *priv = fe->tuner_priv;
549
550 if (priv->i2c == NULL)
551 return -EINVAL;
552
553 if (priv->pll_desc->sleepdata) {
554 struct i2c_msg msg = { .flags = 0,
555 .addr = priv->pll_i2c_address,
556 .buf = priv->pll_desc->sleepdata + 1,
557 .len = priv->pll_desc->sleepdata[0] };
558
559 int result;
560
561 if (fe->ops.i2c_gate_ctrl)
562 fe->ops.i2c_gate_ctrl(fe, 1);
563 if ((result = i2c_transfer(priv->i2c, &msg, 1)) != 1) {
564 return result;
565 }
566 return 0;
567 }
568 /* Shouldn't be called when initdata is NULL, maybe BUG()? */
569 return -EINVAL;
570 }
571
572 static int dvb_pll_set_params(struct dvb_frontend *fe,
573 struct dvb_frontend_parameters *params)
574 {
575 struct dvb_pll_priv *priv = fe->tuner_priv;
576 u8 buf[4];
577 struct i2c_msg msg =
578 { .addr = priv->pll_i2c_address, .flags = 0,
579 .buf = buf, .len = sizeof(buf) };
580 int result;
581 u32 bandwidth = 0, frequency = 0;
582
583 if (priv->i2c == NULL)
584 return -EINVAL;
585
586 // DVBT bandwidth only just now
587 if (fe->ops.info.type == FE_OFDM) {
588 bandwidth = params->u.ofdm.bandwidth;
589 }
590
591 if ((result = dvb_pll_configure(priv->pll_desc, buf,
592 params->frequency, bandwidth)) < 0)
593 return result;
594 else
595 frequency = result;
596
597 if (fe->ops.i2c_gate_ctrl)
598 fe->ops.i2c_gate_ctrl(fe, 1);
599 if ((result = i2c_transfer(priv->i2c, &msg, 1)) != 1) {
600 return result;
601 }
602
603 priv->frequency = frequency;
604 priv->bandwidth = bandwidth;
605
606 return 0;
607 }
608
609 static int dvb_pll_calc_regs(struct dvb_frontend *fe,
610 struct dvb_frontend_parameters *params,
611 u8 *buf, int buf_len)
612 {
613 struct dvb_pll_priv *priv = fe->tuner_priv;
614 int result;
615 u32 bandwidth = 0, frequency = 0;
616
617 if (buf_len < 5)
618 return -EINVAL;
619
620 // DVBT bandwidth only just now
621 if (fe->ops.info.type == FE_OFDM) {
622 bandwidth = params->u.ofdm.bandwidth;
623 }
624
625 if ((result = dvb_pll_configure(priv->pll_desc, buf+1,
626 params->frequency, bandwidth)) < 0)
627 return result;
628 else
629 frequency = result;
630
631 buf[0] = priv->pll_i2c_address;
632
633 priv->frequency = frequency;
634 priv->bandwidth = bandwidth;
635
636 return 5;
637 }
638
639 static int dvb_pll_get_frequency(struct dvb_frontend *fe, u32 *frequency)
640 {
641 struct dvb_pll_priv *priv = fe->tuner_priv;
642 *frequency = priv->frequency;
643 return 0;
644 }
645
646 static int dvb_pll_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
647 {
648 struct dvb_pll_priv *priv = fe->tuner_priv;
649 *bandwidth = priv->bandwidth;
650 return 0;
651 }
652
653 static int dvb_pll_init(struct dvb_frontend *fe)
654 {
655 struct dvb_pll_priv *priv = fe->tuner_priv;
656
657 if (priv->i2c == NULL)
658 return -EINVAL;
659
660 if (priv->pll_desc->initdata) {
661 struct i2c_msg msg = { .flags = 0,
662 .addr = priv->pll_i2c_address,
663 .buf = priv->pll_desc->initdata + 1,
664 .len = priv->pll_desc->initdata[0] };
665
666 int result;
667 if (fe->ops.i2c_gate_ctrl)
668 fe->ops.i2c_gate_ctrl(fe, 1);
669 if ((result = i2c_transfer(priv->i2c, &msg, 1)) != 1) {
670 return result;
671 }
672 return 0;
673 }
674 /* Shouldn't be called when initdata is NULL, maybe BUG()? */
675 return -EINVAL;
676 }
677
678 static struct dvb_tuner_ops dvb_pll_tuner_ops = {
679 .release = dvb_pll_release,
680 .sleep = dvb_pll_sleep,
681 .init = dvb_pll_init,
682 .set_params = dvb_pll_set_params,
683 .calc_regs = dvb_pll_calc_regs,
684 .get_frequency = dvb_pll_get_frequency,
685 .get_bandwidth = dvb_pll_get_bandwidth,
686 };
687
688 struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
689 struct i2c_adapter *i2c,
690 struct dvb_pll_desc *desc)
691 {
692 u8 b1 [] = { 0 };
693 struct i2c_msg msg = { .addr = pll_addr, .flags = I2C_M_RD,
694 .buf = b1, .len = 1 };
695 struct dvb_pll_priv *priv = NULL;
696 int ret;
697
698 if (i2c != NULL) {
699 if (fe->ops.i2c_gate_ctrl)
700 fe->ops.i2c_gate_ctrl(fe, 1);
701
702 ret = i2c_transfer (i2c, &msg, 1);
703 if (ret != 1)
704 return NULL;
705 if (fe->ops.i2c_gate_ctrl)
706 fe->ops.i2c_gate_ctrl(fe, 0);
707 }
708
709 priv = kzalloc(sizeof(struct dvb_pll_priv), GFP_KERNEL);
710 if (priv == NULL)
711 return NULL;
712
713 priv->pll_i2c_address = pll_addr;
714 priv->i2c = i2c;
715 priv->pll_desc = desc;
716
717 memcpy(&fe->ops.tuner_ops, &dvb_pll_tuner_ops,
718 sizeof(struct dvb_tuner_ops));
719
720 strncpy(fe->ops.tuner_ops.info.name, desc->name,
721 sizeof(fe->ops.tuner_ops.info.name));
722 fe->ops.tuner_ops.info.frequency_min = desc->min;
723 fe->ops.tuner_ops.info.frequency_min = desc->max;
724 if (!desc->initdata)
725 fe->ops.tuner_ops.init = NULL;
726 if (!desc->sleepdata)
727 fe->ops.tuner_ops.sleep = NULL;
728
729 fe->tuner_priv = priv;
730 return fe;
731 }
732 EXPORT_SYMBOL(dvb_pll_attach);
733
734 MODULE_DESCRIPTION("dvb pll library");
735 MODULE_AUTHOR("Gerd Knorr");
736 MODULE_LICENSE("GPL");
WRT350N Kernel Patches