]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/common/tuners/mt2266.c
Merge branch 'slabh' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/misc
[mirror_ubuntu-bionic-kernel.git] / drivers / media / common / tuners / mt2266.c
1 /*
2 * Driver for Microtune MT2266 "Direct conversion low power broadband tuner"
3 *
4 * Copyright (c) 2007 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 * GNU General Public License for more details.
15 */
16
17 #include <linux/module.h>
18 #include <linux/delay.h>
19 #include <linux/dvb/frontend.h>
20 #include <linux/i2c.h>
21 #include <linux/slab.h>
22
23 #include "dvb_frontend.h"
24 #include "mt2266.h"
25
26 #define I2C_ADDRESS 0x60
27
28 #define REG_PART_REV 0
29 #define REG_TUNE 1
30 #define REG_BAND 6
31 #define REG_BANDWIDTH 8
32 #define REG_LOCK 0x12
33
34 #define PART_REV 0x85
35
36 struct mt2266_priv {
37 struct mt2266_config *cfg;
38 struct i2c_adapter *i2c;
39
40 u32 frequency;
41 u32 bandwidth;
42 u8 band;
43 };
44
45 #define MT2266_VHF 1
46 #define MT2266_UHF 0
47
48 /* Here, frequencies are expressed in kiloHertz to avoid 32 bits overflows */
49
50 static int debug;
51 module_param(debug, int, 0644);
52 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
53
54 #define dprintk(args...) do { if (debug) {printk(KERN_DEBUG "MT2266: " args); printk("\n"); }} while (0)
55
56 // Reads a single register
57 static int mt2266_readreg(struct mt2266_priv *priv, u8 reg, u8 *val)
58 {
59 struct i2c_msg msg[2] = {
60 { .addr = priv->cfg->i2c_address, .flags = 0, .buf = &reg, .len = 1 },
61 { .addr = priv->cfg->i2c_address, .flags = I2C_M_RD, .buf = val, .len = 1 },
62 };
63 if (i2c_transfer(priv->i2c, msg, 2) != 2) {
64 printk(KERN_WARNING "MT2266 I2C read failed\n");
65 return -EREMOTEIO;
66 }
67 return 0;
68 }
69
70 // Writes a single register
71 static int mt2266_writereg(struct mt2266_priv *priv, u8 reg, u8 val)
72 {
73 u8 buf[2] = { reg, val };
74 struct i2c_msg msg = {
75 .addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = 2
76 };
77 if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
78 printk(KERN_WARNING "MT2266 I2C write failed\n");
79 return -EREMOTEIO;
80 }
81 return 0;
82 }
83
84 // Writes a set of consecutive registers
85 static int mt2266_writeregs(struct mt2266_priv *priv,u8 *buf, u8 len)
86 {
87 struct i2c_msg msg = {
88 .addr = priv->cfg->i2c_address, .flags = 0, .buf = buf, .len = len
89 };
90 if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
91 printk(KERN_WARNING "MT2266 I2C write failed (len=%i)\n",(int)len);
92 return -EREMOTEIO;
93 }
94 return 0;
95 }
96
97 // Initialisation sequences
98 static u8 mt2266_init1[] = { REG_TUNE, 0x00, 0x00, 0x28,
99 0x00, 0x52, 0x99, 0x3f };
100
101 static u8 mt2266_init2[] = {
102 0x17, 0x6d, 0x71, 0x61, 0xc0, 0xbf, 0xff, 0xdc, 0x00, 0x0a, 0xd4,
103 0x03, 0x64, 0x64, 0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14,
104 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7f, 0x5e, 0x3f, 0xff, 0xff,
105 0xff, 0x00, 0x77, 0x0f, 0x2d
106 };
107
108 static u8 mt2266_init_8mhz[] = { REG_BANDWIDTH, 0x22, 0x22, 0x22, 0x22,
109 0x22, 0x22, 0x22, 0x22 };
110
111 static u8 mt2266_init_7mhz[] = { REG_BANDWIDTH, 0x32, 0x32, 0x32, 0x32,
112 0x32, 0x32, 0x32, 0x32 };
113
114 static u8 mt2266_init_6mhz[] = { REG_BANDWIDTH, 0xa7, 0xa7, 0xa7, 0xa7,
115 0xa7, 0xa7, 0xa7, 0xa7 };
116
117 static u8 mt2266_uhf[] = { 0x1d, 0xdc, 0x00, 0x0a, 0xd4, 0x03, 0x64, 0x64,
118 0x64, 0x64, 0x22, 0xaa, 0xf2, 0x1e, 0x80, 0x14 };
119
120 static u8 mt2266_vhf[] = { 0x1d, 0xfe, 0x00, 0x00, 0xb4, 0x03, 0xa5, 0xa5,
121 0xa5, 0xa5, 0x82, 0xaa, 0xf1, 0x17, 0x80, 0x1f };
122
123 #define FREF 30000 // Quartz oscillator 30 MHz
124
125 static int mt2266_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
126 {
127 struct mt2266_priv *priv;
128 int ret=0;
129 u32 freq;
130 u32 tune;
131 u8 lnaband;
132 u8 b[10];
133 int i;
134 u8 band;
135
136 priv = fe->tuner_priv;
137
138 freq = params->frequency / 1000; // Hz -> kHz
139 if (freq < 470000 && freq > 230000)
140 return -EINVAL; /* Gap between VHF and UHF bands */
141 priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
142 priv->frequency = freq * 1000;
143
144 tune = 2 * freq * (8192/16) / (FREF/16);
145 band = (freq < 300000) ? MT2266_VHF : MT2266_UHF;
146 if (band == MT2266_VHF)
147 tune *= 2;
148
149 switch (params->u.ofdm.bandwidth) {
150 case BANDWIDTH_6_MHZ:
151 mt2266_writeregs(priv, mt2266_init_6mhz,
152 sizeof(mt2266_init_6mhz));
153 break;
154 case BANDWIDTH_7_MHZ:
155 mt2266_writeregs(priv, mt2266_init_7mhz,
156 sizeof(mt2266_init_7mhz));
157 break;
158 case BANDWIDTH_8_MHZ:
159 default:
160 mt2266_writeregs(priv, mt2266_init_8mhz,
161 sizeof(mt2266_init_8mhz));
162 break;
163 }
164
165 if (band == MT2266_VHF && priv->band == MT2266_UHF) {
166 dprintk("Switch from UHF to VHF");
167 mt2266_writereg(priv, 0x05, 0x04);
168 mt2266_writereg(priv, 0x19, 0x61);
169 mt2266_writeregs(priv, mt2266_vhf, sizeof(mt2266_vhf));
170 } else if (band == MT2266_UHF && priv->band == MT2266_VHF) {
171 dprintk("Switch from VHF to UHF");
172 mt2266_writereg(priv, 0x05, 0x52);
173 mt2266_writereg(priv, 0x19, 0x61);
174 mt2266_writeregs(priv, mt2266_uhf, sizeof(mt2266_uhf));
175 }
176 msleep(10);
177
178 if (freq <= 495000)
179 lnaband = 0xEE;
180 else if (freq <= 525000)
181 lnaband = 0xDD;
182 else if (freq <= 550000)
183 lnaband = 0xCC;
184 else if (freq <= 580000)
185 lnaband = 0xBB;
186 else if (freq <= 605000)
187 lnaband = 0xAA;
188 else if (freq <= 630000)
189 lnaband = 0x99;
190 else if (freq <= 655000)
191 lnaband = 0x88;
192 else if (freq <= 685000)
193 lnaband = 0x77;
194 else if (freq <= 710000)
195 lnaband = 0x66;
196 else if (freq <= 735000)
197 lnaband = 0x55;
198 else if (freq <= 765000)
199 lnaband = 0x44;
200 else if (freq <= 802000)
201 lnaband = 0x33;
202 else if (freq <= 840000)
203 lnaband = 0x22;
204 else
205 lnaband = 0x11;
206
207 b[0] = REG_TUNE;
208 b[1] = (tune >> 8) & 0x1F;
209 b[2] = tune & 0xFF;
210 b[3] = tune >> 13;
211 mt2266_writeregs(priv,b,4);
212
213 dprintk("set_parms: tune=%d band=%d %s",
214 (int) tune, (int) lnaband,
215 (band == MT2266_UHF) ? "UHF" : "VHF");
216 dprintk("set_parms: [1..3]: %2x %2x %2x",
217 (int) b[1], (int) b[2], (int)b[3]);
218
219 if (band == MT2266_UHF) {
220 b[0] = 0x05;
221 b[1] = (priv->band == MT2266_VHF) ? 0x52 : 0x62;
222 b[2] = lnaband;
223 mt2266_writeregs(priv, b, 3);
224 }
225
226 /* Wait for pll lock or timeout */
227 i = 0;
228 do {
229 mt2266_readreg(priv,REG_LOCK,b);
230 if (b[0] & 0x40)
231 break;
232 msleep(10);
233 i++;
234 } while (i<10);
235 dprintk("Lock when i=%i",(int)i);
236
237 if (band == MT2266_UHF && priv->band == MT2266_VHF)
238 mt2266_writereg(priv, 0x05, 0x62);
239
240 priv->band = band;
241
242 return ret;
243 }
244
245 static void mt2266_calibrate(struct mt2266_priv *priv)
246 {
247 mt2266_writereg(priv, 0x11, 0x03);
248 mt2266_writereg(priv, 0x11, 0x01);
249 mt2266_writeregs(priv, mt2266_init1, sizeof(mt2266_init1));
250 mt2266_writeregs(priv, mt2266_init2, sizeof(mt2266_init2));
251 mt2266_writereg(priv, 0x33, 0x5e);
252 mt2266_writereg(priv, 0x10, 0x10);
253 mt2266_writereg(priv, 0x10, 0x00);
254 mt2266_writeregs(priv, mt2266_init_8mhz, sizeof(mt2266_init_8mhz));
255 msleep(25);
256 mt2266_writereg(priv, 0x17, 0x6d);
257 mt2266_writereg(priv, 0x1c, 0x00);
258 msleep(75);
259 mt2266_writereg(priv, 0x17, 0x6d);
260 mt2266_writereg(priv, 0x1c, 0xff);
261 }
262
263 static int mt2266_get_frequency(struct dvb_frontend *fe, u32 *frequency)
264 {
265 struct mt2266_priv *priv = fe->tuner_priv;
266 *frequency = priv->frequency;
267 return 0;
268 }
269
270 static int mt2266_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
271 {
272 struct mt2266_priv *priv = fe->tuner_priv;
273 *bandwidth = priv->bandwidth;
274 return 0;
275 }
276
277 static int mt2266_init(struct dvb_frontend *fe)
278 {
279 int ret;
280 struct mt2266_priv *priv = fe->tuner_priv;
281 ret = mt2266_writereg(priv, 0x17, 0x6d);
282 if (ret < 0)
283 return ret;
284 ret = mt2266_writereg(priv, 0x1c, 0xff);
285 if (ret < 0)
286 return ret;
287 return 0;
288 }
289
290 static int mt2266_sleep(struct dvb_frontend *fe)
291 {
292 struct mt2266_priv *priv = fe->tuner_priv;
293 mt2266_writereg(priv, 0x17, 0x6d);
294 mt2266_writereg(priv, 0x1c, 0x00);
295 return 0;
296 }
297
298 static int mt2266_release(struct dvb_frontend *fe)
299 {
300 kfree(fe->tuner_priv);
301 fe->tuner_priv = NULL;
302 return 0;
303 }
304
305 static const struct dvb_tuner_ops mt2266_tuner_ops = {
306 .info = {
307 .name = "Microtune MT2266",
308 .frequency_min = 174000000,
309 .frequency_max = 862000000,
310 .frequency_step = 50000,
311 },
312 .release = mt2266_release,
313 .init = mt2266_init,
314 .sleep = mt2266_sleep,
315 .set_params = mt2266_set_params,
316 .get_frequency = mt2266_get_frequency,
317 .get_bandwidth = mt2266_get_bandwidth
318 };
319
320 struct dvb_frontend * mt2266_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2266_config *cfg)
321 {
322 struct mt2266_priv *priv = NULL;
323 u8 id = 0;
324
325 priv = kzalloc(sizeof(struct mt2266_priv), GFP_KERNEL);
326 if (priv == NULL)
327 return NULL;
328
329 priv->cfg = cfg;
330 priv->i2c = i2c;
331 priv->band = MT2266_UHF;
332
333 if (mt2266_readreg(priv, 0, &id)) {
334 kfree(priv);
335 return NULL;
336 }
337 if (id != PART_REV) {
338 kfree(priv);
339 return NULL;
340 }
341 printk(KERN_INFO "MT2266: successfully identified\n");
342 memcpy(&fe->ops.tuner_ops, &mt2266_tuner_ops, sizeof(struct dvb_tuner_ops));
343
344 fe->tuner_priv = priv;
345 mt2266_calibrate(priv);
346 return fe;
347 }
348 EXPORT_SYMBOL(mt2266_attach);
349
350 MODULE_AUTHOR("Olivier DANET");
351 MODULE_DESCRIPTION("Microtune MT2266 silicon tuner driver");
352 MODULE_LICENSE("GPL");