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