Merge git://git.infradead.org/battery-2.6
[linux-2.6] / drivers / media / dvb / frontends / dib0070.c
1 /*
2  * Linux-DVB Driver for DiBcom's DiB0070 base-band RF Tuner.
3  *
4  * Copyright (C) 2005-7 DiBcom (http://www.dibcom.fr/)
5  *
6  * This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License as
8  *      published by the Free Software Foundation, version 2.
9  */
10 #include <linux/kernel.h>
11 #include <linux/i2c.h>
12
13 #include "dvb_frontend.h"
14
15 #include "dib0070.h"
16 #include "dibx000_common.h"
17
18 static int debug;
19 module_param(debug, int, 0644);
20 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
21
22 #define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiB0070: "); printk(args); printk("\n"); } } while (0)
23
24 #define DIB0070_P1D  0x00
25 #define DIB0070_P1F  0x01
26 #define DIB0070_P1G  0x03
27 #define DIB0070S_P1A 0x02
28
29 struct dib0070_state {
30         struct i2c_adapter *i2c;
31         struct dvb_frontend *fe;
32         const struct dib0070_config *cfg;
33         u16 wbd_ff_offset;
34         u8 revision;
35 };
36
37 static uint16_t dib0070_read_reg(struct dib0070_state *state, u8 reg)
38 {
39         u8 b[2];
40         struct i2c_msg msg[2] = {
41                 { .addr = state->cfg->i2c_address, .flags = 0,        .buf = &reg, .len = 1 },
42                 { .addr = state->cfg->i2c_address, .flags = I2C_M_RD, .buf = b,  .len = 2 },
43         };
44         if (i2c_transfer(state->i2c, msg, 2) != 2) {
45                 printk(KERN_WARNING "DiB0070 I2C read failed\n");
46                 return 0;
47         }
48         return (b[0] << 8) | b[1];
49 }
50
51 static int dib0070_write_reg(struct dib0070_state *state, u8 reg, u16 val)
52 {
53         u8 b[3] = { reg, val >> 8, val & 0xff };
54         struct i2c_msg msg = { .addr = state->cfg->i2c_address, .flags = 0, .buf = b, .len = 3 };
55         if (i2c_transfer(state->i2c, &msg, 1) != 1) {
56                 printk(KERN_WARNING "DiB0070 I2C write failed\n");
57                 return -EREMOTEIO;
58         }
59         return 0;
60 }
61
62 #define HARD_RESET(state) do { if (state->cfg->reset) { state->cfg->reset(state->fe,1); msleep(10); state->cfg->reset(state->fe,0); msleep(10); } } while (0)
63
64 static int dib0070_set_bandwidth(struct dvb_frontend *fe, struct dvb_frontend_parameters *ch)
65 {
66         struct dib0070_state *st = fe->tuner_priv;
67         u16 tmp = 0;
68         tmp = dib0070_read_reg(st, 0x02) & 0x3fff;
69
70     switch(BANDWIDTH_TO_KHZ(ch->u.ofdm.bandwidth)) {
71                 case  8000:
72                         tmp |= (0 << 14);
73                         break;
74                 case  7000:
75                         tmp |= (1 << 14);
76                         break;
77         case  6000:
78                         tmp |= (2 << 14);
79                         break;
80         case 5000:
81                 default:
82                         tmp |= (3 << 14);
83                         break;
84         }
85         dib0070_write_reg(st, 0x02, tmp);
86         return 0;
87 }
88
89 static void dib0070_captrim(struct dib0070_state *st, u16 LO4)
90 {
91         int8_t captrim, fcaptrim, step_sign, step;
92         u16 adc, adc_diff = 3000;
93
94
95
96         dib0070_write_reg(st, 0x0f, 0xed10);
97         dib0070_write_reg(st, 0x17,    0x0034);
98
99         dib0070_write_reg(st, 0x18, 0x0032);
100         msleep(2);
101
102         step = captrim = fcaptrim = 64;
103
104         do {
105                 step /= 2;
106                 dib0070_write_reg(st, 0x14, LO4 | captrim);
107                 msleep(1);
108                 adc = dib0070_read_reg(st, 0x19);
109
110                 dprintk( "CAPTRIM=%hd; ADC = %hd (ADC) & %dmV", captrim, adc, (u32) adc*(u32)1800/(u32)1024);
111
112                 if (adc >= 400) {
113                         adc -= 400;
114                         step_sign = -1;
115                 } else {
116                         adc = 400 - adc;
117                         step_sign = 1;
118                 }
119
120                 if (adc < adc_diff) {
121                         dprintk( "CAPTRIM=%hd is closer to target (%hd/%hd)", captrim, adc, adc_diff);
122                         adc_diff = adc;
123                         fcaptrim = captrim;
124
125
126
127                 }
128                 captrim += (step_sign * step);
129         } while (step >= 1);
130
131         dib0070_write_reg(st, 0x14, LO4 | fcaptrim);
132         dib0070_write_reg(st, 0x18, 0x07ff);
133 }
134
135 #define LPF     100                       // define for the loop filter 100kHz by default 16-07-06
136 #define LO4_SET_VCO_HFDIV(l, v, h)   l |= ((v) << 11) | ((h) << 7)
137 #define LO4_SET_SD(l, s)             l |= ((s) << 14) | ((s) << 12)
138 #define LO4_SET_CTRIM(l, c)          l |=  (c) << 10
139 static int dib0070_tune_digital(struct dvb_frontend *fe, struct dvb_frontend_parameters *ch)
140 {
141         struct dib0070_state *st = fe->tuner_priv;
142         u32 freq = ch->frequency/1000 + (BAND_OF_FREQUENCY(ch->frequency/1000) == BAND_VHF ? st->cfg->freq_offset_khz_vhf : st->cfg->freq_offset_khz_uhf);
143
144         u8 band = BAND_OF_FREQUENCY(freq), c;
145
146         /*******************VCO***********************************/
147         u16 lo4 = 0;
148
149         u8 REFDIV, PRESC = 2;
150         u32 FBDiv, Rest, FREF, VCOF_kHz;
151         u16 Num, Den;
152         /*******************FrontEnd******************************/
153         u16 value = 0;
154
155         dprintk( "Tuning for Band: %hd (%d kHz)", band, freq);
156
157
158         dib0070_write_reg(st, 0x17, 0x30);
159
160         dib0070_set_bandwidth(fe, ch);  /* c is used as HF */
161         switch (st->revision) {
162                 case DIB0070S_P1A:
163                         switch (band) {
164                                 case BAND_LBAND:
165                                         LO4_SET_VCO_HFDIV(lo4, 1, 1);
166                                         c = 2;
167                                         break;
168                                 case BAND_SBAND:
169                                         LO4_SET_VCO_HFDIV(lo4, 0, 0);
170                                         LO4_SET_CTRIM(lo4, 1);;
171                                         c = 1;
172                                         break;
173                                 case BAND_UHF:
174                                 default:
175                                         if (freq < 570000) {
176                                                 LO4_SET_VCO_HFDIV(lo4, 1, 3);
177                                                 PRESC = 6; c = 6;
178                                         } else if (freq < 680000) {
179                                                 LO4_SET_VCO_HFDIV(lo4, 0, 2);
180                                                 c = 4;
181                                         } else {
182                                                 LO4_SET_VCO_HFDIV(lo4, 1, 2);
183                                                 c = 4;
184                                         }
185                                         break;
186                         } break;
187
188                 case DIB0070_P1G:
189                 case DIB0070_P1F:
190                 default:
191                         switch (band) {
192                                 case BAND_FM:
193                                                 LO4_SET_VCO_HFDIV(lo4, 0, 7);
194                                                 c = 24;
195                                         break;
196                                 case BAND_LBAND:
197                                                 LO4_SET_VCO_HFDIV(lo4, 1, 0);
198                                                 c = 2;
199                                         break;
200                                 case BAND_VHF:
201                                         if (freq < 180000) {
202                                                 LO4_SET_VCO_HFDIV(lo4, 0, 3);
203                                                 c = 16;
204                                         } else if (freq < 190000) {
205                                                 LO4_SET_VCO_HFDIV(lo4, 1, 3);
206                                                 c = 16;
207                                         } else {
208                                                 LO4_SET_VCO_HFDIV(lo4, 0, 6);
209                                                 c = 12;
210                                         }
211                                         break;
212
213                                 case BAND_UHF:
214                                 default:
215                                         if (freq < 570000) {
216                                                 LO4_SET_VCO_HFDIV(lo4, 1, 5);
217                                                 c = 6;
218                                         } else if (freq < 700000) {
219                                                 LO4_SET_VCO_HFDIV(lo4, 0, 1);
220                                                 c = 4;
221                                         } else {
222                                                 LO4_SET_VCO_HFDIV(lo4, 1, 1);
223                                                 c = 4;
224                                         }
225                                         break;
226                         }
227                 break;
228         }
229
230         dprintk( "HFDIV code: %hd", (lo4 >> 7) & 0xf);
231         dprintk( "VCO = %hd", (lo4 >> 11) & 0x3);
232
233
234         VCOF_kHz = (c * freq) * 2;
235         dprintk( "VCOF in kHz: %d ((%hd*%d) << 1))",VCOF_kHz, c, freq);
236
237         switch (band) {
238                 case BAND_VHF:
239                         REFDIV = (u8) ((st->cfg->clock_khz + 9999) / 10000);
240                         break;
241                 case BAND_FM:
242                         REFDIV = (u8) ((st->cfg->clock_khz) / 1000);
243                         break;
244                 default:
245                         REFDIV = (u8) ( st->cfg->clock_khz  / 10000);
246                         break;
247         }
248         FREF = st->cfg->clock_khz / REFDIV;
249
250         dprintk( "REFDIV: %hd, FREF: %d", REFDIV, FREF);
251
252
253
254         switch (st->revision) {
255                 case DIB0070S_P1A:
256                         FBDiv = (VCOF_kHz / PRESC / FREF);
257                         Rest  = (VCOF_kHz / PRESC) - FBDiv * FREF;
258                         break;
259
260                 case DIB0070_P1G:
261                 case DIB0070_P1F:
262                 default:
263                         FBDiv = (freq / (FREF / 2));
264                         Rest  = 2 * freq - FBDiv * FREF;
265                         break;
266         }
267
268
269              if (Rest < LPF)              Rest = 0;
270         else if (Rest < 2 * LPF)          Rest = 2 * LPF;
271         else if (Rest > (FREF - LPF))   { Rest = 0 ; FBDiv += 1; }
272         else if (Rest > (FREF - 2 * LPF)) Rest = FREF - 2 * LPF;
273         Rest = (Rest * 6528) / (FREF / 10);
274         dprintk( "FBDIV: %d, Rest: %d", FBDiv, Rest);
275
276         Num = 0;
277         Den = 1;
278
279         if (Rest > 0) {
280                 LO4_SET_SD(lo4, 1);
281                 Den = 255;
282                 Num = (u16)Rest;
283         }
284         dprintk( "Num: %hd, Den: %hd, SD: %hd",Num, Den, (lo4 >> 12) & 0x1);
285
286
287
288         dib0070_write_reg(st, 0x11, (u16)FBDiv);
289
290
291         dib0070_write_reg(st, 0x12, (Den << 8) | REFDIV);
292
293
294         dib0070_write_reg(st, 0x13, Num);
295
296
297         value = 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001;
298
299         switch (band) {
300                 case BAND_UHF:   value |= 0x4000 | 0x0800; break;
301                 case BAND_LBAND: value |= 0x2000 | 0x0400; break;
302                 default:         value |= 0x8000 | 0x1000; break;
303         }
304         dib0070_write_reg(st, 0x20, value);
305
306         dib0070_captrim(st, lo4);
307         if (st->revision == DIB0070S_P1A) {
308                 if (band == BAND_SBAND)
309                         dib0070_write_reg(st, 0x15, 0x16e2);
310                 else
311                         dib0070_write_reg(st, 0x15, 0x56e5);
312         }
313
314
315
316         switch (band) {
317                 case BAND_UHF:   value = 0x7c82; break;
318                 case BAND_LBAND: value = 0x7c84; break;
319                 default:         value = 0x7c81; break;
320         }
321         dib0070_write_reg(st, 0x0f, value);
322         dib0070_write_reg(st, 0x06, 0x3fff);
323
324         /* Front End */
325         /* c == TUNE, value = SWITCH */
326         c = 0;
327         value = 0;
328         switch (band) {
329                 case BAND_FM:
330                         c = 0; value = 1;
331                 break;
332
333                 case BAND_VHF:
334                         if (freq <= 180000) c = 0;
335                         else if (freq <= 188200) c = 1;
336                         else if (freq <= 196400) c = 2;
337                         else c = 3;
338                         value = 1;
339                 break;
340
341                 case BAND_LBAND:
342                         if (freq <= 1500000) c = 0;
343                         else if (freq <= 1600000) c = 1;
344                         else c = 3;
345                 break;
346
347                 case BAND_SBAND:
348                         c = 7;
349                         dib0070_write_reg(st, 0x1d,0xFFFF);
350                 break;
351
352                 case BAND_UHF:
353                 default:
354                         if (st->cfg->flip_chip) {
355                                 if (freq <= 550000) c = 0;
356                                 else if (freq <= 590000) c = 1;
357                                 else if (freq <= 666000) c = 3;
358                                 else c = 5;
359                         } else {
360                                 if (freq <= 550000) c = 2;
361                                 else if (freq <= 650000) c = 3;
362                                 else if (freq <= 750000) c = 5;
363                                 else if (freq <= 850000) c = 6;
364                                 else c = 7;
365                         }
366                         value = 2;
367                 break;
368         }
369
370         /* default: LNA_MATCH=7, BIAS=3 */
371         dib0070_write_reg(st, 0x07, (value << 11) | (7 << 8) | (c << 3) | (3 << 0));
372         dib0070_write_reg(st, 0x08, (c << 10) | (3 << 7) | (127));
373         dib0070_write_reg(st, 0x0d, 0x0d80);
374
375
376         dib0070_write_reg(st, 0x18,   0x07ff);
377         dib0070_write_reg(st, 0x17, 0x0033);
378
379         return 0;
380 }
381
382 static int dib0070_wakeup(struct dvb_frontend *fe)
383 {
384         struct dib0070_state *st = fe->tuner_priv;
385         if (st->cfg->sleep)
386                 st->cfg->sleep(fe, 0);
387         return 0;
388 }
389
390 static int dib0070_sleep(struct dvb_frontend *fe)
391 {
392         struct dib0070_state *st = fe->tuner_priv;
393         if (st->cfg->sleep)
394                 st->cfg->sleep(fe, 1);
395         return 0;
396 }
397
398 static u16 dib0070_p1f_defaults[] =
399
400 {
401         7, 0x02,
402                 0x0008,
403                 0x0000,
404                 0x0000,
405                 0x0000,
406                 0x0000,
407                 0x0002,
408                 0x0100,
409
410         3, 0x0d,
411                 0x0d80,
412                 0x0001,
413                 0x0000,
414
415         4, 0x11,
416                 0x0000,
417                 0x0103,
418                 0x0000,
419                 0x0000,
420
421         3, 0x16,
422                 0x0004 | 0x0040,
423                 0x0030,
424                 0x07ff,
425
426         6, 0x1b,
427                 0x4112,
428                 0xff00,
429                 0xc07f,
430                 0x0000,
431                 0x0180,
432                 0x4000 | 0x0800 | 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001,
433
434         0,
435 };
436
437 static void dib0070_wbd_calibration(struct dib0070_state *state)
438 {
439         u16 wbd_offs;
440         dib0070_write_reg(state, 0x0f, 0x6d81);
441         dib0070_write_reg(state, 0x20, 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001);
442         msleep(9);
443         wbd_offs = dib0070_read_reg(state, 0x19);
444         dib0070_write_reg(state, 0x20, 0);
445         state->wbd_ff_offset = ((wbd_offs * 8 * 18 / 33 + 1) / 2);
446         dprintk( "WBDStart = %d (Vargen) - FF = %hd", (u32) wbd_offs * 1800/1024, state->wbd_ff_offset);
447 }
448
449 u16 dib0070_wbd_offset(struct dvb_frontend *fe)
450 {
451         struct dib0070_state *st = fe->tuner_priv;
452         return st->wbd_ff_offset;
453 }
454
455 EXPORT_SYMBOL(dib0070_wbd_offset);
456 static int dib0070_set_ctrl_lo5(struct dvb_frontend *fe, u8 vco_bias_trim, u8 hf_div_trim, u8 cp_current, u8 third_order_filt)
457 {
458         struct dib0070_state *state = fe->tuner_priv;
459     u16 lo5 = (third_order_filt << 14) | (0 << 13) | (1 << 12) | (3 << 9) | (cp_current << 6) | (hf_div_trim << 3) | (vco_bias_trim << 0);
460         dprintk( "CTRL_LO5: 0x%x", lo5);
461         return dib0070_write_reg(state, 0x15, lo5);
462 }
463
464 #define pgm_read_word(w) (*w)
465 static int dib0070_reset(struct dib0070_state *state)
466 {
467         u16 l, r, *n;
468
469         HARD_RESET(state);
470
471
472 #ifndef FORCE_SBAND_TUNER
473         if ((dib0070_read_reg(state, 0x22) >> 9) & 0x1)
474                 state->revision = (dib0070_read_reg(state, 0x1f) >> 8) & 0xff;
475         else
476 #endif
477                 state->revision = DIB0070S_P1A;
478
479         /* P1F or not */
480         dprintk( "Revision: %x", state->revision);
481
482         if (state->revision == DIB0070_P1D) {
483                 dprintk( "Error: this driver is not to be used meant for P1D or earlier");
484                 return -EINVAL;
485         }
486
487         n = (u16 *) dib0070_p1f_defaults;
488         l = pgm_read_word(n++);
489         while (l) {
490                 r = pgm_read_word(n++);
491                 do {
492                         dib0070_write_reg(state, (u8)r, pgm_read_word(n++));
493                         r++;
494                 } while (--l);
495                 l = pgm_read_word(n++);
496         }
497
498         if (state->cfg->force_crystal_mode != 0)
499                 r = state->cfg->force_crystal_mode;
500         else if (state->cfg->clock_khz >= 24000)
501                 r = 1;
502         else
503                 r = 2;
504
505         r |= state->cfg->osc_buffer_state << 3;
506
507         dib0070_write_reg(state, 0x10, r);
508         dib0070_write_reg(state, 0x1f, (1 << 8) | ((state->cfg->clock_pad_drive & 0xf) << 4));
509
510         if (state->cfg->invert_iq) {
511                 r = dib0070_read_reg(state, 0x02) & 0xffdf;
512                 dib0070_write_reg(state, 0x02, r | (1 << 5));
513         }
514
515
516         if (state->revision == DIB0070S_P1A)
517                 dib0070_set_ctrl_lo5(state->fe, 4, 7, 3, 1);
518         else
519                 dib0070_set_ctrl_lo5(state->fe, 4, 4, 2, 0);
520
521         dib0070_write_reg(state, 0x01, (54 << 9) | 0xc8);
522         return 0;
523 }
524
525
526 static int dib0070_release(struct dvb_frontend *fe)
527 {
528         kfree(fe->tuner_priv);
529         fe->tuner_priv = NULL;
530         return 0;
531 }
532
533 static struct dvb_tuner_ops dib0070_ops = {
534         .info = {
535                 .name           = "DiBcom DiB0070",
536                 .frequency_min  =  45000000,
537                 .frequency_max  = 860000000,
538                 .frequency_step =      1000,
539         },
540         .release       = dib0070_release,
541
542         .init          = dib0070_wakeup,
543         .sleep         = dib0070_sleep,
544         .set_params    = dib0070_tune_digital,
545 //      .get_frequency = dib0070_get_frequency,
546 //      .get_bandwidth = dib0070_get_bandwidth
547 };
548
549 struct dvb_frontend * dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg)
550 {
551         struct dib0070_state *state = kzalloc(sizeof(struct dib0070_state), GFP_KERNEL);
552         if (state == NULL)
553                 return NULL;
554
555         state->cfg = cfg;
556         state->i2c = i2c;
557         state->fe  = fe;
558         fe->tuner_priv = state;
559
560         if (dib0070_reset(state) != 0)
561                 goto free_mem;
562
563         dib0070_wbd_calibration(state);
564
565         printk(KERN_INFO "DiB0070: successfully identified\n");
566         memcpy(&fe->ops.tuner_ops, &dib0070_ops, sizeof(struct dvb_tuner_ops));
567
568         fe->tuner_priv = state;
569         return fe;
570
571 free_mem:
572         kfree(state);
573         fe->tuner_priv = NULL;
574         return NULL;
575 }
576 EXPORT_SYMBOL(dib0070_attach);
577
578 MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>");
579 MODULE_DESCRIPTION("Driver for the DiBcom 0070 base-band RF Tuner");
580 MODULE_LICENSE("GPL");