diff options
Diffstat (limited to 'drivers/media/common/tuners/mt2060.c')
-rw-r--r-- | drivers/media/common/tuners/mt2060.c | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/drivers/media/common/tuners/mt2060.c b/drivers/media/common/tuners/mt2060.c new file mode 100644 index 000000000000..1305b0e63ce5 --- /dev/null +++ b/drivers/media/common/tuners/mt2060.c | |||
@@ -0,0 +1,369 @@ | |||
1 | /* | ||
2 | * Driver for Microtune MT2060 "Single chip dual conversion broadband tuner" | ||
3 | * | ||
4 | * Copyright (c) 2006 Olivier DANET <odanet@caramail.com> | ||
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 | * | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.= | ||
20 | */ | ||
21 | |||
22 | /* In that file, frequencies are expressed in kiloHertz to avoid 32 bits overflows */ | ||
23 | |||
24 | #include <linux/module.h> | ||
25 | #include <linux/delay.h> | ||
26 | #include <linux/dvb/frontend.h> | ||
27 | #include <linux/i2c.h> | ||
28 | |||
29 | #include "dvb_frontend.h" | ||
30 | |||
31 | #include "mt2060.h" | ||
32 | #include "mt2060_priv.h" | ||
33 | |||
34 | static int debug; | ||
35 | module_param(debug, int, 0644); | ||
36 | MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); | ||
37 | |||
38 | #define dprintk(args...) do { if (debug) {printk(KERN_DEBUG "MT2060: " args); printk("\n"); }} while (0) | ||
39 | |||
40 | // Reads a single register | ||
41 | static int mt2060_readreg(struct mt2060_priv *priv, u8 reg, u8 *val) | ||
42 | { | ||
43 | struct i2c_msg msg[2] = { | ||
44 | { .addr = priv->cfg->i2c_address, .flags = 0, .buf = ®, .len = 1 }, | ||
45 | { .addr = priv->cfg->i2c_address, .flags = I2C_M_RD, .buf = val, .len = 1 }, | ||
46 | }; | ||
47 | |||
48 | if (i2c_transfer(priv->i2c, msg, 2) != 2) { | ||
49 | printk(KERN_WARNING "mt2060 I2C read failed\n"); | ||
50 | return -EREMOTEIO; | ||
51 | } | ||
52 | return 0; | ||
53 | } | ||
54 | |||
55 | // Writes a single register | ||
56 | static int mt2060_writereg(struct mt2060_priv *priv, u8 reg, u8 val) | ||
57 | { | ||
58 | u8 buf[2] = { reg, val }; | ||
59 | struct i2c_msg msg = { | ||
60 | .addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = 2 | ||
61 | }; | ||
62 | |||
63 | if (i2c_transfer(priv->i2c, &msg, 1) != 1) { | ||
64 | printk(KERN_WARNING "mt2060 I2C write failed\n"); | ||
65 | return -EREMOTEIO; | ||
66 | } | ||
67 | return 0; | ||
68 | } | ||
69 | |||
70 | // Writes a set of consecutive registers | ||
71 | static int mt2060_writeregs(struct mt2060_priv *priv,u8 *buf, u8 len) | ||
72 | { | ||
73 | struct i2c_msg msg = { | ||
74 | .addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = len | ||
75 | }; | ||
76 | if (i2c_transfer(priv->i2c, &msg, 1) != 1) { | ||
77 | printk(KERN_WARNING "mt2060 I2C write failed (len=%i)\n",(int)len); | ||
78 | return -EREMOTEIO; | ||
79 | } | ||
80 | return 0; | ||
81 | } | ||
82 | |||
83 | // Initialisation sequences | ||
84 | // LNABAND=3, NUM1=0x3C, DIV1=0x74, NUM2=0x1080, DIV2=0x49 | ||
85 | static u8 mt2060_config1[] = { | ||
86 | REG_LO1C1, | ||
87 | 0x3F, 0x74, 0x00, 0x08, 0x93 | ||
88 | }; | ||
89 | |||
90 | // FMCG=2, GP2=0, GP1=0 | ||
91 | static u8 mt2060_config2[] = { | ||
92 | REG_MISC_CTRL, | ||
93 | 0x20, 0x1E, 0x30, 0xff, 0x80, 0xff, 0x00, 0x2c, 0x42 | ||
94 | }; | ||
95 | |||
96 | // VGAG=3, V1CSE=1 | ||
97 | |||
98 | #ifdef MT2060_SPURCHECK | ||
99 | /* The function below calculates the frequency offset between the output frequency if2 | ||
100 | and the closer cross modulation subcarrier between lo1 and lo2 up to the tenth harmonic */ | ||
101 | static int mt2060_spurcalc(u32 lo1,u32 lo2,u32 if2) | ||
102 | { | ||
103 | int I,J; | ||
104 | int dia,diamin,diff; | ||
105 | diamin=1000000; | ||
106 | for (I = 1; I < 10; I++) { | ||
107 | J = ((2*I*lo1)/lo2+1)/2; | ||
108 | diff = I*(int)lo1-J*(int)lo2; | ||
109 | if (diff < 0) diff=-diff; | ||
110 | dia = (diff-(int)if2); | ||
111 | if (dia < 0) dia=-dia; | ||
112 | if (diamin > dia) diamin=dia; | ||
113 | } | ||
114 | return diamin; | ||
115 | } | ||
116 | |||
117 | #define BANDWIDTH 4000 // kHz | ||
118 | |||
119 | /* Calculates the frequency offset to add to avoid spurs. Returns 0 if no offset is needed */ | ||
120 | static int mt2060_spurcheck(u32 lo1,u32 lo2,u32 if2) | ||
121 | { | ||
122 | u32 Spur,Sp1,Sp2; | ||
123 | int I,J; | ||
124 | I=0; | ||
125 | J=1000; | ||
126 | |||
127 | Spur=mt2060_spurcalc(lo1,lo2,if2); | ||
128 | if (Spur < BANDWIDTH) { | ||
129 | /* Potential spurs detected */ | ||
130 | dprintk("Spurs before : f_lo1: %d f_lo2: %d (kHz)", | ||
131 | (int)lo1,(int)lo2); | ||
132 | I=1000; | ||
133 | Sp1 = mt2060_spurcalc(lo1+I,lo2+I,if2); | ||
134 | Sp2 = mt2060_spurcalc(lo1-I,lo2-I,if2); | ||
135 | |||
136 | if (Sp1 < Sp2) { | ||
137 | J=-J; I=-I; Spur=Sp2; | ||
138 | } else | ||
139 | Spur=Sp1; | ||
140 | |||
141 | while (Spur < BANDWIDTH) { | ||
142 | I += J; | ||
143 | Spur = mt2060_spurcalc(lo1+I,lo2+I,if2); | ||
144 | } | ||
145 | dprintk("Spurs after : f_lo1: %d f_lo2: %d (kHz)", | ||
146 | (int)(lo1+I),(int)(lo2+I)); | ||
147 | } | ||
148 | return I; | ||
149 | } | ||
150 | #endif | ||
151 | |||
152 | #define IF2 36150 // IF2 frequency = 36.150 MHz | ||
153 | #define FREF 16000 // Quartz oscillator 16 MHz | ||
154 | |||
155 | static int mt2060_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params) | ||
156 | { | ||
157 | struct mt2060_priv *priv; | ||
158 | int ret=0; | ||
159 | int i=0; | ||
160 | u32 freq; | ||
161 | u8 lnaband; | ||
162 | u32 f_lo1,f_lo2; | ||
163 | u32 div1,num1,div2,num2; | ||
164 | u8 b[8]; | ||
165 | u32 if1; | ||
166 | |||
167 | priv = fe->tuner_priv; | ||
168 | |||
169 | if1 = priv->if1_freq; | ||
170 | b[0] = REG_LO1B1; | ||
171 | b[1] = 0xFF; | ||
172 | |||
173 | mt2060_writeregs(priv,b,2); | ||
174 | |||
175 | freq = params->frequency / 1000; // Hz -> kHz | ||
176 | priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0; | ||
177 | |||
178 | f_lo1 = freq + if1 * 1000; | ||
179 | f_lo1 = (f_lo1 / 250) * 250; | ||
180 | f_lo2 = f_lo1 - freq - IF2; | ||
181 | // From the Comtech datasheet, the step used is 50kHz. The tuner chip could be more precise | ||
182 | f_lo2 = ((f_lo2 + 25) / 50) * 50; | ||
183 | priv->frequency = (f_lo1 - f_lo2 - IF2) * 1000, | ||
184 | |||
185 | #ifdef MT2060_SPURCHECK | ||
186 | // LO-related spurs detection and correction | ||
187 | num1 = mt2060_spurcheck(f_lo1,f_lo2,IF2); | ||
188 | f_lo1 += num1; | ||
189 | f_lo2 += num1; | ||
190 | #endif | ||
191 | //Frequency LO1 = 16MHz * (DIV1 + NUM1/64 ) | ||
192 | num1 = f_lo1 / (FREF / 64); | ||
193 | div1 = num1 / 64; | ||
194 | num1 &= 0x3f; | ||
195 | |||
196 | // Frequency LO2 = 16MHz * (DIV2 + NUM2/8192 ) | ||
197 | num2 = f_lo2 * 64 / (FREF / 128); | ||
198 | div2 = num2 / 8192; | ||
199 | num2 &= 0x1fff; | ||
200 | |||
201 | if (freq <= 95000) lnaband = 0xB0; else | ||
202 | if (freq <= 180000) lnaband = 0xA0; else | ||
203 | if (freq <= 260000) lnaband = 0x90; else | ||
204 | if (freq <= 335000) lnaband = 0x80; else | ||
205 | if (freq <= 425000) lnaband = 0x70; else | ||
206 | if (freq <= 480000) lnaband = 0x60; else | ||
207 | if (freq <= 570000) lnaband = 0x50; else | ||
208 | if (freq <= 645000) lnaband = 0x40; else | ||
209 | if (freq <= 730000) lnaband = 0x30; else | ||
210 | if (freq <= 810000) lnaband = 0x20; else lnaband = 0x10; | ||
211 | |||
212 | b[0] = REG_LO1C1; | ||
213 | b[1] = lnaband | ((num1 >>2) & 0x0F); | ||
214 | b[2] = div1; | ||
215 | b[3] = (num2 & 0x0F) | ((num1 & 3) << 4); | ||
216 | b[4] = num2 >> 4; | ||
217 | b[5] = ((num2 >>12) & 1) | (div2 << 1); | ||
218 | |||
219 | dprintk("IF1: %dMHz",(int)if1); | ||
220 | dprintk("PLL freq=%dkHz f_lo1=%dkHz f_lo2=%dkHz",(int)freq,(int)f_lo1,(int)f_lo2); | ||
221 | dprintk("PLL div1=%d num1=%d div2=%d num2=%d",(int)div1,(int)num1,(int)div2,(int)num2); | ||
222 | dprintk("PLL [1..5]: %2x %2x %2x %2x %2x",(int)b[1],(int)b[2],(int)b[3],(int)b[4],(int)b[5]); | ||
223 | |||
224 | mt2060_writeregs(priv,b,6); | ||
225 | |||
226 | //Waits for pll lock or timeout | ||
227 | i = 0; | ||
228 | do { | ||
229 | mt2060_readreg(priv,REG_LO_STATUS,b); | ||
230 | if ((b[0] & 0x88)==0x88) | ||
231 | break; | ||
232 | msleep(4); | ||
233 | i++; | ||
234 | } while (i<10); | ||
235 | |||
236 | return ret; | ||
237 | } | ||
238 | |||
239 | static void mt2060_calibrate(struct mt2060_priv *priv) | ||
240 | { | ||
241 | u8 b = 0; | ||
242 | int i = 0; | ||
243 | |||
244 | if (mt2060_writeregs(priv,mt2060_config1,sizeof(mt2060_config1))) | ||
245 | return; | ||
246 | if (mt2060_writeregs(priv,mt2060_config2,sizeof(mt2060_config2))) | ||
247 | return; | ||
248 | |||
249 | /* initialize the clock output */ | ||
250 | mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x30); | ||
251 | |||
252 | do { | ||
253 | b |= (1 << 6); // FM1SS; | ||
254 | mt2060_writereg(priv, REG_LO2C1,b); | ||
255 | msleep(20); | ||
256 | |||
257 | if (i == 0) { | ||
258 | b |= (1 << 7); // FM1CA; | ||
259 | mt2060_writereg(priv, REG_LO2C1,b); | ||
260 | b &= ~(1 << 7); // FM1CA; | ||
261 | msleep(20); | ||
262 | } | ||
263 | |||
264 | b &= ~(1 << 6); // FM1SS | ||
265 | mt2060_writereg(priv, REG_LO2C1,b); | ||
266 | |||
267 | msleep(20); | ||
268 | i++; | ||
269 | } while (i < 9); | ||
270 | |||
271 | i = 0; | ||
272 | while (i++ < 10 && mt2060_readreg(priv, REG_MISC_STAT, &b) == 0 && (b & (1 << 6)) == 0) | ||
273 | msleep(20); | ||
274 | |||
275 | if (i < 10) { | ||
276 | mt2060_readreg(priv, REG_FM_FREQ, &priv->fmfreq); // now find out, what is fmreq used for :) | ||
277 | dprintk("calibration was successful: %d", (int)priv->fmfreq); | ||
278 | } else | ||
279 | dprintk("FMCAL timed out"); | ||
280 | } | ||
281 | |||
282 | static int mt2060_get_frequency(struct dvb_frontend *fe, u32 *frequency) | ||
283 | { | ||
284 | struct mt2060_priv *priv = fe->tuner_priv; | ||
285 | *frequency = priv->frequency; | ||
286 | return 0; | ||
287 | } | ||
288 | |||
289 | static int mt2060_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) | ||
290 | { | ||
291 | struct mt2060_priv *priv = fe->tuner_priv; | ||
292 | *bandwidth = priv->bandwidth; | ||
293 | return 0; | ||
294 | } | ||
295 | |||
296 | static int mt2060_init(struct dvb_frontend *fe) | ||
297 | { | ||
298 | struct mt2060_priv *priv = fe->tuner_priv; | ||
299 | return mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x33); | ||
300 | } | ||
301 | |||
302 | static int mt2060_sleep(struct dvb_frontend *fe) | ||
303 | { | ||
304 | struct mt2060_priv *priv = fe->tuner_priv; | ||
305 | return mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x30); | ||
306 | } | ||
307 | |||
308 | static int mt2060_release(struct dvb_frontend *fe) | ||
309 | { | ||
310 | kfree(fe->tuner_priv); | ||
311 | fe->tuner_priv = NULL; | ||
312 | return 0; | ||
313 | } | ||
314 | |||
315 | static const struct dvb_tuner_ops mt2060_tuner_ops = { | ||
316 | .info = { | ||
317 | .name = "Microtune MT2060", | ||
318 | .frequency_min = 48000000, | ||
319 | .frequency_max = 860000000, | ||
320 | .frequency_step = 50000, | ||
321 | }, | ||
322 | |||
323 | .release = mt2060_release, | ||
324 | |||
325 | .init = mt2060_init, | ||
326 | .sleep = mt2060_sleep, | ||
327 | |||
328 | .set_params = mt2060_set_params, | ||
329 | .get_frequency = mt2060_get_frequency, | ||
330 | .get_bandwidth = mt2060_get_bandwidth | ||
331 | }; | ||
332 | |||
333 | /* This functions tries to identify a MT2060 tuner by reading the PART/REV register. This is hasty. */ | ||
334 | struct dvb_frontend * mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1) | ||
335 | { | ||
336 | struct mt2060_priv *priv = NULL; | ||
337 | u8 id = 0; | ||
338 | |||
339 | priv = kzalloc(sizeof(struct mt2060_priv), GFP_KERNEL); | ||
340 | if (priv == NULL) | ||
341 | return NULL; | ||
342 | |||
343 | priv->cfg = cfg; | ||
344 | priv->i2c = i2c; | ||
345 | priv->if1_freq = if1; | ||
346 | |||
347 | if (mt2060_readreg(priv,REG_PART_REV,&id) != 0) { | ||
348 | kfree(priv); | ||
349 | return NULL; | ||
350 | } | ||
351 | |||
352 | if (id != PART_REV) { | ||
353 | kfree(priv); | ||
354 | return NULL; | ||
355 | } | ||
356 | printk(KERN_INFO "MT2060: successfully identified (IF1 = %d)\n", if1); | ||
357 | memcpy(&fe->ops.tuner_ops, &mt2060_tuner_ops, sizeof(struct dvb_tuner_ops)); | ||
358 | |||
359 | fe->tuner_priv = priv; | ||
360 | |||
361 | mt2060_calibrate(priv); | ||
362 | |||
363 | return fe; | ||
364 | } | ||
365 | EXPORT_SYMBOL(mt2060_attach); | ||
366 | |||
367 | MODULE_AUTHOR("Olivier DANET"); | ||
368 | MODULE_DESCRIPTION("Microtune MT2060 silicon tuner driver"); | ||
369 | MODULE_LICENSE("GPL"); | ||