Merge branch 'master' of /usr/src/ntfs-2.6/
[linux-2.6] / drivers / media / video / tuner-simple.c
1 /*
2  *
3  * i2c tv tuner chip device driver
4  * controls all those simple 4-control-bytes style tuners.
5  */
6 #include <linux/delay.h>
7 #include <linux/i2c.h>
8 #include <linux/videodev.h>
9 #include <media/tuner.h>
10
11 static int offset = 0;
12 module_param(offset, int, 0666);
13 MODULE_PARM_DESC(offset,"Allows to specify an offset for tuner");
14
15 /* ---------------------------------------------------------------------- */
16
17 /* tv standard selection for Temic 4046 FM5
18    this value takes the low bits of control byte 2
19    from datasheet Rev.01, Feb.00
20      standard     BG      I       L       L2      D
21      picture IF   38.9    38.9    38.9    33.95   38.9
22      sound 1      33.4    32.9    32.4    40.45   32.4
23      sound 2      33.16
24      NICAM        33.05   32.348  33.05           33.05
25  */
26 #define TEMIC_SET_PAL_I         0x05
27 #define TEMIC_SET_PAL_DK        0x09
28 #define TEMIC_SET_PAL_L         0x0a // SECAM ?
29 #define TEMIC_SET_PAL_L2        0x0b // change IF !
30 #define TEMIC_SET_PAL_BG        0x0c
31
32 /* tv tuner system standard selection for Philips FQ1216ME
33    this value takes the low bits of control byte 2
34    from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
35      standard           BG      DK      I       L       L`
36      picture carrier    38.90   38.90   38.90   38.90   33.95
37      colour             34.47   34.47   34.47   34.47   38.38
38      sound 1            33.40   32.40   32.90   32.40   40.45
39      sound 2            33.16   -       -       -       -
40      NICAM              33.05   33.05   32.35   33.05   39.80
41  */
42 #define PHILIPS_SET_PAL_I       0x01 /* Bit 2 always zero !*/
43 #define PHILIPS_SET_PAL_BGDK    0x09
44 #define PHILIPS_SET_PAL_L2      0x0a
45 #define PHILIPS_SET_PAL_L       0x0b
46
47 /* system switching for Philips FI1216MF MK2
48    from datasheet "1996 Jul 09",
49     standard         BG     L      L'
50     picture carrier  38.90  38.90  33.95
51     colour           34.47  34.37  38.38
52     sound 1          33.40  32.40  40.45
53     sound 2          33.16  -      -
54     NICAM            33.05  33.05  39.80
55  */
56 #define PHILIPS_MF_SET_BG       0x01 /* Bit 2 must be zero, Bit 3 is system output */
57 #define PHILIPS_MF_SET_PAL_L    0x03 // France
58 #define PHILIPS_MF_SET_PAL_L2   0x02 // L'
59
60 /* Control byte */
61
62 #define TUNER_RATIO_MASK        0x06 /* Bit cb1:cb2 */
63 #define TUNER_RATIO_SELECT_50   0x00
64 #define TUNER_RATIO_SELECT_32   0x02
65 #define TUNER_RATIO_SELECT_166  0x04
66 #define TUNER_RATIO_SELECT_62   0x06
67
68 #define TUNER_CHARGE_PUMP       0x40  /* Bit cb6 */
69
70 /* Status byte */
71
72 #define TUNER_POR         0x80
73 #define TUNER_FL          0x40
74 #define TUNER_MODE        0x38
75 #define TUNER_AFC         0x07
76 #define TUNER_SIGNAL      0x07
77 #define TUNER_STEREO      0x10
78
79 #define TUNER_PLL_LOCKED   0x40
80 #define TUNER_STEREO_MK3   0x04
81
82 #define TUNER_PARAM_ANALOG 0  /* to be removed */
83 /* FIXME:
84  * Right now, all tuners are using the first tuner_params[] array element
85  * for analog mode. In the future, we will be merging similar tuner
86  * definitions together, such that each tuner definition will have a
87  * tuner_params struct for each available video standard. At that point,
88  * TUNER_PARAM_ANALOG will be removed, and the tuner_params[] array
89  * element will be chosen based on the video standard in use.
90  *
91  */
92
93 /* ---------------------------------------------------------------------- */
94
95 static int tuner_getstatus(struct i2c_client *c)
96 {
97         unsigned char byte;
98
99         if (1 != i2c_master_recv(c,&byte,1))
100                 return 0;
101
102         return byte;
103 }
104
105 static int tuner_signal(struct i2c_client *c)
106 {
107         return (tuner_getstatus(c) & TUNER_SIGNAL) << 13;
108 }
109
110 static int tuner_stereo(struct i2c_client *c)
111 {
112         int stereo, status;
113         struct tuner *t = i2c_get_clientdata(c);
114
115         status = tuner_getstatus (c);
116
117         switch (t->type) {
118                 case TUNER_PHILIPS_FM1216ME_MK3:
119                 case TUNER_PHILIPS_FM1236_MK3:
120                 case TUNER_PHILIPS_FM1256_IH3:
121                         stereo = ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
122                         break;
123                 default:
124                         stereo = status & TUNER_STEREO;
125         }
126
127         return stereo;
128 }
129
130
131 /* ---------------------------------------------------------------------- */
132
133 static void default_set_tv_freq(struct i2c_client *c, unsigned int freq)
134 {
135         struct tuner *t = i2c_get_clientdata(c);
136         u8 config, tuneraddr;
137         u16 div;
138         struct tunertype *tun;
139         u8 buffer[4];
140         int rc, IFPCoff, i, j;
141
142         tun = &tuners[t->type];
143         j = TUNER_PARAM_ANALOG;
144
145         for (i = 0; i < tun->params[j].count; i++) {
146                 if (freq > tun->params[j].ranges[i].limit)
147                         continue;
148                 break;
149         }
150         if (i == tun->params[j].count) {
151                 tuner_dbg("TV frequency out of range (%d > %d)",
152                                 freq, tun->params[j].ranges[i - 1].limit);
153                 freq = tun->params[j].ranges[--i].limit;
154         }
155         config = tun->params[j].ranges[i].cb;
156         /*  i == 0 -> VHF_LO  */
157         /*  i == 1 -> VHF_HI  */
158         /*  i == 2 -> UHF     */
159         tuner_dbg("tv: range %d\n",i);
160
161         /* tv norm specific stuff for multi-norm tuners */
162         switch (t->type) {
163         case TUNER_PHILIPS_SECAM: // FI1216MF
164                 /* 0x01 -> ??? no change ??? */
165                 /* 0x02 -> PAL BDGHI / SECAM L */
166                 /* 0x04 -> ??? PAL others / SECAM others ??? */
167                 config &= ~0x02;
168                 if (t->std & V4L2_STD_SECAM)
169                         config |= 0x02;
170                 break;
171
172         case TUNER_TEMIC_4046FM5:
173                 config &= ~0x0f;
174
175                 if (t->std & V4L2_STD_PAL_BG) {
176                         config |= TEMIC_SET_PAL_BG;
177
178                 } else if (t->std & V4L2_STD_PAL_I) {
179                         config |= TEMIC_SET_PAL_I;
180
181                 } else if (t->std & V4L2_STD_PAL_DK) {
182                         config |= TEMIC_SET_PAL_DK;
183
184                 } else if (t->std & V4L2_STD_SECAM_L) {
185                         config |= TEMIC_SET_PAL_L;
186
187                 }
188                 break;
189
190         case TUNER_PHILIPS_FQ1216ME:
191                 config &= ~0x0f;
192
193                 if (t->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
194                         config |= PHILIPS_SET_PAL_BGDK;
195
196                 } else if (t->std & V4L2_STD_PAL_I) {
197                         config |= PHILIPS_SET_PAL_I;
198
199                 } else if (t->std & V4L2_STD_SECAM_L) {
200                         config |= PHILIPS_SET_PAL_L;
201
202                 }
203                 break;
204
205         case TUNER_PHILIPS_ATSC:
206                 /* 0x00 -> ATSC antenna input 1 */
207                 /* 0x01 -> ATSC antenna input 2 */
208                 /* 0x02 -> NTSC antenna input 1 */
209                 /* 0x03 -> NTSC antenna input 2 */
210                 config &= ~0x03;
211                 if (!(t->std & V4L2_STD_ATSC))
212                         config |= 2;
213                 /* FIXME: input */
214                 break;
215
216         case TUNER_MICROTUNE_4042FI5:
217                 /* Set the charge pump for fast tuning */
218                 tun->params[j].config |= TUNER_CHARGE_PUMP;
219                 break;
220
221         case TUNER_PHILIPS_TUV1236D:
222                 /* 0x40 -> ATSC antenna input 1 */
223                 /* 0x48 -> ATSC antenna input 2 */
224                 /* 0x00 -> NTSC antenna input 1 */
225                 /* 0x08 -> NTSC antenna input 2 */
226                 buffer[0] = 0x14;
227                 buffer[1] = 0x00;
228                 buffer[2] = 0x17;
229                 buffer[3] = 0x00;
230                 config &= ~0x40;
231                 if (t->std & V4L2_STD_ATSC) {
232                         config |= 0x40;
233                         buffer[1] = 0x04;
234                 }
235                 /* set to the correct mode (analog or digital) */
236                 tuneraddr = c->addr;
237                 c->addr = 0x0a;
238                 if (2 != (rc = i2c_master_send(c,&buffer[0],2)))
239                         tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);
240                 if (2 != (rc = i2c_master_send(c,&buffer[2],2)))
241                         tuner_warn("i2c i/o error: rc == %d (should be 2)\n",rc);
242                 c->addr = tuneraddr;
243                 /* FIXME: input */
244                 break;
245         }
246
247         /* IFPCoff = Video Intermediate Frequency - Vif:
248                 940  =16*58.75  NTSC/J (Japan)
249                 732  =16*45.75  M/N STD
250                 704  =16*44     ATSC (at DVB code)
251                 632  =16*39.50  I U.K.
252                 622.4=16*38.90  B/G D/K I, L STD
253                 592  =16*37.00  D China
254                 590  =16.36.875 B Australia
255                 543.2=16*33.95  L' STD
256                 171.2=16*10.70  FM Radio (at set_radio_freq)
257         */
258
259         if (t->std == V4L2_STD_NTSC_M_JP) {
260                 IFPCoff = 940;
261         } else if ((t->std & V4L2_STD_MN) &&
262                   !(t->std & ~V4L2_STD_MN)) {
263                 IFPCoff = 732;
264         } else if (t->std == V4L2_STD_SECAM_LC) {
265                 IFPCoff = 543;
266         } else {
267                 IFPCoff = 623;
268         }
269
270         div=freq + IFPCoff + offset;
271
272         tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, Offset=%d.%02d MHz, div=%0d\n",
273                                         freq / 16, freq % 16 * 100 / 16,
274                                         IFPCoff / 16, IFPCoff % 16 * 100 / 16,
275                                         offset / 16, offset % 16 * 100 / 16,
276                                         div);
277
278         if (tuners[t->type].params->cb_first_if_lower_freq && div < t->last_div) {
279                 buffer[0] = tun->params[j].config;
280                 buffer[1] = config;
281                 buffer[2] = (div>>8) & 0x7f;
282                 buffer[3] = div      & 0xff;
283         } else {
284                 buffer[0] = (div>>8) & 0x7f;
285                 buffer[1] = div      & 0xff;
286                 buffer[2] = tun->params[j].config;
287                 buffer[3] = config;
288         }
289         t->last_div = div;
290         tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
291                   buffer[0],buffer[1],buffer[2],buffer[3]);
292
293         if (4 != (rc = i2c_master_send(c,buffer,4)))
294                 tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
295
296         if (t->type == TUNER_MICROTUNE_4042FI5) {
297                 // FIXME - this may also work for other tuners
298                 unsigned long timeout = jiffies + msecs_to_jiffies(1);
299                 u8 status_byte = 0;
300
301                 /* Wait until the PLL locks */
302                 for (;;) {
303                         if (time_after(jiffies,timeout))
304                                 return;
305                         if (1 != (rc = i2c_master_recv(c,&status_byte,1))) {
306                                 tuner_warn("i2c i/o read error: rc == %d (should be 1)\n",rc);
307                                 break;
308                         }
309                         if (status_byte & TUNER_PLL_LOCKED)
310                                 break;
311                         udelay(10);
312                 }
313
314                 /* Set the charge pump for optimized phase noise figure */
315                 tun->params[j].config &= ~TUNER_CHARGE_PUMP;
316                 buffer[0] = (div>>8) & 0x7f;
317                 buffer[1] = div      & 0xff;
318                 buffer[2] = tun->params[j].config;
319                 buffer[3] = config;
320                 tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
321                        buffer[0],buffer[1],buffer[2],buffer[3]);
322
323                 if (4 != (rc = i2c_master_send(c,buffer,4)))
324                         tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
325         }
326 }
327
328 static void default_set_radio_freq(struct i2c_client *c, unsigned int freq)
329 {
330         struct tunertype *tun;
331         struct tuner *t = i2c_get_clientdata(c);
332         u8 buffer[4];
333         u16 div;
334         int rc, j;
335
336         tun = &tuners[t->type];
337         j = TUNER_PARAM_ANALOG;
338
339         div = (20 * freq / 16000) + (int)(20*10.7); /* IF 10.7 MHz */
340         buffer[2] = (tun->params[j].config & ~TUNER_RATIO_MASK) | TUNER_RATIO_SELECT_50; /* 50 kHz step */
341
342         switch (t->type) {
343         case TUNER_TENA_9533_DI:
344         case TUNER_YMEC_TVF_5533MF:
345                 tuner_dbg ("This tuner doesn't have FM. Most cards has a TEA5767 for FM\n");
346                 return;
347         case TUNER_PHILIPS_FM1216ME_MK3:
348         case TUNER_PHILIPS_FM1236_MK3:
349         case TUNER_PHILIPS_FMD1216ME_MK3:
350                 buffer[3] = 0x19;
351                 break;
352         case TUNER_PHILIPS_FM1256_IH3:
353                 div = (20 * freq) / 16000 + (int)(33.3 * 20);  /* IF 33.3 MHz */
354                 buffer[3] = 0x19;
355                 break;
356         case TUNER_LG_PAL_FM:
357                 buffer[3] = 0xa5;
358                 break;
359         case TUNER_MICROTUNE_4049FM5:
360                 div = (20 * freq) / 16000 + (int)(33.3 * 20); /* IF 33.3 MHz */
361                 buffer[3] = 0xa4;
362                 break;
363         default:
364                 buffer[3] = 0xa4;
365                 break;
366         }
367         buffer[0] = (div>>8) & 0x7f;
368         buffer[1] = div      & 0xff;
369         if (tuners[t->type].params->cb_first_if_lower_freq && div < t->last_div) {
370                 buffer[0] = buffer[2];
371                 buffer[1] = buffer[3];
372                 buffer[2] = (div>>8) & 0x7f;
373                 buffer[3] = div      & 0xff;
374         } else {
375                 buffer[0] = (div>>8) & 0x7f;
376                 buffer[1] = div      & 0xff;
377         }
378
379         tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
380                buffer[0],buffer[1],buffer[2],buffer[3]);
381         t->last_div = div;
382
383         if (4 != (rc = i2c_master_send(c,buffer,4)))
384                 tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
385 }
386
387 int default_tuner_init(struct i2c_client *c)
388 {
389         struct tuner *t = i2c_get_clientdata(c);
390
391         tuner_info("type set to %d (%s)\n",
392                    t->type, tuners[t->type].name);
393         strlcpy(c->name, tuners[t->type].name, sizeof(c->name));
394
395         t->set_tv_freq = default_set_tv_freq;
396         t->set_radio_freq = default_set_radio_freq;
397         t->has_signal = tuner_signal;
398         t->is_stereo = tuner_stereo;
399         t->standby = NULL;
400
401         return 0;
402 }
403
404 /*
405  * Overrides for Emacs so that we follow Linus's tabbing style.
406  * ---------------------------------------------------------------------------
407  * Local variables:
408  * c-basic-offset: 8
409  * End:
410  */