Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / media / video / msp3400-kthreads.c
1 /*
2  * Programming the mspx4xx sound processor family
3  *
4  * (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org>
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
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (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  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19  * 02110-1301, USA.
20  */
21
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/i2c.h>
27 #include <linux/freezer.h>
28 #include <linux/videodev.h>
29 #include <linux/videodev2.h>
30 #include <media/v4l2-common.h>
31 #include <media/msp3400.h>
32 #include <linux/kthread.h>
33 #include <linux/suspend.h>
34 #include "msp3400-driver.h"
35
36 /* this one uses the automatic sound standard detection of newer msp34xx
37    chip versions */
38 static struct {
39         int retval;
40         int main, second;
41         char *name;
42 } msp_stdlist[] = {
43         { 0x0000, 0, 0, "could not detect sound standard" },
44         { 0x0001, 0, 0, "autodetect start" },
45         { 0x0002, MSP_CARRIER(4.5), MSP_CARRIER(4.72), "4.5/4.72  M Dual FM-Stereo" },
46         { 0x0003, MSP_CARRIER(5.5), MSP_CARRIER(5.7421875), "5.5/5.74  B/G Dual FM-Stereo" },
47         { 0x0004, MSP_CARRIER(6.5), MSP_CARRIER(6.2578125), "6.5/6.25  D/K1 Dual FM-Stereo" },
48         { 0x0005, MSP_CARRIER(6.5), MSP_CARRIER(6.7421875), "6.5/6.74  D/K2 Dual FM-Stereo" },
49         { 0x0006, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  D/K FM-Mono (HDEV3)" },
50         { 0x0007, MSP_CARRIER(6.5), MSP_CARRIER(5.7421875), "6.5/5.74  D/K3 Dual FM-Stereo" },
51         { 0x0008, MSP_CARRIER(5.5), MSP_CARRIER(5.85), "5.5/5.85  B/G NICAM FM" },
52         { 0x0009, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  L NICAM AM" },
53         { 0x000a, MSP_CARRIER(6.0), MSP_CARRIER(6.55), "6.0/6.55  I NICAM FM" },
54         { 0x000b, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM" },
55         { 0x000c, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM (HDEV2)" },
56         { 0x000d, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM (HDEV3)" },
57         { 0x0020, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Stereo" },
58         { 0x0021, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Mono + SAP" },
59         { 0x0030, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M EIA-J Japan Stereo" },
60         { 0x0040, MSP_CARRIER(10.7), MSP_CARRIER(10.7), "10.7  FM-Stereo Radio" },
61         { 0x0050, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  SAT-Mono" },
62         { 0x0051, MSP_CARRIER(7.02), MSP_CARRIER(7.20), "7.02/7.20  SAT-Stereo" },
63         { 0x0060, MSP_CARRIER(7.2), MSP_CARRIER(7.2), "7.2  SAT ADR" },
64         {     -1, 0, 0, NULL }, /* EOF */
65 };
66
67 static struct msp3400c_init_data_dem {
68         int fir1[6];
69         int fir2[6];
70         int cdo1;
71         int cdo2;
72         int ad_cv;
73         int mode_reg;
74         int dsp_src;
75         int dsp_matrix;
76 } msp3400c_init_data[] = {
77         {       /* AM (for carrier detect / msp3400) */
78                 {75, 19, 36, 35, 39, 40},
79                 {75, 19, 36, 35, 39, 40},
80                 MSP_CARRIER(5.5), MSP_CARRIER(5.5),
81                 0x00d0, 0x0500, 0x0020, 0x3000
82         }, {    /* AM (for carrier detect / msp3410) */
83                 {-1, -1, -8, 2, 59, 126},
84                 {-1, -1, -8, 2, 59, 126},
85                 MSP_CARRIER(5.5), MSP_CARRIER(5.5),
86                 0x00d0, 0x0100, 0x0020, 0x3000
87         }, {    /* FM Radio */
88                 {-8, -8, 4, 6, 78, 107},
89                 {-8, -8, 4, 6, 78, 107},
90                 MSP_CARRIER(10.7), MSP_CARRIER(10.7),
91                 0x00d0, 0x0480, 0x0020, 0x3000
92         }, {    /* Terrestial FM-mono + FM-stereo */
93                 {3, 18, 27, 48, 66, 72},
94                 {3, 18, 27, 48, 66, 72},
95                 MSP_CARRIER(5.5), MSP_CARRIER(5.5),
96                 0x00d0, 0x0480, 0x0030, 0x3000
97         }, {    /* Sat FM-mono */
98                 { 1, 9, 14, 24, 33, 37},
99                 { 3, 18, 27, 48, 66, 72},
100                 MSP_CARRIER(6.5), MSP_CARRIER(6.5),
101                 0x00c6, 0x0480, 0x0000, 0x3000
102         }, {    /* NICAM/FM --  B/G (5.5/5.85), D/K (6.5/5.85) */
103                 {-2, -8, -10, 10, 50, 86},
104                 {3, 18, 27, 48, 66, 72},
105                 MSP_CARRIER(5.5), MSP_CARRIER(5.5),
106                 0x00d0, 0x0040, 0x0120, 0x3000
107         }, {    /* NICAM/FM -- I (6.0/6.552) */
108                 {2, 4, -6, -4, 40, 94},
109                 {3, 18, 27, 48, 66, 72},
110                 MSP_CARRIER(6.0), MSP_CARRIER(6.0),
111                 0x00d0, 0x0040, 0x0120, 0x3000
112         }, {    /* NICAM/AM -- L (6.5/5.85) */
113                 {-2, -8, -10, 10, 50, 86},
114                 {-4, -12, -9, 23, 79, 126},
115                 MSP_CARRIER(6.5), MSP_CARRIER(6.5),
116                 0x00c6, 0x0140, 0x0120, 0x7c00
117         },
118 };
119
120 struct msp3400c_carrier_detect {
121         int   cdo;
122         char *name;
123 };
124
125 static struct msp3400c_carrier_detect msp3400c_carrier_detect_main[] = {
126         /* main carrier */
127         { MSP_CARRIER(4.5),        "4.5   NTSC"                   },
128         { MSP_CARRIER(5.5),        "5.5   PAL B/G"                },
129         { MSP_CARRIER(6.0),        "6.0   PAL I"                  },
130         { MSP_CARRIER(6.5),        "6.5   PAL D/K + SAT + SECAM"  }
131 };
132
133 static struct msp3400c_carrier_detect msp3400c_carrier_detect_55[] = {
134         /* PAL B/G */
135         { MSP_CARRIER(5.7421875),  "5.742 PAL B/G FM-stereo"     },
136         { MSP_CARRIER(5.85),       "5.85  PAL B/G NICAM"         }
137 };
138
139 static struct msp3400c_carrier_detect msp3400c_carrier_detect_65[] = {
140         /* PAL SAT / SECAM */
141         { MSP_CARRIER(5.85),       "5.85  PAL D/K + SECAM NICAM" },
142         { MSP_CARRIER(6.2578125),  "6.25  PAL D/K1 FM-stereo" },
143         { MSP_CARRIER(6.7421875),  "6.74  PAL D/K2 FM-stereo" },
144         { MSP_CARRIER(7.02),       "7.02  PAL SAT FM-stereo s/b" },
145         { MSP_CARRIER(7.20),       "7.20  PAL SAT FM-stereo s"   },
146         { MSP_CARRIER(7.38),       "7.38  PAL SAT FM-stereo b"   },
147 };
148
149 /* ------------------------------------------------------------------------ */
150
151 const char *msp_standard_std_name(int std)
152 {
153         int i;
154
155         for (i = 0; msp_stdlist[i].name != NULL; i++)
156                 if (msp_stdlist[i].retval == std)
157                         return msp_stdlist[i].name;
158         return "unknown";
159 }
160
161 static void msp_set_source(struct i2c_client *client, u16 src)
162 {
163         struct msp_state *state = i2c_get_clientdata(client);
164
165         if (msp_dolby) {
166                 msp_write_dsp(client, 0x0008, 0x0520); /* I2S1 */
167                 msp_write_dsp(client, 0x0009, 0x0620); /* I2S2 */
168         } else {
169                 msp_write_dsp(client, 0x0008, src);
170                 msp_write_dsp(client, 0x0009, src);
171         }
172         msp_write_dsp(client, 0x000a, src);
173         msp_write_dsp(client, 0x000b, src);
174         msp_write_dsp(client, 0x000c, src);
175         if (state->has_scart2_out)
176                 msp_write_dsp(client, 0x0041, src);
177 }
178
179 void msp3400c_set_carrier(struct i2c_client *client, int cdo1, int cdo2)
180 {
181         msp_write_dem(client, 0x0093, cdo1 & 0xfff);
182         msp_write_dem(client, 0x009b, cdo1 >> 12);
183         msp_write_dem(client, 0x00a3, cdo2 & 0xfff);
184         msp_write_dem(client, 0x00ab, cdo2 >> 12);
185         msp_write_dem(client, 0x0056, 0); /* LOAD_REG_1/2 */
186 }
187
188 void msp3400c_set_mode(struct i2c_client *client, int mode)
189 {
190         struct msp_state *state = i2c_get_clientdata(client);
191         struct msp3400c_init_data_dem *data = &msp3400c_init_data[mode];
192         int tuner = (state->routing.input >> 3) & 1;
193         int i;
194
195         v4l_dbg(1, msp_debug, client, "set_mode: %d\n", mode);
196         state->mode = mode;
197         state->rxsubchans = V4L2_TUNER_SUB_MONO;
198
199         msp_write_dem(client, 0x00bb, data->ad_cv | (tuner ? 0x100 : 0));
200
201         for (i = 5; i >= 0; i--)               /* fir 1 */
202                 msp_write_dem(client, 0x0001, data->fir1[i]);
203
204         msp_write_dem(client, 0x0005, 0x0004); /* fir 2 */
205         msp_write_dem(client, 0x0005, 0x0040);
206         msp_write_dem(client, 0x0005, 0x0000);
207         for (i = 5; i >= 0; i--)
208                 msp_write_dem(client, 0x0005, data->fir2[i]);
209
210         msp_write_dem(client, 0x0083, data->mode_reg);
211
212         msp3400c_set_carrier(client, data->cdo1, data->cdo2);
213
214         msp_set_source(client, data->dsp_src);
215         /* set prescales */
216
217         /* volume prescale for SCART (AM mono input) */
218         msp_write_dsp(client, 0x000d, 0x1900);
219         msp_write_dsp(client, 0x000e, data->dsp_matrix);
220         if (state->has_nicam) /* nicam prescale */
221                 msp_write_dsp(client, 0x0010, 0x5a00);
222 }
223
224 /* Set audio mode. Note that the pre-'G' models do not support BTSC+SAP,
225    nor do they support stereo BTSC. */
226 static void msp3400c_set_audmode(struct i2c_client *client)
227 {
228         static char *strmode[] = {
229                 "mono", "stereo", "lang2", "lang1", "lang1+lang2"
230         };
231         struct msp_state *state = i2c_get_clientdata(client);
232         char *modestr = (state->audmode >= 0 && state->audmode < 5) ?
233                 strmode[state->audmode] : "unknown";
234         int src = 0;    /* channel source: FM/AM, nicam or SCART */
235         int audmode = state->audmode;
236
237         if (state->opmode == OPMODE_AUTOSELECT) {
238                 /* this method would break everything, let's make sure
239                  * it's never called
240                  */
241                 v4l_dbg(1, msp_debug, client,
242                         "set_audmode called with mode=%d instead of set_source (ignored)\n",
243                         state->audmode);
244                 return;
245         }
246
247         /* Note: for the C and D revs no NTSC stereo + SAP is possible as
248            the hardware does not support SAP. So the rxsubchans combination
249            of STEREO | LANG2 does not occur. */
250
251         if (state->mode != MSP_MODE_EXTERN) {
252                 /* switch to mono if only mono is available */
253                 if (state->rxsubchans == V4L2_TUNER_SUB_MONO)
254                         audmode = V4L2_TUNER_MODE_MONO;
255                 /* if bilingual */
256                 else if (state->rxsubchans & V4L2_TUNER_SUB_LANG2) {
257                         /* and mono or stereo, then fallback to lang1 */
258                         if (audmode == V4L2_TUNER_MODE_MONO ||
259                             audmode == V4L2_TUNER_MODE_STEREO)
260                                 audmode = V4L2_TUNER_MODE_LANG1;
261                 }
262                 /* if stereo, and audmode is not mono, then switch to stereo */
263                 else if (audmode != V4L2_TUNER_MODE_MONO)
264                         audmode = V4L2_TUNER_MODE_STEREO;
265         }
266
267         /* switch demodulator */
268         switch (state->mode) {
269         case MSP_MODE_FM_TERRA:
270                 v4l_dbg(1, msp_debug, client, "FM set_audmode: %s\n", modestr);
271                 switch (audmode) {
272                 case V4L2_TUNER_MODE_STEREO:
273                         msp_write_dsp(client, 0x000e, 0x3001);
274                         break;
275                 case V4L2_TUNER_MODE_MONO:
276                 case V4L2_TUNER_MODE_LANG1:
277                 case V4L2_TUNER_MODE_LANG2:
278                 case V4L2_TUNER_MODE_LANG1_LANG2:
279                         msp_write_dsp(client, 0x000e, 0x3000);
280                         break;
281                 }
282                 break;
283         case MSP_MODE_FM_SAT:
284                 v4l_dbg(1, msp_debug, client, "SAT set_audmode: %s\n", modestr);
285                 switch (audmode) {
286                 case V4L2_TUNER_MODE_MONO:
287                         msp3400c_set_carrier(client, MSP_CARRIER(6.5), MSP_CARRIER(6.5));
288                         break;
289                 case V4L2_TUNER_MODE_STEREO:
290                 case V4L2_TUNER_MODE_LANG1_LANG2:
291                         msp3400c_set_carrier(client, MSP_CARRIER(7.2), MSP_CARRIER(7.02));
292                         break;
293                 case V4L2_TUNER_MODE_LANG1:
294                         msp3400c_set_carrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
295                         break;
296                 case V4L2_TUNER_MODE_LANG2:
297                         msp3400c_set_carrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
298                         break;
299                 }
300                 break;
301         case MSP_MODE_FM_NICAM1:
302         case MSP_MODE_FM_NICAM2:
303         case MSP_MODE_AM_NICAM:
304                 v4l_dbg(1, msp_debug, client,
305                         "NICAM set_audmode: %s\n", modestr);
306                 if (state->nicam_on)
307                         src = 0x0100;  /* NICAM */
308                 break;
309         case MSP_MODE_BTSC:
310                 v4l_dbg(1, msp_debug, client,
311                         "BTSC set_audmode: %s\n", modestr);
312                 break;
313         case MSP_MODE_EXTERN:
314                 v4l_dbg(1, msp_debug, client,
315                         "extern set_audmode: %s\n", modestr);
316                 src = 0x0200;  /* SCART */
317                 break;
318         case MSP_MODE_FM_RADIO:
319                 v4l_dbg(1, msp_debug, client,
320                         "FM-Radio set_audmode: %s\n", modestr);
321                 break;
322         default:
323                 v4l_dbg(1, msp_debug, client, "mono set_audmode\n");
324                 return;
325         }
326
327         /* switch audio */
328         v4l_dbg(1, msp_debug, client, "set audmode %d\n", audmode);
329         switch (audmode) {
330         case V4L2_TUNER_MODE_STEREO:
331         case V4L2_TUNER_MODE_LANG1_LANG2:
332                 src |= 0x0020;
333                 break;
334         case V4L2_TUNER_MODE_MONO:
335                 if (state->mode == MSP_MODE_AM_NICAM) {
336                         v4l_dbg(1, msp_debug, client, "switching to AM mono\n");
337                         /* AM mono decoding is handled by tuner, not MSP chip */
338                         /* SCART switching control register */
339                         msp_set_scart(client, SCART_MONO, 0);
340                         src = 0x0200;
341                         break;
342                 }
343                 if (state->rxsubchans & V4L2_TUNER_SUB_STEREO)
344                         src = 0x0030;
345                 break;
346         case V4L2_TUNER_MODE_LANG1:
347                 break;
348         case V4L2_TUNER_MODE_LANG2:
349                 src |= 0x0010;
350                 break;
351         }
352         v4l_dbg(1, msp_debug, client,
353                 "set_audmode final source/matrix = 0x%x\n", src);
354
355         msp_set_source(client, src);
356 }
357
358 static void msp3400c_print_mode(struct i2c_client *client)
359 {
360         struct msp_state *state = i2c_get_clientdata(client);
361
362         if (state->main == state->second)
363                 v4l_dbg(1, msp_debug, client,
364                         "mono sound carrier: %d.%03d MHz\n",
365                         state->main / 910000, (state->main / 910) % 1000);
366         else
367                 v4l_dbg(1, msp_debug, client,
368                         "main sound carrier: %d.%03d MHz\n",
369                         state->main / 910000, (state->main / 910) % 1000);
370         if (state->mode == MSP_MODE_FM_NICAM1 || state->mode == MSP_MODE_FM_NICAM2)
371                 v4l_dbg(1, msp_debug, client,
372                         "NICAM/FM carrier  : %d.%03d MHz\n",
373                         state->second / 910000, (state->second/910) % 1000);
374         if (state->mode == MSP_MODE_AM_NICAM)
375                 v4l_dbg(1, msp_debug, client,
376                         "NICAM/AM carrier  : %d.%03d MHz\n",
377                         state->second / 910000, (state->second / 910) % 1000);
378         if (state->mode == MSP_MODE_FM_TERRA && state->main != state->second) {
379                 v4l_dbg(1, msp_debug, client,
380                         "FM-stereo carrier : %d.%03d MHz\n",
381                         state->second / 910000, (state->second / 910) % 1000);
382         }
383 }
384
385 /* ----------------------------------------------------------------------- */
386
387 static int msp3400c_detect_stereo(struct i2c_client *client)
388 {
389         struct msp_state *state = i2c_get_clientdata(client);
390         int val;
391         int rxsubchans = state->rxsubchans;
392         int newnicam = state->nicam_on;
393         int update = 0;
394
395         switch (state->mode) {
396         case MSP_MODE_FM_TERRA:
397                 val = msp_read_dsp(client, 0x18);
398                 if (val > 32767)
399                         val -= 65536;
400                 v4l_dbg(2, msp_debug, client,
401                         "stereo detect register: %d\n", val);
402                 if (val > 8192) {
403                         rxsubchans = V4L2_TUNER_SUB_STEREO;
404                 } else if (val < -4096) {
405                         rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
406                 } else {
407                         rxsubchans = V4L2_TUNER_SUB_MONO;
408                 }
409                 newnicam = 0;
410                 break;
411         case MSP_MODE_FM_NICAM1:
412         case MSP_MODE_FM_NICAM2:
413         case MSP_MODE_AM_NICAM:
414                 val = msp_read_dem(client, 0x23);
415                 v4l_dbg(2, msp_debug, client, "nicam sync=%d, mode=%d\n",
416                         val & 1, (val & 0x1e) >> 1);
417
418                 if (val & 1) {
419                         /* nicam synced */
420                         switch ((val & 0x1e) >> 1)  {
421                         case 0:
422                         case 8:
423                                 rxsubchans = V4L2_TUNER_SUB_STEREO;
424                                 break;
425                         case 1:
426                         case 9:
427                                 rxsubchans = V4L2_TUNER_SUB_MONO;
428                                 break;
429                         case 2:
430                         case 10:
431                                 rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
432                                 break;
433                         default:
434                                 rxsubchans = V4L2_TUNER_SUB_MONO;
435                                 break;
436                         }
437                         newnicam = 1;
438                 } else {
439                         newnicam = 0;
440                         rxsubchans = V4L2_TUNER_SUB_MONO;
441                 }
442                 break;
443         }
444         if (rxsubchans != state->rxsubchans) {
445                 update = 1;
446                 v4l_dbg(1, msp_debug, client,
447                         "watch: rxsubchans %02x => %02x\n",
448                         state->rxsubchans, rxsubchans);
449                 state->rxsubchans = rxsubchans;
450         }
451         if (newnicam != state->nicam_on) {
452                 update = 1;
453                 v4l_dbg(1, msp_debug, client, "watch: nicam %d => %d\n",
454                         state->nicam_on, newnicam);
455                 state->nicam_on = newnicam;
456         }
457         return update;
458 }
459
460 /*
461  * A kernel thread for msp3400 control -- we don't want to block the
462  * in the ioctl while doing the sound carrier & stereo detect
463  */
464 /* stereo/multilang monitoring */
465 static void watch_stereo(struct i2c_client *client)
466 {
467         struct msp_state *state = i2c_get_clientdata(client);
468
469         if (msp_detect_stereo(client))
470                 msp_set_audmode(client);
471
472         if (msp_once)
473                 state->watch_stereo = 0;
474 }
475
476 int msp3400c_thread(void *data)
477 {
478         struct i2c_client *client = data;
479         struct msp_state *state = i2c_get_clientdata(client);
480         struct msp3400c_carrier_detect *cd;
481         int count, max1, max2, val1, val2, val, i;
482
483
484         v4l_dbg(1, msp_debug, client, "msp3400 daemon started\n");
485         set_freezable();
486         for (;;) {
487                 v4l_dbg(2, msp_debug, client, "msp3400 thread: sleep\n");
488                 msp_sleep(state, -1);
489                 v4l_dbg(2, msp_debug, client, "msp3400 thread: wakeup\n");
490
491 restart:
492                 v4l_dbg(2, msp_debug, client, "thread: restart scan\n");
493                 state->restart = 0;
494                 if (kthread_should_stop())
495                         break;
496
497                 if (state->radio || MSP_MODE_EXTERN == state->mode) {
498                         /* no carrier scan, just unmute */
499                         v4l_dbg(1, msp_debug, client,
500                                 "thread: no carrier scan\n");
501                         state->scan_in_progress = 0;
502                         msp_set_audio(client);
503                         continue;
504                 }
505
506                 /* mute audio */
507                 state->scan_in_progress = 1;
508                 msp_set_audio(client);
509
510                 msp3400c_set_mode(client, MSP_MODE_AM_DETECT);
511                 val1 = val2 = 0;
512                 max1 = max2 = -1;
513                 state->watch_stereo = 0;
514                 state->nicam_on = 0;
515
516                 /* wait for tuner to settle down after a channel change */
517                 if (msp_sleep(state, 200))
518                         goto restart;
519
520                 /* carrier detect pass #1 -- main carrier */
521                 cd = msp3400c_carrier_detect_main;
522                 count = ARRAY_SIZE(msp3400c_carrier_detect_main);
523
524                 if (msp_amsound && (state->v4l2_std & V4L2_STD_SECAM)) {
525                         /* autodetect doesn't work well with AM ... */
526                         max1 = 3;
527                         count = 0;
528                         v4l_dbg(1, msp_debug, client, "AM sound override\n");
529                 }
530
531                 for (i = 0; i < count; i++) {
532                         msp3400c_set_carrier(client, cd[i].cdo, cd[i].cdo);
533                         if (msp_sleep(state, 100))
534                                 goto restart;
535                         val = msp_read_dsp(client, 0x1b);
536                         if (val > 32767)
537                                 val -= 65536;
538                         if (val1 < val)
539                                 val1 = val, max1 = i;
540                         v4l_dbg(1, msp_debug, client,
541                                 "carrier1 val: %5d / %s\n", val, cd[i].name);
542                 }
543
544                 /* carrier detect pass #2 -- second (stereo) carrier */
545                 switch (max1) {
546                 case 1: /* 5.5 */
547                         cd = msp3400c_carrier_detect_55;
548                         count = ARRAY_SIZE(msp3400c_carrier_detect_55);
549                         break;
550                 case 3: /* 6.5 */
551                         cd = msp3400c_carrier_detect_65;
552                         count = ARRAY_SIZE(msp3400c_carrier_detect_65);
553                         break;
554                 case 0: /* 4.5 */
555                 case 2: /* 6.0 */
556                 default:
557                         cd = NULL;
558                         count = 0;
559                         break;
560                 }
561
562                 if (msp_amsound && (state->v4l2_std & V4L2_STD_SECAM)) {
563                         /* autodetect doesn't work well with AM ... */
564                         cd = NULL;
565                         count = 0;
566                         max2 = 0;
567                 }
568                 for (i = 0; i < count; i++) {
569                         msp3400c_set_carrier(client, cd[i].cdo, cd[i].cdo);
570                         if (msp_sleep(state, 100))
571                                 goto restart;
572                         val = msp_read_dsp(client, 0x1b);
573                         if (val > 32767)
574                                 val -= 65536;
575                         if (val2 < val)
576                                 val2 = val, max2 = i;
577                         v4l_dbg(1, msp_debug, client,
578                                 "carrier2 val: %5d / %s\n", val, cd[i].name);
579                 }
580
581                 /* program the msp3400 according to the results */
582                 state->main = msp3400c_carrier_detect_main[max1].cdo;
583                 switch (max1) {
584                 case 1: /* 5.5 */
585                         if (max2 == 0) {
586                                 /* B/G FM-stereo */
587                                 state->second = msp3400c_carrier_detect_55[max2].cdo;
588                                 msp3400c_set_mode(client, MSP_MODE_FM_TERRA);
589                                 state->watch_stereo = 1;
590                         } else if (max2 == 1 && state->has_nicam) {
591                                 /* B/G NICAM */
592                                 state->second = msp3400c_carrier_detect_55[max2].cdo;
593                                 msp3400c_set_mode(client, MSP_MODE_FM_NICAM1);
594                                 state->nicam_on = 1;
595                                 state->watch_stereo = 1;
596                         } else {
597                                 goto no_second;
598                         }
599                         break;
600                 case 2: /* 6.0 */
601                         /* PAL I NICAM */
602                         state->second = MSP_CARRIER(6.552);
603                         msp3400c_set_mode(client, MSP_MODE_FM_NICAM2);
604                         state->nicam_on = 1;
605                         state->watch_stereo = 1;
606                         break;
607                 case 3: /* 6.5 */
608                         if (max2 == 1 || max2 == 2) {
609                                 /* D/K FM-stereo */
610                                 state->second = msp3400c_carrier_detect_65[max2].cdo;
611                                 msp3400c_set_mode(client, MSP_MODE_FM_TERRA);
612                                 state->watch_stereo = 1;
613                         } else if (max2 == 0 && (state->v4l2_std & V4L2_STD_SECAM)) {
614                                 /* L NICAM or AM-mono */
615                                 state->second = msp3400c_carrier_detect_65[max2].cdo;
616                                 msp3400c_set_mode(client, MSP_MODE_AM_NICAM);
617                                 state->watch_stereo = 1;
618                         } else if (max2 == 0 && state->has_nicam) {
619                                 /* D/K NICAM */
620                                 state->second = msp3400c_carrier_detect_65[max2].cdo;
621                                 msp3400c_set_mode(client, MSP_MODE_FM_NICAM1);
622                                 state->nicam_on = 1;
623                                 state->watch_stereo = 1;
624                         } else {
625                                 goto no_second;
626                         }
627                         break;
628                 case 0: /* 4.5 */
629                 default:
630 no_second:
631                         state->second = msp3400c_carrier_detect_main[max1].cdo;
632                         msp3400c_set_mode(client, MSP_MODE_FM_TERRA);
633                         break;
634                 }
635                 msp3400c_set_carrier(client, state->second, state->main);
636
637                 /* unmute */
638                 state->scan_in_progress = 0;
639                 msp3400c_set_audmode(client);
640                 msp_set_audio(client);
641
642                 if (msp_debug)
643                         msp3400c_print_mode(client);
644
645                 /* monitor tv audio mode, the first time don't wait
646                    so long to get a quick stereo/bilingual result */
647                 count = 3;
648                 while (state->watch_stereo) {
649                         if (msp_sleep(state, count ? 1000 : 5000))
650                                 goto restart;
651                         if (count)
652                                 count--;
653                         watch_stereo(client);
654                 }
655         }
656         v4l_dbg(1, msp_debug, client, "thread: exit\n");
657         return 0;
658 }
659
660
661 int msp3410d_thread(void *data)
662 {
663         struct i2c_client *client = data;
664         struct msp_state *state = i2c_get_clientdata(client);
665         int val, i, std, count;
666
667         v4l_dbg(1, msp_debug, client, "msp3410 daemon started\n");
668         set_freezable();
669         for (;;) {
670                 v4l_dbg(2, msp_debug, client, "msp3410 thread: sleep\n");
671                 msp_sleep(state, -1);
672                 v4l_dbg(2, msp_debug, client, "msp3410 thread: wakeup\n");
673
674 restart:
675                 v4l_dbg(2, msp_debug, client, "thread: restart scan\n");
676                 state->restart = 0;
677                 if (kthread_should_stop())
678                         break;
679
680                 if (state->mode == MSP_MODE_EXTERN) {
681                         /* no carrier scan needed, just unmute */
682                         v4l_dbg(1, msp_debug, client,
683                                 "thread: no carrier scan\n");
684                         state->scan_in_progress = 0;
685                         msp_set_audio(client);
686                         continue;
687                 }
688
689                 /* mute audio */
690                 state->scan_in_progress = 1;
691                 msp_set_audio(client);
692
693                 /* start autodetect. Note: autodetect is not supported for
694                    NTSC-M and radio, hence we force the standard in those
695                    cases. */
696                 if (state->radio)
697                         std = 0x40;
698                 else
699                         std = (state->v4l2_std & V4L2_STD_NTSC) ? 0x20 : 1;
700                 state->watch_stereo = 0;
701                 state->nicam_on = 0;
702
703                 /* wait for tuner to settle down after a channel change */
704                 if (msp_sleep(state, 200))
705                         goto restart;
706
707                 if (msp_debug)
708                         v4l_dbg(2, msp_debug, client,
709                                 "setting standard: %s (0x%04x)\n",
710                                 msp_standard_std_name(std), std);
711
712                 if (std != 1) {
713                         /* programmed some specific mode */
714                         val = std;
715                 } else {
716                         /* triggered autodetect */
717                         msp_write_dem(client, 0x20, std);
718                         for (;;) {
719                                 if (msp_sleep(state, 100))
720                                         goto restart;
721
722                                 /* check results */
723                                 val = msp_read_dem(client, 0x7e);
724                                 if (val < 0x07ff)
725                                         break;
726                                 v4l_dbg(2, msp_debug, client,
727                                         "detection still in progress\n");
728                         }
729                 }
730                 for (i = 0; msp_stdlist[i].name != NULL; i++)
731                         if (msp_stdlist[i].retval == val)
732                                 break;
733                 v4l_dbg(1, msp_debug, client, "current standard: %s (0x%04x)\n",
734                         msp_standard_std_name(val), val);
735                 state->main   = msp_stdlist[i].main;
736                 state->second = msp_stdlist[i].second;
737                 state->std = val;
738                 state->rxsubchans = V4L2_TUNER_SUB_MONO;
739
740                 if (msp_amsound && !state->radio &&
741                     (state->v4l2_std & V4L2_STD_SECAM) && (val != 0x0009)) {
742                         /* autodetection has failed, let backup */
743                         v4l_dbg(1, msp_debug, client, "autodetection failed,"
744                                 " switching to backup standard: %s (0x%04x)\n",
745                                 msp_stdlist[8].name ?
746                                         msp_stdlist[8].name : "unknown", val);
747                         state->std = val = 0x0009;
748                         msp_write_dem(client, 0x20, val);
749                 }
750
751                 /* set stereo */
752                 switch (val) {
753                 case 0x0008: /* B/G NICAM */
754                 case 0x000a: /* I NICAM */
755                 case 0x000b: /* D/K NICAM */
756                         if (val == 0x000a)
757                                 state->mode = MSP_MODE_FM_NICAM2;
758                         else
759                                 state->mode = MSP_MODE_FM_NICAM1;
760                         /* just turn on stereo */
761                         state->nicam_on = 1;
762                         state->watch_stereo = 1;
763                         break;
764                 case 0x0009:
765                         state->mode = MSP_MODE_AM_NICAM;
766                         state->nicam_on = 1;
767                         state->watch_stereo = 1;
768                         break;
769                 case 0x0020: /* BTSC */
770                         /* The pre-'G' models only have BTSC-mono */
771                         state->mode = MSP_MODE_BTSC;
772                         break;
773                 case 0x0040: /* FM radio */
774                         state->mode = MSP_MODE_FM_RADIO;
775                         state->rxsubchans = V4L2_TUNER_SUB_STEREO;
776                         /* not needed in theory if we have radio, but
777                            short programming enables carrier mute */
778                         msp3400c_set_mode(client, MSP_MODE_FM_RADIO);
779                         msp3400c_set_carrier(client, MSP_CARRIER(10.7),
780                                             MSP_CARRIER(10.7));
781                         break;
782                 case 0x0002:
783                 case 0x0003:
784                 case 0x0004:
785                 case 0x0005:
786                         state->mode = MSP_MODE_FM_TERRA;
787                         state->watch_stereo = 1;
788                         break;
789                 }
790
791                 /* set various prescales */
792                 msp_write_dsp(client, 0x0d, 0x1900); /* scart */
793                 msp_write_dsp(client, 0x0e, 0x3000); /* FM */
794                 if (state->has_nicam)
795                         msp_write_dsp(client, 0x10, 0x5a00); /* nicam */
796
797                 if (state->has_i2s_conf)
798                         msp_write_dem(client, 0x40, state->i2s_mode);
799
800                 /* unmute */
801                 msp3400c_set_audmode(client);
802                 state->scan_in_progress = 0;
803                 msp_set_audio(client);
804
805                 /* monitor tv audio mode, the first time don't wait
806                    so long to get a quick stereo/bilingual result */
807                 count = 3;
808                 while (state->watch_stereo) {
809                         if (msp_sleep(state, count ? 1000 : 5000))
810                                 goto restart;
811                         if (count)
812                                 count--;
813                         watch_stereo(client);
814                 }
815         }
816         v4l_dbg(1, msp_debug, client, "thread: exit\n");
817         return 0;
818 }
819
820 /* ----------------------------------------------------------------------- */
821
822 /* msp34xxG + (autoselect no-thread)
823  * this one uses both automatic standard detection and automatic sound
824  * select which are available in the newer G versions
825  * struct msp: only norm, acb and source are really used in this mode
826  */
827
828 static int msp34xxg_modus(struct i2c_client *client)
829 {
830         struct msp_state *state = i2c_get_clientdata(client);
831
832         if (state->radio) {
833                 v4l_dbg(1, msp_debug, client, "selected radio modus\n");
834                 return 0x0001;
835         }
836         if (state->v4l2_std == V4L2_STD_NTSC_M_JP) {
837                 v4l_dbg(1, msp_debug, client, "selected M (EIA-J) modus\n");
838                 return 0x4001;
839         }
840         if (state->v4l2_std == V4L2_STD_NTSC_M_KR) {
841                 v4l_dbg(1, msp_debug, client, "selected M (A2) modus\n");
842                 return 0x0001;
843         }
844         if (state->v4l2_std == V4L2_STD_SECAM_L) {
845                 v4l_dbg(1, msp_debug, client, "selected SECAM-L modus\n");
846                 return 0x6001;
847         }
848         if (state->v4l2_std & V4L2_STD_MN) {
849                 v4l_dbg(1, msp_debug, client, "selected M (BTSC) modus\n");
850                 return 0x2001;
851         }
852         return 0x7001;
853 }
854
855 static void msp34xxg_set_source(struct i2c_client *client, u16 reg, int in)
856  {
857         struct msp_state *state = i2c_get_clientdata(client);
858         int source, matrix;
859
860         switch (state->audmode) {
861         case V4L2_TUNER_MODE_MONO:
862                 source = 0; /* mono only */
863                 matrix = 0x30;
864                 break;
865         case V4L2_TUNER_MODE_LANG2:
866                 source = 4; /* stereo or B */
867                 matrix = 0x10;
868                 break;
869         case V4L2_TUNER_MODE_LANG1_LANG2:
870                 source = 1; /* stereo or A|B */
871                 matrix = 0x20;
872                 break;
873         case V4L2_TUNER_MODE_LANG1:
874                 source = 3; /* stereo or A */
875                 matrix = 0x00;
876                 break;
877         case V4L2_TUNER_MODE_STEREO:
878         default:
879                 source = 3; /* stereo or A */
880                 matrix = 0x20;
881                 break;
882         }
883
884         if (in == MSP_DSP_IN_TUNER)
885                 source = (source << 8) | 0x20;
886         /* the msp34x2g puts the MAIN_AVC, MAIN and AUX sources in 12, 13, 14
887            instead of 11, 12, 13. So we add one for that msp version. */
888         else if (in >= MSP_DSP_IN_MAIN_AVC && state->has_dolby_pro_logic)
889                 source = ((in + 1) << 8) | matrix;
890         else
891                 source = (in << 8) | matrix;
892
893         v4l_dbg(1, msp_debug, client,
894                 "set source to %d (0x%x) for output %02x\n", in, source, reg);
895         msp_write_dsp(client, reg, source);
896 }
897
898 static void msp34xxg_set_sources(struct i2c_client *client)
899 {
900         struct msp_state *state = i2c_get_clientdata(client);
901         u32 in = state->routing.input;
902
903         msp34xxg_set_source(client, 0x0008, (in >> 4) & 0xf);
904         /* quasi-peak detector is set to same input as the loudspeaker (MAIN) */
905         msp34xxg_set_source(client, 0x000c, (in >> 4) & 0xf);
906         msp34xxg_set_source(client, 0x0009, (in >> 8) & 0xf);
907         msp34xxg_set_source(client, 0x000a, (in >> 12) & 0xf);
908         if (state->has_scart2_out)
909                 msp34xxg_set_source(client, 0x0041, (in >> 16) & 0xf);
910         msp34xxg_set_source(client, 0x000b, (in >> 20) & 0xf);
911 }
912
913 /* (re-)initialize the msp34xxg */
914 static void msp34xxg_reset(struct i2c_client *client)
915 {
916         struct msp_state *state = i2c_get_clientdata(client);
917         int tuner = (state->routing.input >> 3) & 1;
918         int modus;
919
920         /* initialize std to 1 (autodetect) to signal that no standard is
921            selected yet. */
922         state->std = 1;
923
924         msp_reset(client);
925
926         if (state->has_i2s_conf)
927                 msp_write_dem(client, 0x40, state->i2s_mode);
928
929         /* step-by-step initialisation, as described in the manual */
930         modus = msp34xxg_modus(client);
931         modus |= tuner ? 0x100 : 0;
932         msp_write_dem(client, 0x30, modus);
933
934         /* write the dsps that may have an influence on
935            standard/audio autodetection right now */
936         msp34xxg_set_sources(client);
937
938         msp_write_dsp(client, 0x0d, 0x1900); /* scart */
939         msp_write_dsp(client, 0x0e, 0x3000); /* FM */
940         if (state->has_nicam)
941                 msp_write_dsp(client, 0x10, 0x5a00); /* nicam */
942
943         /* set identification threshold. Personally, I
944          * I set it to a higher value than the default
945          * of 0x190 to ignore noisy stereo signals.
946          * this needs tuning. (recommended range 0x00a0-0x03c0)
947          * 0x7f0 = forced mono mode
948          *
949          * a2 threshold for stereo/bilingual.
950          * Note: this register is part of the Manual/Compatibility mode.
951          * It is supported by all 'G'-family chips.
952          */
953         msp_write_dem(client, 0x22, msp_stereo_thresh);
954 }
955
956 int msp34xxg_thread(void *data)
957 {
958         struct i2c_client *client = data;
959         struct msp_state *state = i2c_get_clientdata(client);
960         int val, i;
961
962         v4l_dbg(1, msp_debug, client, "msp34xxg daemon started\n");
963         set_freezable();
964         for (;;) {
965                 v4l_dbg(2, msp_debug, client, "msp34xxg thread: sleep\n");
966                 msp_sleep(state, -1);
967                 v4l_dbg(2, msp_debug, client, "msp34xxg thread: wakeup\n");
968
969 restart:
970                 v4l_dbg(1, msp_debug, client, "thread: restart scan\n");
971                 state->restart = 0;
972                 if (kthread_should_stop())
973                         break;
974
975                 if (state->mode == MSP_MODE_EXTERN) {
976                         /* no carrier scan needed, just unmute */
977                         v4l_dbg(1, msp_debug, client,
978                                 "thread: no carrier scan\n");
979                         state->scan_in_progress = 0;
980                         msp_set_audio(client);
981                         continue;
982                 }
983
984                 /* setup the chip*/
985                 msp34xxg_reset(client);
986                 state->std = state->radio ? 0x40 :
987                         (state->force_btsc && msp_standard == 1) ? 32 : msp_standard;
988                 msp_write_dem(client, 0x20, state->std);
989                 /* start autodetect */
990                 if (state->std != 1)
991                         goto unmute;
992
993                 /* watch autodetect */
994                 v4l_dbg(1, msp_debug, client,
995                         "started autodetect, waiting for result\n");
996                 for (i = 0; i < 10; i++) {
997                         if (msp_sleep(state, 100))
998                                 goto restart;
999
1000                         /* check results */
1001                         val = msp_read_dem(client, 0x7e);
1002                         if (val < 0x07ff) {
1003                                 state->std = val;
1004                                 break;
1005                         }
1006                         v4l_dbg(2, msp_debug, client,
1007                                 "detection still in progress\n");
1008                 }
1009                 if (state->std == 1) {
1010                         v4l_dbg(1, msp_debug, client,
1011                                 "detection still in progress after 10 tries. giving up.\n");
1012                         continue;
1013                 }
1014
1015 unmute:
1016                 v4l_dbg(1, msp_debug, client,
1017                         "detected standard: %s (0x%04x)\n",
1018                         msp_standard_std_name(state->std), state->std);
1019
1020                 if (state->std == 9) {
1021                         /* AM NICAM mode */
1022                         msp_write_dsp(client, 0x0e, 0x7c00);
1023                 }
1024
1025                 /* unmute: dispatch sound to scart output, set scart volume */
1026                 msp_set_audio(client);
1027
1028                 /* restore ACB */
1029                 if (msp_write_dsp(client, 0x13, state->acb))
1030                         return -1;
1031
1032                 /* the periodic stereo/SAP check is only relevant for
1033                    the 0x20 standard (BTSC) */
1034                 if (state->std != 0x20)
1035                         continue;
1036
1037                 state->watch_stereo = 1;
1038
1039                 /* monitor tv audio mode, the first time don't wait
1040                    in order to get a quick stereo/SAP update */
1041                 watch_stereo(client);
1042                 while (state->watch_stereo) {
1043                         watch_stereo(client);
1044                         if (msp_sleep(state, 5000))
1045                                 goto restart;
1046                 }
1047         }
1048         v4l_dbg(1, msp_debug, client, "thread: exit\n");
1049         return 0;
1050 }
1051
1052 static int msp34xxg_detect_stereo(struct i2c_client *client)
1053 {
1054         struct msp_state *state = i2c_get_clientdata(client);
1055         int status = msp_read_dem(client, 0x0200);
1056         int is_bilingual = status & 0x100;
1057         int is_stereo = status & 0x40;
1058         int oldrx = state->rxsubchans;
1059
1060         if (state->mode == MSP_MODE_EXTERN)
1061                 return 0;
1062
1063         state->rxsubchans = 0;
1064         if (is_stereo)
1065                 state->rxsubchans = V4L2_TUNER_SUB_STEREO;
1066         else
1067                 state->rxsubchans = V4L2_TUNER_SUB_MONO;
1068         if (is_bilingual) {
1069                 if (state->std == 0x20)
1070                         state->rxsubchans |= V4L2_TUNER_SUB_SAP;
1071                 else
1072                         state->rxsubchans =
1073                                 V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1074         }
1075         v4l_dbg(1, msp_debug, client,
1076                 "status=0x%x, stereo=%d, bilingual=%d -> rxsubchans=%d\n",
1077                 status, is_stereo, is_bilingual, state->rxsubchans);
1078         return (oldrx != state->rxsubchans);
1079 }
1080
1081 static void msp34xxg_set_audmode(struct i2c_client *client)
1082 {
1083         struct msp_state *state = i2c_get_clientdata(client);
1084
1085         if (state->std == 0x20) {
1086                if ((state->rxsubchans & V4L2_TUNER_SUB_SAP) &&
1087                    (state->audmode == V4L2_TUNER_MODE_LANG1_LANG2 ||
1088                     state->audmode == V4L2_TUNER_MODE_LANG2)) {
1089                         msp_write_dem(client, 0x20, 0x21);
1090                } else {
1091                         msp_write_dem(client, 0x20, 0x20);
1092                }
1093         }
1094
1095         msp34xxg_set_sources(client);
1096 }
1097
1098 void msp_set_audmode(struct i2c_client *client)
1099 {
1100         struct msp_state *state = i2c_get_clientdata(client);
1101
1102         switch (state->opmode) {
1103         case OPMODE_MANUAL:
1104         case OPMODE_AUTODETECT:
1105                 msp3400c_set_audmode(client);
1106                 break;
1107         case OPMODE_AUTOSELECT:
1108                 msp34xxg_set_audmode(client);
1109                 break;
1110         }
1111 }
1112
1113 int msp_detect_stereo(struct i2c_client *client)
1114 {
1115         struct msp_state *state  = i2c_get_clientdata(client);
1116
1117         switch (state->opmode) {
1118         case OPMODE_MANUAL:
1119         case OPMODE_AUTODETECT:
1120                 return msp3400c_detect_stereo(client);
1121         case OPMODE_AUTOSELECT:
1122                 return msp34xxg_detect_stereo(client);
1123         }
1124         return 0;
1125 }
1126