]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * i2c tv tuner chip device driver |
3 | * controls microtune tuners, mt2032 + mt2050 at the moment. | |
96c0b7cf MK |
4 | * |
5 | * This "mt20xx" module was split apart from the original "tuner" module. | |
1da177e4 LT |
6 | */ |
7 | #include <linux/delay.h> | |
8 | #include <linux/i2c.h> | |
ffbb807c | 9 | #include <linux/videodev.h> |
96c0b7cf MK |
10 | #include "tuner-i2c.h" |
11 | #include "mt20xx.h" | |
12 | ||
ff699e6b | 13 | static int debug; |
96c0b7cf MK |
14 | module_param(debug, int, 0644); |
15 | MODULE_PARM_DESC(debug, "enable verbose debug messages"); | |
16 | ||
9dd659de | 17 | #define PREFIX "mt20xx" |
1da177e4 LT |
18 | |
19 | /* ---------------------------------------------------------------------- */ | |
20 | ||
21 | static unsigned int optimize_vco = 1; | |
22 | module_param(optimize_vco, int, 0644); | |
23 | ||
24 | static unsigned int tv_antenna = 1; | |
25 | module_param(tv_antenna, int, 0644); | |
26 | ||
ff699e6b | 27 | static unsigned int radio_antenna; |
1da177e4 LT |
28 | module_param(radio_antenna, int, 0644); |
29 | ||
30 | /* ---------------------------------------------------------------------- */ | |
31 | ||
32 | #define MT2032 0x04 | |
33 | #define MT2030 0x06 | |
34 | #define MT2040 0x07 | |
35 | #define MT2050 0x42 | |
36 | ||
37 | static char *microtune_part[] = { | |
38 | [ MT2030 ] = "MT2030", | |
39 | [ MT2032 ] = "MT2032", | |
40 | [ MT2040 ] = "MT2040", | |
41 | [ MT2050 ] = "MT2050", | |
42 | }; | |
43 | ||
b2083199 | 44 | struct microtune_priv { |
db8a6956 MK |
45 | struct tuner_i2c_props i2c_props; |
46 | ||
b2083199 | 47 | unsigned int xogc; |
96c0b7cf MK |
48 | //unsigned int radio_if2; |
49 | ||
50 | u32 frequency; | |
b2083199 MK |
51 | }; |
52 | ||
96c0b7cf MK |
53 | static int microtune_release(struct dvb_frontend *fe) |
54 | { | |
55 | kfree(fe->tuner_priv); | |
56 | fe->tuner_priv = NULL; | |
57 | ||
58 | return 0; | |
59 | } | |
60 | ||
61 | static int microtune_get_frequency(struct dvb_frontend *fe, u32 *frequency) | |
c22bcb07 | 62 | { |
96c0b7cf MK |
63 | struct microtune_priv *priv = fe->tuner_priv; |
64 | *frequency = priv->frequency; | |
65 | return 0; | |
c22bcb07 MK |
66 | } |
67 | ||
1da177e4 | 68 | // IsSpurInBand()? |
96c0b7cf | 69 | static int mt2032_spurcheck(struct dvb_frontend *fe, |
1da177e4 LT |
70 | int f1, int f2, int spectrum_from,int spectrum_to) |
71 | { | |
96c0b7cf | 72 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
73 | int n1=1,n2,f; |
74 | ||
75 | f1=f1/1000; //scale to kHz to avoid 32bit overflows | |
76 | f2=f2/1000; | |
77 | spectrum_from/=1000; | |
78 | spectrum_to/=1000; | |
79 | ||
80 | tuner_dbg("spurcheck f1=%d f2=%d from=%d to=%d\n", | |
81 | f1,f2,spectrum_from,spectrum_to); | |
82 | ||
83 | do { | |
84 | n2=-n1; | |
85 | f=n1*(f1-f2); | |
86 | do { | |
87 | n2--; | |
88 | f=f-f2; | |
89 | tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f); | |
90 | ||
91 | if( (f>spectrum_from) && (f<spectrum_to)) | |
92 | tuner_dbg("mt2032 spurcheck triggered: %d\n",n1); | |
93 | } while ( (f>(f2-spectrum_to)) || (n2>-5)); | |
94 | n1++; | |
95 | } while (n1<5); | |
96 | ||
97 | return 1; | |
98 | } | |
99 | ||
96c0b7cf | 100 | static int mt2032_compute_freq(struct dvb_frontend *fe, |
1da177e4 LT |
101 | unsigned int rfin, |
102 | unsigned int if1, unsigned int if2, | |
103 | unsigned int spectrum_from, | |
104 | unsigned int spectrum_to, | |
105 | unsigned char *buf, | |
106 | int *ret_sel, | |
107 | unsigned int xogc) //all in Hz | |
108 | { | |
96c0b7cf | 109 | struct microtune_priv *priv = fe->tuner_priv; |
4ac97914 | 110 | unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1, |
1da177e4 LT |
111 | desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq; |
112 | ||
4ac97914 | 113 | fref= 5250 *1000; //5.25MHz |
1da177e4 LT |
114 | desired_lo1=rfin+if1; |
115 | ||
116 | lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000); | |
4ac97914 MCC |
117 | lo1n=lo1/8; |
118 | lo1a=lo1-(lo1n*8); | |
1da177e4 | 119 | |
4ac97914 | 120 | s=rfin/1000/1000+1090; |
1da177e4 LT |
121 | |
122 | if(optimize_vco) { | |
123 | if(s>1890) sel=0; | |
124 | else if(s>1720) sel=1; | |
125 | else if(s>1530) sel=2; | |
126 | else if(s>1370) sel=3; | |
127 | else sel=4; // >1090 | |
128 | } | |
129 | else { | |
4ac97914 MCC |
130 | if(s>1790) sel=0; // <1958 |
131 | else if(s>1617) sel=1; | |
132 | else if(s>1449) sel=2; | |
133 | else if(s>1291) sel=3; | |
134 | else sel=4; // >1090 | |
1da177e4 LT |
135 | } |
136 | *ret_sel=sel; | |
137 | ||
4ac97914 | 138 | lo1freq=(lo1a+8*lo1n)*fref; |
1da177e4 LT |
139 | |
140 | tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n", | |
141 | rfin,lo1,lo1n,lo1a,sel,lo1freq); | |
142 | ||
4ac97914 MCC |
143 | desired_lo2=lo1freq-rfin-if2; |
144 | lo2=(desired_lo2)/fref; | |
145 | lo2n=lo2/8; | |
146 | lo2a=lo2-(lo2n*8); | |
147 | lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith | |
148 | lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000; | |
1da177e4 LT |
149 | |
150 | tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n", | |
151 | rfin,lo2,lo2n,lo2a,lo2num,lo2freq); | |
152 | ||
4ac97914 | 153 | if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) { |
1da177e4 LT |
154 | tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n", |
155 | lo1a, lo1n, lo2a,lo2n); | |
4ac97914 MCC |
156 | return(-1); |
157 | } | |
1da177e4 | 158 | |
96c0b7cf | 159 | mt2032_spurcheck(fe, lo1freq, desired_lo2, spectrum_from, spectrum_to); |
1da177e4 LT |
160 | // should recalculate lo1 (one step up/down) |
161 | ||
162 | // set up MT2032 register map for transfer over i2c | |
163 | buf[0]=lo1n-1; | |
164 | buf[1]=lo1a | (sel<<4); | |
165 | buf[2]=0x86; // LOGC | |
166 | buf[3]=0x0f; //reserved | |
167 | buf[4]=0x1f; | |
168 | buf[5]=(lo2n-1) | (lo2a<<5); | |
4ac97914 MCC |
169 | if(rfin >400*1000*1000) |
170 | buf[6]=0xe4; | |
171 | else | |
172 | buf[6]=0xf4; // set PKEN per rev 1.2 | |
1da177e4 LT |
173 | buf[7]=8+xogc; |
174 | buf[8]=0xc3; //reserved | |
175 | buf[9]=0x4e; //reserved | |
176 | buf[10]=0xec; //reserved | |
177 | buf[11]=(lo2num&0xff); | |
178 | buf[12]=(lo2num>>8) |0x80; // Lo2RST | |
179 | ||
180 | return 0; | |
181 | } | |
182 | ||
96c0b7cf | 183 | static int mt2032_check_lo_lock(struct dvb_frontend *fe) |
1da177e4 | 184 | { |
96c0b7cf | 185 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
186 | int try,lock=0; |
187 | unsigned char buf[2]; | |
188 | ||
189 | for(try=0;try<10;try++) { | |
190 | buf[0]=0x0e; | |
db8a6956 MK |
191 | tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
192 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,1); | |
1da177e4 LT |
193 | tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]); |
194 | lock=buf[0] &0x06; | |
195 | ||
196 | if (lock==6) | |
197 | break; | |
198 | ||
199 | tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]); | |
200 | udelay(1000); | |
201 | } | |
4ac97914 | 202 | return lock; |
1da177e4 LT |
203 | } |
204 | ||
96c0b7cf | 205 | static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock) |
1da177e4 | 206 | { |
96c0b7cf | 207 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
208 | unsigned char buf[2]; |
209 | int tad1; | |
210 | ||
211 | buf[0]=0x0f; | |
db8a6956 MK |
212 | tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
213 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,1); | |
1da177e4 LT |
214 | tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]); |
215 | tad1=buf[0]&0x07; | |
216 | ||
217 | if(tad1 ==0) return lock; | |
218 | if(tad1 ==1) return lock; | |
219 | ||
220 | if(tad1==2) { | |
221 | if(sel==0) | |
222 | return lock; | |
223 | else sel--; | |
224 | } | |
225 | else { | |
226 | if(sel<4) | |
227 | sel++; | |
228 | else | |
229 | return lock; | |
230 | } | |
231 | ||
232 | tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel); | |
233 | ||
234 | buf[0]=0x0f; | |
235 | buf[1]=sel; | |
db8a6956 | 236 | tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
96c0b7cf | 237 | lock=mt2032_check_lo_lock(fe); |
1da177e4 LT |
238 | return lock; |
239 | } | |
240 | ||
241 | ||
96c0b7cf | 242 | static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin, |
1da177e4 LT |
243 | unsigned int if1, unsigned int if2, |
244 | unsigned int from, unsigned int to) | |
245 | { | |
246 | unsigned char buf[21]; | |
247 | int lint_try,ret,sel,lock=0; | |
96c0b7cf | 248 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
249 | |
250 | tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n", | |
251 | rfin,if1,if2,from,to); | |
252 | ||
4ac97914 | 253 | buf[0]=0; |
db8a6956 MK |
254 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
255 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,21); | |
1da177e4 LT |
256 | |
257 | buf[0]=0; | |
96c0b7cf | 258 | ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc); |
1da177e4 LT |
259 | if (ret<0) |
260 | return; | |
261 | ||
4ac97914 MCC |
262 | // send only the relevant registers per Rev. 1.2 |
263 | buf[0]=0; | |
db8a6956 | 264 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4); |
4ac97914 | 265 | buf[5]=5; |
db8a6956 | 266 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4); |
4ac97914 | 267 | buf[11]=11; |
db8a6956 | 268 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3); |
4ac97914 | 269 | if(ret!=3) |
1da177e4 LT |
270 | tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret); |
271 | ||
272 | // wait for PLLs to lock (per manual), retry LINT if not. | |
273 | for(lint_try=0; lint_try<2; lint_try++) { | |
96c0b7cf | 274 | lock=mt2032_check_lo_lock(fe); |
1da177e4 LT |
275 | |
276 | if(optimize_vco) | |
96c0b7cf | 277 | lock=mt2032_optimize_vco(fe,sel,lock); |
1da177e4 LT |
278 | if(lock==6) break; |
279 | ||
280 | tuner_dbg("mt2032: re-init PLLs by LINT\n"); | |
281 | buf[0]=7; | |
b2083199 | 282 | buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs |
db8a6956 | 283 | tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
1da177e4 | 284 | mdelay(10); |
b2083199 | 285 | buf[1]=8+priv->xogc; |
db8a6956 | 286 | tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
4ac97914 | 287 | } |
1da177e4 LT |
288 | |
289 | if (lock!=6) | |
290 | tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n"); | |
291 | ||
292 | buf[0]=2; | |
293 | buf[1]=0x20; // LOGC for optimal phase noise | |
db8a6956 | 294 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
1da177e4 LT |
295 | if (ret!=2) |
296 | tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret); | |
297 | } | |
298 | ||
299 | ||
96c0b7cf MK |
300 | static int mt2032_set_tv_freq(struct dvb_frontend *fe, |
301 | struct analog_parameters *params) | |
1da177e4 | 302 | { |
1da177e4 LT |
303 | int if2,from,to; |
304 | ||
305 | // signal bandwidth and picture carrier | |
96c0b7cf | 306 | if (params->std & V4L2_STD_525_60) { |
1da177e4 LT |
307 | // NTSC |
308 | from = 40750*1000; | |
309 | to = 46750*1000; | |
310 | if2 = 45750*1000; | |
311 | } else { | |
312 | // PAL | |
313 | from = 32900*1000; | |
314 | to = 39900*1000; | |
315 | if2 = 38900*1000; | |
316 | } | |
317 | ||
96c0b7cf | 318 | mt2032_set_if_freq(fe, params->frequency*62500, |
1da177e4 | 319 | 1090*1000*1000, if2, from, to); |
96c0b7cf MK |
320 | |
321 | return 0; | |
1da177e4 LT |
322 | } |
323 | ||
96c0b7cf MK |
324 | static int mt2032_set_radio_freq(struct dvb_frontend *fe, |
325 | struct analog_parameters *params) | |
1da177e4 | 326 | { |
96c0b7cf MK |
327 | struct microtune_priv *priv = fe->tuner_priv; |
328 | int if2; | |
329 | ||
330 | if (params->std & V4L2_STD_525_60) { | |
331 | tuner_dbg("pinnacle ntsc\n"); | |
332 | if2 = 41300 * 1000; | |
333 | } else { | |
334 | tuner_dbg("pinnacle pal\n"); | |
335 | if2 = 33300 * 1000; | |
336 | } | |
1da177e4 LT |
337 | |
338 | // per Manual for FM tuning: first if center freq. 1085 MHz | |
96c0b7cf MK |
339 | mt2032_set_if_freq(fe, params->frequency * 125 / 2, |
340 | 1085*1000*1000,if2,if2,if2); | |
341 | ||
342 | return 0; | |
1da177e4 LT |
343 | } |
344 | ||
96c0b7cf MK |
345 | static int mt2032_set_params(struct dvb_frontend *fe, |
346 | struct analog_parameters *params) | |
347 | { | |
348 | struct microtune_priv *priv = fe->tuner_priv; | |
349 | int ret = -EINVAL; | |
350 | ||
351 | switch (params->mode) { | |
352 | case V4L2_TUNER_RADIO: | |
353 | ret = mt2032_set_radio_freq(fe, params); | |
354 | priv->frequency = params->frequency * 125 / 2; | |
355 | break; | |
356 | case V4L2_TUNER_ANALOG_TV: | |
357 | case V4L2_TUNER_DIGITAL_TV: | |
358 | ret = mt2032_set_tv_freq(fe, params); | |
359 | priv->frequency = params->frequency * 62500; | |
360 | break; | |
361 | } | |
362 | ||
363 | return ret; | |
364 | } | |
365 | ||
366 | static struct dvb_tuner_ops mt2032_tuner_ops = { | |
367 | .set_analog_params = mt2032_set_params, | |
368 | .release = microtune_release, | |
369 | .get_frequency = microtune_get_frequency, | |
c22bcb07 MK |
370 | }; |
371 | ||
c84e6036 | 372 | // Initialization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001 |
96c0b7cf | 373 | static int mt2032_init(struct dvb_frontend *fe) |
1da177e4 | 374 | { |
96c0b7cf | 375 | struct microtune_priv *priv = fe->tuner_priv; |
4ac97914 MCC |
376 | unsigned char buf[21]; |
377 | int ret,xogc,xok=0; | |
1da177e4 LT |
378 | |
379 | // Initialize Registers per spec. | |
4ac97914 MCC |
380 | buf[1]=2; // Index to register 2 |
381 | buf[2]=0xff; | |
382 | buf[3]=0x0f; | |
383 | buf[4]=0x1f; | |
db8a6956 | 384 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4); |
4ac97914 MCC |
385 | |
386 | buf[5]=6; // Index register 6 | |
387 | buf[6]=0xe4; | |
388 | buf[7]=0x8f; | |
389 | buf[8]=0xc3; | |
390 | buf[9]=0x4e; | |
391 | buf[10]=0xec; | |
db8a6956 | 392 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6); |
4ac97914 MCC |
393 | |
394 | buf[12]=13; // Index register 13 | |
395 | buf[13]=0x32; | |
db8a6956 | 396 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2); |
4ac97914 MCC |
397 | |
398 | // Adjust XOGC (register 7), wait for XOK | |
399 | xogc=7; | |
400 | do { | |
401 | tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07); | |
402 | mdelay(10); | |
403 | buf[0]=0x0e; | |
db8a6956 MK |
404 | tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
405 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,1); | |
4ac97914 MCC |
406 | xok=buf[0]&0x01; |
407 | tuner_dbg("mt2032: xok = 0x%02x\n",xok); | |
408 | if (xok == 1) break; | |
409 | ||
410 | xogc--; | |
1da177e4 | 411 | tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07); |
4ac97914 MCC |
412 | if (xogc == 3) { |
413 | xogc=4; // min. 4 per spec | |
414 | break; | |
415 | } | |
416 | buf[0]=0x07; | |
417 | buf[1]=0x88 + xogc; | |
db8a6956 | 418 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
4ac97914 | 419 | if (ret!=2) |
1da177e4 | 420 | tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret); |
4ac97914 | 421 | } while (xok != 1 ); |
b2083199 | 422 | priv->xogc=xogc; |
1da177e4 | 423 | |
96c0b7cf | 424 | memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops)); |
c22bcb07 | 425 | |
4ac97914 | 426 | return(1); |
1da177e4 LT |
427 | } |
428 | ||
96c0b7cf | 429 | static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna) |
1da177e4 | 430 | { |
96c0b7cf | 431 | struct microtune_priv *priv = fe->tuner_priv; |
56584c9e MK |
432 | unsigned char buf[2]; |
433 | int ret; | |
1da177e4 | 434 | |
56584c9e MK |
435 | buf[0] = 6; |
436 | buf[1] = antenna ? 0x11 : 0x10; | |
db8a6956 | 437 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); |
56584c9e | 438 | tuner_dbg("mt2050: enabled antenna connector %d\n", antenna); |
1da177e4 LT |
439 | } |
440 | ||
96c0b7cf | 441 | static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2) |
1da177e4 | 442 | { |
96c0b7cf | 443 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
444 | unsigned int if1=1218*1000*1000; |
445 | unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b; | |
446 | int ret; | |
447 | unsigned char buf[6]; | |
448 | ||
449 | tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n", | |
450 | freq,if1,if2); | |
451 | ||
452 | f_lo1=freq+if1; | |
453 | f_lo1=(f_lo1/1000000)*1000000; | |
454 | ||
455 | f_lo2=f_lo1-freq-if2; | |
456 | f_lo2=(f_lo2/50000)*50000; | |
457 | ||
458 | lo1=f_lo1/4000000; | |
459 | lo2=f_lo2/4000000; | |
460 | ||
461 | f_lo1_modulo= f_lo1-(lo1*4000000); | |
462 | f_lo2_modulo= f_lo2-(lo2*4000000); | |
463 | ||
464 | num1=4*f_lo1_modulo/4000000; | |
465 | num2=4096*(f_lo2_modulo/1000)/4000; | |
466 | ||
467 | // todo spurchecks | |
468 | ||
469 | div1a=(lo1/12)-1; | |
470 | div1b=lo1-(div1a+1)*12; | |
471 | ||
472 | div2a=(lo2/8)-1; | |
473 | div2b=lo2-(div2a+1)*8; | |
474 | ||
96c0b7cf | 475 | if (debug > 1) { |
1da177e4 LT |
476 | tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2); |
477 | tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n", | |
478 | num1,num2,div1a,div1b,div2a,div2b); | |
479 | } | |
480 | ||
481 | buf[0]=1; | |
482 | buf[1]= 4*div1b + num1; | |
483 | if(freq<275*1000*1000) buf[1] = buf[1]|0x80; | |
484 | ||
485 | buf[2]=div1a; | |
486 | buf[3]=32*div2b + num2/256; | |
487 | buf[4]=num2-(num2/256)*256; | |
488 | buf[5]=div2a; | |
489 | if(num2!=0) buf[5]=buf[5]|0x40; | |
490 | ||
96c0b7cf | 491 | if (debug > 1) { |
1da177e4 LT |
492 | int i; |
493 | tuner_dbg("bufs is: "); | |
494 | for(i=0;i<6;i++) | |
495 | printk("%x ",buf[i]); | |
496 | printk("\n"); | |
497 | } | |
498 | ||
db8a6956 | 499 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6); |
4ac97914 | 500 | if (ret!=6) |
1da177e4 LT |
501 | tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret); |
502 | } | |
503 | ||
96c0b7cf MK |
504 | static int mt2050_set_tv_freq(struct dvb_frontend *fe, |
505 | struct analog_parameters *params) | |
1da177e4 | 506 | { |
1da177e4 LT |
507 | unsigned int if2; |
508 | ||
96c0b7cf | 509 | if (params->std & V4L2_STD_525_60) { |
1da177e4 | 510 | // NTSC |
4ac97914 MCC |
511 | if2 = 45750*1000; |
512 | } else { | |
513 | // PAL | |
514 | if2 = 38900*1000; | |
515 | } | |
96c0b7cf | 516 | if (V4L2_TUNER_DIGITAL_TV == params->mode) { |
1da177e4 LT |
517 | // DVB (pinnacle 300i) |
518 | if2 = 36150*1000; | |
519 | } | |
96c0b7cf MK |
520 | mt2050_set_if_freq(fe, params->frequency*62500, if2); |
521 | mt2050_set_antenna(fe, tv_antenna); | |
522 | ||
523 | return 0; | |
524 | } | |
525 | ||
526 | static int mt2050_set_radio_freq(struct dvb_frontend *fe, | |
527 | struct analog_parameters *params) | |
528 | { | |
529 | struct microtune_priv *priv = fe->tuner_priv; | |
530 | int if2; | |
531 | ||
532 | if (params->std & V4L2_STD_525_60) { | |
533 | tuner_dbg("pinnacle ntsc\n"); | |
534 | if2 = 41300 * 1000; | |
535 | } else { | |
536 | tuner_dbg("pinnacle pal\n"); | |
537 | if2 = 33300 * 1000; | |
538 | } | |
539 | ||
540 | mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2); | |
541 | mt2050_set_antenna(fe, radio_antenna); | |
542 | ||
543 | return 0; | |
1da177e4 LT |
544 | } |
545 | ||
96c0b7cf MK |
546 | static int mt2050_set_params(struct dvb_frontend *fe, |
547 | struct analog_parameters *params) | |
1da177e4 | 548 | { |
96c0b7cf MK |
549 | struct microtune_priv *priv = fe->tuner_priv; |
550 | int ret = -EINVAL; | |
1da177e4 | 551 | |
96c0b7cf MK |
552 | switch (params->mode) { |
553 | case V4L2_TUNER_RADIO: | |
554 | ret = mt2050_set_radio_freq(fe, params); | |
555 | priv->frequency = params->frequency * 125 / 2; | |
556 | break; | |
557 | case V4L2_TUNER_ANALOG_TV: | |
558 | case V4L2_TUNER_DIGITAL_TV: | |
559 | ret = mt2050_set_tv_freq(fe, params); | |
560 | priv->frequency = params->frequency * 62500; | |
561 | break; | |
562 | } | |
563 | ||
564 | return ret; | |
1da177e4 LT |
565 | } |
566 | ||
96c0b7cf MK |
567 | static struct dvb_tuner_ops mt2050_tuner_ops = { |
568 | .set_analog_params = mt2050_set_params, | |
569 | .release = microtune_release, | |
570 | .get_frequency = microtune_get_frequency, | |
c22bcb07 MK |
571 | }; |
572 | ||
96c0b7cf | 573 | static int mt2050_init(struct dvb_frontend *fe) |
1da177e4 | 574 | { |
96c0b7cf | 575 | struct microtune_priv *priv = fe->tuner_priv; |
1da177e4 LT |
576 | unsigned char buf[2]; |
577 | int ret; | |
578 | ||
579 | buf[0]=6; | |
580 | buf[1]=0x10; | |
db8a6956 | 581 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // power |
1da177e4 LT |
582 | |
583 | buf[0]=0x0f; | |
584 | buf[1]=0x0f; | |
db8a6956 | 585 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo |
1da177e4 LT |
586 | |
587 | buf[0]=0x0d; | |
db8a6956 MK |
588 | ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
589 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,1); | |
1da177e4 LT |
590 | |
591 | tuner_dbg("mt2050: sro is %x\n",buf[0]); | |
1da177e4 | 592 | |
96c0b7cf | 593 | memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops)); |
024cf530 | 594 | |
c22bcb07 | 595 | return 0; |
024cf530 MK |
596 | } |
597 | ||
96c0b7cf MK |
598 | struct dvb_frontend *microtune_attach(struct dvb_frontend *fe, |
599 | struct i2c_adapter* i2c_adap, | |
600 | u8 i2c_addr) | |
1da177e4 | 601 | { |
b2083199 | 602 | struct microtune_priv *priv = NULL; |
1da177e4 | 603 | char *name; |
4ac97914 | 604 | unsigned char buf[21]; |
1da177e4 LT |
605 | int company_code; |
606 | ||
b2083199 MK |
607 | priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL); |
608 | if (priv == NULL) | |
96c0b7cf MK |
609 | return NULL; |
610 | fe->tuner_priv = priv; | |
b2083199 | 611 | |
96c0b7cf MK |
612 | priv->i2c_props.addr = i2c_addr; |
613 | priv->i2c_props.adap = i2c_adap; | |
db8a6956 | 614 | |
96c0b7cf | 615 | //priv->radio_if2 = 10700 * 1000; /* 10.7MHz - FM radio */ |
b2083199 | 616 | |
1da177e4 | 617 | memset(buf,0,sizeof(buf)); |
c22bcb07 | 618 | |
1da177e4 LT |
619 | name = "unknown"; |
620 | ||
db8a6956 MK |
621 | tuner_i2c_xfer_send(&priv->i2c_props,buf,1); |
622 | tuner_i2c_xfer_recv(&priv->i2c_props,buf,21); | |
96c0b7cf | 623 | if (debug) { |
4ac97914 | 624 | int i; |
1da177e4 | 625 | tuner_dbg("MT20xx hexdump:"); |
4ac97914 MCC |
626 | for(i=0;i<21;i++) { |
627 | printk(" %02x",buf[i]); | |
628 | if(((i+1)%8)==0) printk(" "); | |
629 | } | |
630 | printk("\n"); | |
631 | } | |
1da177e4 LT |
632 | company_code = buf[0x11] << 8 | buf[0x12]; |
633 | tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n", | |
634 | company_code,buf[0x13],buf[0x14]); | |
635 | ||
1da177e4 LT |
636 | |
637 | if (buf[0x13] < ARRAY_SIZE(microtune_part) && | |
638 | NULL != microtune_part[buf[0x13]]) | |
639 | name = microtune_part[buf[0x13]]; | |
640 | switch (buf[0x13]) { | |
641 | case MT2032: | |
96c0b7cf | 642 | mt2032_init(fe); |
1da177e4 LT |
643 | break; |
644 | case MT2050: | |
96c0b7cf | 645 | mt2050_init(fe); |
1da177e4 LT |
646 | break; |
647 | default: | |
648 | tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n", | |
649 | name); | |
5fa1247a | 650 | return NULL; |
4ac97914 | 651 | } |
1da177e4 | 652 | |
96c0b7cf MK |
653 | strlcpy(fe->ops.tuner_ops.info.name, name, |
654 | sizeof(fe->ops.tuner_ops.info.name)); | |
1da177e4 | 655 | tuner_info("microtune %s found, OK\n",name); |
96c0b7cf | 656 | return fe; |
1da177e4 LT |
657 | } |
658 | ||
96c0b7cf MK |
659 | EXPORT_SYMBOL_GPL(microtune_attach); |
660 | ||
661 | MODULE_DESCRIPTION("Microtune tuner driver"); | |
662 | MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer"); | |
663 | MODULE_LICENSE("GPL"); | |
664 | ||
1da177e4 LT |
665 | /* |
666 | * Overrides for Emacs so that we follow Linus's tabbing style. | |
667 | * --------------------------------------------------------------------------- | |
668 | * Local variables: | |
669 | * c-basic-offset: 8 | |
670 | * End: | |
671 | */ |