Commit | Line | Data |
---|---|---|
7e8b09ea HV |
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 | |
d52c7385 HV |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
19 | * 02110-1301, USA. | |
7e8b09ea HV |
20 | */ |
21 | ||
22 | ||
23 | #include <linux/kernel.h> | |
24 | #include <linux/module.h> | |
25 | #include <linux/slab.h> | |
26 | #include <linux/i2c.h> | |
83144186 | 27 | #include <linux/freezer.h> |
7e8b09ea HV |
28 | #include <linux/videodev.h> |
29 | #include <linux/videodev2.h> | |
30 | #include <media/v4l2-common.h> | |
49965a80 | 31 | #include <media/msp3400.h> |
7e8b09ea HV |
32 | #include <linux/kthread.h> |
33 | #include <linux/suspend.h> | |
49965a80 | 34 | #include "msp3400-driver.h" |
7e8b09ea HV |
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; | |
5af0c8f6 | 42 | } msp_stdlist[] = { |
7e8b09ea HV |
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)" }, | |
de533ccf | 50 | { 0x0007, MSP_CARRIER(6.5), MSP_CARRIER(5.7421875), "6.5/5.74 D/K3 Dual FM-Stereo" }, |
7e8b09ea HV |
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)" }, | |
de533ccf | 56 | { 0x000d, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85 D/K NICAM FM (HDEV3)" }, |
7e8b09ea HV |
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 | |
d52c7385 | 82 | }, { /* AM (for carrier detect / msp3410) */ |
7e8b09ea HV |
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 | |
d52c7385 | 87 | }, { /* FM Radio */ |
7e8b09ea HV |
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 | |
d52c7385 | 92 | }, { /* Terrestial FM-mono + FM-stereo */ |
7e8b09ea HV |
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 | |
d52c7385 | 97 | }, { /* Sat FM-mono */ |
7e8b09ea HV |
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 | |
d52c7385 | 102 | }, { /* NICAM/FM -- B/G (5.5/5.85), D/K (6.5/5.85) */ |
7e8b09ea HV |
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 | |
d52c7385 | 107 | }, { /* NICAM/FM -- I (6.0/6.552) */ |
7e8b09ea HV |
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 | |
d52c7385 | 112 | }, { /* NICAM/AM -- L (6.5/5.85) */ |
7e8b09ea HV |
113 | {-2, -8, -10, 10, 50, 86}, |
114 | {-4, -12, -9, 23, 79, 126}, | |
115 | MSP_CARRIER(6.5), MSP_CARRIER(6.5), | |
8a4b275f | 116 | 0x00c6, 0x0140, 0x0120, 0x7c00 |
7e8b09ea HV |
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 | ||
5af0c8f6 | 151 | const char *msp_standard_std_name(int std) |
7e8b09ea HV |
152 | { |
153 | int i; | |
154 | ||
5af0c8f6 HV |
155 | for (i = 0; msp_stdlist[i].name != NULL; i++) |
156 | if (msp_stdlist[i].retval == std) | |
157 | return msp_stdlist[i].name; | |
7e8b09ea HV |
158 | return "unknown"; |
159 | } | |
160 | ||
044f324f | 161 | static void msp_set_source(struct i2c_client *client, u16 src) |
8a4b275f HV |
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); | |
0020d3ef | 175 | if (state->has_scart2_out) |
8a4b275f HV |
176 | msp_write_dsp(client, 0x0041, src); |
177 | } | |
178 | ||
179 | void msp3400c_set_carrier(struct i2c_client *client, int cdo1, int cdo2) | |
7e8b09ea HV |
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); | |
8a4b275f | 185 | msp_write_dem(client, 0x0056, 0); /* LOAD_REG_1/2 */ |
7e8b09ea HV |
186 | } |
187 | ||
8a4b275f | 188 | void msp3400c_set_mode(struct i2c_client *client, int mode) |
7e8b09ea HV |
189 | { |
190 | struct msp_state *state = i2c_get_clientdata(client); | |
8a4b275f | 191 | struct msp3400c_init_data_dem *data = &msp3400c_init_data[mode]; |
2474ed44 | 192 | int tuner = (state->routing.input >> 3) & 1; |
7e8b09ea HV |
193 | int i; |
194 | ||
8a4b275f HV |
195 | v4l_dbg(1, msp_debug, client, "set_mode: %d\n", mode); |
196 | state->mode = mode; | |
7e8b09ea HV |
197 | state->rxsubchans = V4L2_TUNER_SUB_MONO; |
198 | ||
2474ed44 | 199 | msp_write_dem(client, 0x00bb, data->ad_cv | (tuner ? 0x100 : 0)); |
7e8b09ea HV |
200 | |
201 | for (i = 5; i >= 0; i--) /* fir 1 */ | |
8a4b275f | 202 | msp_write_dem(client, 0x0001, data->fir1[i]); |
7e8b09ea HV |
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--) | |
8a4b275f | 208 | msp_write_dem(client, 0x0005, data->fir2[i]); |
7e8b09ea | 209 | |
8a4b275f | 210 | msp_write_dem(client, 0x0083, data->mode_reg); |
7e8b09ea | 211 | |
8a4b275f | 212 | msp3400c_set_carrier(client, data->cdo1, data->cdo2); |
7e8b09ea | 213 | |
8a4b275f | 214 | msp_set_source(client, data->dsp_src); |
de533ccf | 215 | /* set prescales */ |
7e8b09ea | 216 | |
de533ccf HV |
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); | |
7e8b09ea HV |
222 | } |
223 | ||
8a4b275f HV |
224 | /* Set audio mode. Note that the pre-'G' models do not support BTSC+SAP, |
225 | nor do they support stereo BTSC. */ | |
044f324f | 226 | static void msp3400c_set_audmode(struct i2c_client *client) |
7e8b09ea | 227 | { |
d52c7385 HV |
228 | static char *strmode[] = { |
229 | "mono", "stereo", "lang2", "lang1", "lang1+lang2" | |
230 | }; | |
7e8b09ea | 231 | struct msp_state *state = i2c_get_clientdata(client); |
301e22d6 | 232 | char *modestr = (state->audmode >= 0 && state->audmode < 5) ? |
8a4b275f HV |
233 | strmode[state->audmode] : "unknown"; |
234 | int src = 0; /* channel source: FM/AM, nicam or SCART */ | |
7061561e | 235 | int audmode = state->audmode; |
7e8b09ea HV |
236 | |
237 | if (state->opmode == OPMODE_AUTOSELECT) { | |
238 | /* this method would break everything, let's make sure | |
239 | * it's never called | |
240 | */ | |
8a4b275f HV |
241 | v4l_dbg(1, msp_debug, client, |
242 | "set_audmode called with mode=%d instead of set_source (ignored)\n", | |
243 | state->audmode); | |
7e8b09ea HV |
244 | return; |
245 | } | |
246 | ||
0020d3ef HV |
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 | ||
2eb606db HV |
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; | |
0020d3ef | 265 | } |
7061561e | 266 | |
7e8b09ea HV |
267 | /* switch demodulator */ |
268 | switch (state->mode) { | |
269 | case MSP_MODE_FM_TERRA: | |
8a4b275f | 270 | v4l_dbg(1, msp_debug, client, "FM set_audmode: %s\n", modestr); |
7061561e | 271 | switch (audmode) { |
7e8b09ea HV |
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: | |
301e22d6 | 278 | case V4L2_TUNER_MODE_LANG1_LANG2: |
7e8b09ea HV |
279 | msp_write_dsp(client, 0x000e, 0x3000); |
280 | break; | |
281 | } | |
282 | break; | |
283 | case MSP_MODE_FM_SAT: | |
8a4b275f | 284 | v4l_dbg(1, msp_debug, client, "SAT set_audmode: %s\n", modestr); |
7061561e | 285 | switch (audmode) { |
7e8b09ea | 286 | case V4L2_TUNER_MODE_MONO: |
8a4b275f | 287 | msp3400c_set_carrier(client, MSP_CARRIER(6.5), MSP_CARRIER(6.5)); |
7e8b09ea HV |
288 | break; |
289 | case V4L2_TUNER_MODE_STEREO: | |
301e22d6 | 290 | case V4L2_TUNER_MODE_LANG1_LANG2: |
8a4b275f | 291 | msp3400c_set_carrier(client, MSP_CARRIER(7.2), MSP_CARRIER(7.02)); |
7e8b09ea HV |
292 | break; |
293 | case V4L2_TUNER_MODE_LANG1: | |
8a4b275f | 294 | msp3400c_set_carrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02)); |
7e8b09ea HV |
295 | break; |
296 | case V4L2_TUNER_MODE_LANG2: | |
8a4b275f | 297 | msp3400c_set_carrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02)); |
7e8b09ea HV |
298 | break; |
299 | } | |
300 | break; | |
301 | case MSP_MODE_FM_NICAM1: | |
302 | case MSP_MODE_FM_NICAM2: | |
303 | case MSP_MODE_AM_NICAM: | |
d52c7385 HV |
304 | v4l_dbg(1, msp_debug, client, |
305 | "NICAM set_audmode: %s\n", modestr); | |
7e8b09ea | 306 | if (state->nicam_on) |
8a4b275f | 307 | src = 0x0100; /* NICAM */ |
7e8b09ea HV |
308 | break; |
309 | case MSP_MODE_BTSC: | |
d52c7385 HV |
310 | v4l_dbg(1, msp_debug, client, |
311 | "BTSC set_audmode: %s\n", modestr); | |
7e8b09ea HV |
312 | break; |
313 | case MSP_MODE_EXTERN: | |
d52c7385 HV |
314 | v4l_dbg(1, msp_debug, client, |
315 | "extern set_audmode: %s\n", modestr); | |
8a4b275f | 316 | src = 0x0200; /* SCART */ |
7e8b09ea HV |
317 | break; |
318 | case MSP_MODE_FM_RADIO: | |
d52c7385 HV |
319 | v4l_dbg(1, msp_debug, client, |
320 | "FM-Radio set_audmode: %s\n", modestr); | |
7e8b09ea HV |
321 | break; |
322 | default: | |
8a4b275f | 323 | v4l_dbg(1, msp_debug, client, "mono set_audmode\n"); |
7e8b09ea HV |
324 | return; |
325 | } | |
326 | ||
327 | /* switch audio */ | |
0020d3ef | 328 | v4l_dbg(1, msp_debug, client, "set audmode %d\n", audmode); |
7061561e | 329 | switch (audmode) { |
7e8b09ea | 330 | case V4L2_TUNER_MODE_STEREO: |
301e22d6 | 331 | case V4L2_TUNER_MODE_LANG1_LANG2: |
8a4b275f | 332 | src |= 0x0020; |
7e8b09ea HV |
333 | break; |
334 | case V4L2_TUNER_MODE_MONO: | |
335 | if (state->mode == MSP_MODE_AM_NICAM) { | |
f167cb4e | 336 | v4l_dbg(1, msp_debug, client, "switching to AM mono\n"); |
7e8b09ea HV |
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 | } | |
8a4b275f HV |
343 | if (state->rxsubchans & V4L2_TUNER_SUB_STEREO) |
344 | src = 0x0030; | |
345 | break; | |
7e8b09ea | 346 | case V4L2_TUNER_MODE_LANG1: |
7e8b09ea HV |
347 | break; |
348 | case V4L2_TUNER_MODE_LANG2: | |
8a4b275f | 349 | src |= 0x0010; |
7e8b09ea HV |
350 | break; |
351 | } | |
d52c7385 HV |
352 | v4l_dbg(1, msp_debug, client, |
353 | "set_audmode final source/matrix = 0x%x\n", src); | |
7e8b09ea | 354 | |
8a4b275f | 355 | msp_set_source(client, src); |
7e8b09ea HV |
356 | } |
357 | ||
358 | static void msp3400c_print_mode(struct i2c_client *client) | |
359 | { | |
360 | struct msp_state *state = i2c_get_clientdata(client); | |
361 | ||
d52c7385 HV |
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); | |
7e8b09ea | 370 | if (state->mode == MSP_MODE_FM_NICAM1 || state->mode == MSP_MODE_FM_NICAM2) |
d52c7385 HV |
371 | v4l_dbg(1, msp_debug, client, |
372 | "NICAM/FM carrier : %d.%03d MHz\n", | |
373 | state->second / 910000, (state->second/910) % 1000); | |
7e8b09ea | 374 | if (state->mode == MSP_MODE_AM_NICAM) |
d52c7385 HV |
375 | v4l_dbg(1, msp_debug, client, |
376 | "NICAM/AM carrier : %d.%03d MHz\n", | |
377 | state->second / 910000, (state->second / 910) % 1000); | |
7e8b09ea | 378 | if (state->mode == MSP_MODE_FM_TERRA && state->main != state->second) { |
d52c7385 HV |
379 | v4l_dbg(1, msp_debug, client, |
380 | "FM-stereo carrier : %d.%03d MHz\n", | |
381 | state->second / 910000, (state->second / 910) % 1000); | |
7e8b09ea HV |
382 | } |
383 | } | |
384 | ||
385 | /* ----------------------------------------------------------------------- */ | |
386 | ||
8a4b275f | 387 | static int msp3400c_detect_stereo(struct i2c_client *client) |
7e8b09ea HV |
388 | { |
389 | struct msp_state *state = i2c_get_clientdata(client); | |
390 | int val; | |
391 | int rxsubchans = state->rxsubchans; | |
8a4b275f | 392 | int newnicam = state->nicam_on; |
7e8b09ea HV |
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; | |
d52c7385 HV |
400 | v4l_dbg(2, msp_debug, client, |
401 | "stereo detect register: %d\n", val); | |
3bbe5a83 | 402 | if (val > 8192) { |
8a4b275f | 403 | rxsubchans = V4L2_TUNER_SUB_STEREO; |
7e8b09ea HV |
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); | |
f167cb4e | 415 | v4l_dbg(2, msp_debug, client, "nicam sync=%d, mode=%d\n", |
7e8b09ea HV |
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: | |
8a4b275f | 427 | rxsubchans = V4L2_TUNER_SUB_MONO; |
7e8b09ea HV |
428 | break; |
429 | case 2: | |
430 | case 10: | |
8a4b275f | 431 | rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; |
7e8b09ea HV |
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; | |
7e8b09ea HV |
443 | } |
444 | if (rxsubchans != state->rxsubchans) { | |
445 | update = 1; | |
d52c7385 HV |
446 | v4l_dbg(1, msp_debug, client, |
447 | "watch: rxsubchans %02x => %02x\n", | |
8a4b275f | 448 | state->rxsubchans, rxsubchans); |
7e8b09ea HV |
449 | state->rxsubchans = rxsubchans; |
450 | } | |
451 | if (newnicam != state->nicam_on) { | |
452 | update = 1; | |
f167cb4e | 453 | v4l_dbg(1, msp_debug, client, "watch: nicam %d => %d\n", |
8a4b275f | 454 | state->nicam_on, newnicam); |
7e8b09ea HV |
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 | ||
d52c7385 | 469 | if (msp_detect_stereo(client)) |
de533ccf | 470 | msp_set_audmode(client); |
7e8b09ea | 471 | |
f167cb4e | 472 | if (msp_once) |
7e8b09ea HV |
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; | |
d52c7385 | 481 | int count, max1, max2, val1, val2, val, i; |
7e8b09ea HV |
482 | |
483 | ||
f167cb4e | 484 | v4l_dbg(1, msp_debug, client, "msp3400 daemon started\n"); |
83144186 | 485 | set_freezable(); |
7e8b09ea | 486 | for (;;) { |
f167cb4e | 487 | v4l_dbg(2, msp_debug, client, "msp3400 thread: sleep\n"); |
7e8b09ea | 488 | msp_sleep(state, -1); |
f167cb4e | 489 | v4l_dbg(2, msp_debug, client, "msp3400 thread: wakeup\n"); |
7e8b09ea | 490 | |
d52c7385 | 491 | restart: |
8a4b275f | 492 | v4l_dbg(2, msp_debug, client, "thread: restart scan\n"); |
7e8b09ea HV |
493 | state->restart = 0; |
494 | if (kthread_should_stop()) | |
495 | break; | |
496 | ||
7560d7a4 | 497 | if (state->radio || MSP_MODE_EXTERN == state->mode) { |
7e8b09ea | 498 | /* no carrier scan, just unmute */ |
d52c7385 HV |
499 | v4l_dbg(1, msp_debug, client, |
500 | "thread: no carrier scan\n"); | |
3bbe5a83 | 501 | state->scan_in_progress = 0; |
7e8b09ea HV |
502 | msp_set_audio(client); |
503 | continue; | |
504 | } | |
505 | ||
3bbe5a83 HV |
506 | /* mute audio */ |
507 | state->scan_in_progress = 1; | |
508 | msp_set_audio(client); | |
0020d3ef | 509 | |
de533ccf | 510 | msp3400c_set_mode(client, MSP_MODE_AM_DETECT); |
7e8b09ea HV |
511 | val1 = val2 = 0; |
512 | max1 = max2 = -1; | |
513 | state->watch_stereo = 0; | |
8a4b275f | 514 | state->nicam_on = 0; |
7e8b09ea | 515 | |
3bbe5a83 | 516 | /* wait for tuner to settle down after a channel change */ |
8a4b275f | 517 | if (msp_sleep(state, 200)) |
7e8b09ea HV |
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 | ||
f167cb4e | 524 | if (msp_amsound && (state->v4l2_std & V4L2_STD_SECAM)) { |
7e8b09ea HV |
525 | /* autodetect doesn't work well with AM ... */ |
526 | max1 = 3; | |
527 | count = 0; | |
f167cb4e | 528 | v4l_dbg(1, msp_debug, client, "AM sound override\n"); |
7e8b09ea HV |
529 | } |
530 | ||
d52c7385 HV |
531 | for (i = 0; i < count; i++) { |
532 | msp3400c_set_carrier(client, cd[i].cdo, cd[i].cdo); | |
533 | if (msp_sleep(state, 100)) | |
7e8b09ea HV |
534 | goto restart; |
535 | val = msp_read_dsp(client, 0x1b); | |
536 | if (val > 32767) | |
537 | val -= 65536; | |
538 | if (val1 < val) | |
d52c7385 HV |
539 | val1 = val, max1 = i; |
540 | v4l_dbg(1, msp_debug, client, | |
541 | "carrier1 val: %5d / %s\n", val, cd[i].name); | |
7e8b09ea HV |
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 | ||
f167cb4e | 562 | if (msp_amsound && (state->v4l2_std & V4L2_STD_SECAM)) { |
7e8b09ea HV |
563 | /* autodetect doesn't work well with AM ... */ |
564 | cd = NULL; | |
565 | count = 0; | |
566 | max2 = 0; | |
567 | } | |
d52c7385 HV |
568 | for (i = 0; i < count; i++) { |
569 | msp3400c_set_carrier(client, cd[i].cdo, cd[i].cdo); | |
570 | if (msp_sleep(state, 100)) | |
7e8b09ea HV |
571 | goto restart; |
572 | val = msp_read_dsp(client, 0x1b); | |
573 | if (val > 32767) | |
574 | val -= 65536; | |
575 | if (val2 < val) | |
d52c7385 HV |
576 | val2 = val, max2 = i; |
577 | v4l_dbg(1, msp_debug, client, | |
578 | "carrier2 val: %5d / %s\n", val, cd[i].name); | |
7e8b09ea HV |
579 | } |
580 | ||
581 | /* program the msp3400 according to the results */ | |
8a4b275f | 582 | state->main = msp3400c_carrier_detect_main[max1].cdo; |
7e8b09ea HV |
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; | |
8a4b275f | 588 | msp3400c_set_mode(client, MSP_MODE_FM_TERRA); |
7e8b09ea | 589 | state->watch_stereo = 1; |
7560d7a4 | 590 | } else if (max2 == 1 && state->has_nicam) { |
7e8b09ea HV |
591 | /* B/G NICAM */ |
592 | state->second = msp3400c_carrier_detect_55[max2].cdo; | |
8a4b275f | 593 | msp3400c_set_mode(client, MSP_MODE_FM_NICAM1); |
7e8b09ea | 594 | state->nicam_on = 1; |
7e8b09ea HV |
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); | |
8a4b275f | 603 | msp3400c_set_mode(client, MSP_MODE_FM_NICAM2); |
7e8b09ea | 604 | state->nicam_on = 1; |
7e8b09ea HV |
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; | |
8a4b275f | 611 | msp3400c_set_mode(client, MSP_MODE_FM_TERRA); |
7e8b09ea | 612 | state->watch_stereo = 1; |
5af0c8f6 | 613 | } else if (max2 == 0 && (state->v4l2_std & V4L2_STD_SECAM)) { |
7e8b09ea HV |
614 | /* L NICAM or AM-mono */ |
615 | state->second = msp3400c_carrier_detect_65[max2].cdo; | |
8a4b275f | 616 | msp3400c_set_mode(client, MSP_MODE_AM_NICAM); |
7e8b09ea | 617 | state->watch_stereo = 1; |
7560d7a4 | 618 | } else if (max2 == 0 && state->has_nicam) { |
7e8b09ea HV |
619 | /* D/K NICAM */ |
620 | state->second = msp3400c_carrier_detect_65[max2].cdo; | |
8a4b275f | 621 | msp3400c_set_mode(client, MSP_MODE_FM_NICAM1); |
7e8b09ea | 622 | state->nicam_on = 1; |
7e8b09ea HV |
623 | state->watch_stereo = 1; |
624 | } else { | |
625 | goto no_second; | |
626 | } | |
627 | break; | |
628 | case 0: /* 4.5 */ | |
629 | default: | |
d52c7385 | 630 | no_second: |
7e8b09ea | 631 | state->second = msp3400c_carrier_detect_main[max1].cdo; |
8a4b275f | 632 | msp3400c_set_mode(client, MSP_MODE_FM_TERRA); |
7e8b09ea HV |
633 | break; |
634 | } | |
0020d3ef | 635 | msp3400c_set_carrier(client, state->second, state->main); |
7e8b09ea | 636 | |
3bbe5a83 HV |
637 | /* unmute */ |
638 | state->scan_in_progress = 0; | |
8a4b275f | 639 | msp3400c_set_audmode(client); |
3bbe5a83 | 640 | msp_set_audio(client); |
7e8b09ea | 641 | |
f167cb4e | 642 | if (msp_debug) |
7e8b09ea HV |
643 | msp3400c_print_mode(client); |
644 | ||
8a4b275f HV |
645 | /* monitor tv audio mode, the first time don't wait |
646 | so long to get a quick stereo/bilingual result */ | |
3bbe5a83 | 647 | count = 3; |
7e8b09ea | 648 | while (state->watch_stereo) { |
3bbe5a83 | 649 | if (msp_sleep(state, count ? 1000 : 5000)) |
7e8b09ea | 650 | goto restart; |
d52c7385 HV |
651 | if (count) |
652 | count--; | |
3bbe5a83 | 653 | watch_stereo(client); |
7e8b09ea HV |
654 | } |
655 | } | |
f167cb4e | 656 | v4l_dbg(1, msp_debug, client, "thread: exit\n"); |
7e8b09ea HV |
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); | |
0020d3ef | 665 | int val, i, std, count; |
7e8b09ea | 666 | |
f167cb4e | 667 | v4l_dbg(1, msp_debug, client, "msp3410 daemon started\n"); |
83144186 | 668 | set_freezable(); |
7e8b09ea | 669 | for (;;) { |
f167cb4e | 670 | v4l_dbg(2, msp_debug, client, "msp3410 thread: sleep\n"); |
d52c7385 | 671 | msp_sleep(state, -1); |
f167cb4e | 672 | v4l_dbg(2, msp_debug, client, "msp3410 thread: wakeup\n"); |
7e8b09ea | 673 | |
d52c7385 | 674 | restart: |
8a4b275f | 675 | v4l_dbg(2, msp_debug, client, "thread: restart scan\n"); |
7e8b09ea HV |
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 */ | |
d52c7385 HV |
682 | v4l_dbg(1, msp_debug, client, |
683 | "thread: no carrier scan\n"); | |
3bbe5a83 | 684 | state->scan_in_progress = 0; |
7e8b09ea HV |
685 | msp_set_audio(client); |
686 | continue; | |
687 | } | |
688 | ||
3bbe5a83 HV |
689 | /* mute audio */ |
690 | state->scan_in_progress = 1; | |
691 | msp_set_audio(client); | |
7e8b09ea | 692 | |
de533ccf | 693 | /* start autodetect. Note: autodetect is not supported for |
d52c7385 HV |
694 | NTSC-M and radio, hence we force the standard in those |
695 | cases. */ | |
5af0c8f6 HV |
696 | if (state->radio) |
697 | std = 0x40; | |
d312a46e | 698 | else |
5af0c8f6 | 699 | std = (state->v4l2_std & V4L2_STD_NTSC) ? 0x20 : 1; |
7e8b09ea | 700 | state->watch_stereo = 0; |
8a4b275f | 701 | state->nicam_on = 0; |
7e8b09ea | 702 | |
3bbe5a83 HV |
703 | /* wait for tuner to settle down after a channel change */ |
704 | if (msp_sleep(state, 200)) | |
705 | goto restart; | |
706 | ||
f167cb4e | 707 | if (msp_debug) |
d52c7385 HV |
708 | v4l_dbg(2, msp_debug, client, |
709 | "setting standard: %s (0x%04x)\n", | |
710 | msp_standard_std_name(std), std); | |
7e8b09ea HV |
711 | |
712 | if (std != 1) { | |
713 | /* programmed some specific mode */ | |
714 | val = std; | |
715 | } else { | |
716 | /* triggered autodetect */ | |
5af0c8f6 | 717 | msp_write_dem(client, 0x20, std); |
7e8b09ea | 718 | for (;;) { |
d312a46e | 719 | if (msp_sleep(state, 100)) |
7e8b09ea HV |
720 | goto restart; |
721 | ||
722 | /* check results */ | |
723 | val = msp_read_dem(client, 0x7e); | |
724 | if (val < 0x07ff) | |
725 | break; | |
d52c7385 HV |
726 | v4l_dbg(2, msp_debug, client, |
727 | "detection still in progress\n"); | |
7e8b09ea HV |
728 | } |
729 | } | |
5af0c8f6 HV |
730 | for (i = 0; msp_stdlist[i].name != NULL; i++) |
731 | if (msp_stdlist[i].retval == val) | |
7e8b09ea | 732 | break; |
f167cb4e | 733 | v4l_dbg(1, msp_debug, client, "current standard: %s (0x%04x)\n", |
5af0c8f6 HV |
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; | |
3bbe5a83 | 738 | state->rxsubchans = V4L2_TUNER_SUB_MONO; |
5af0c8f6 | 739 | |
d52c7385 HV |
740 | if (msp_amsound && !state->radio && |
741 | (state->v4l2_std & V4L2_STD_SECAM) && (val != 0x0009)) { | |
7e8b09ea | 742 | /* autodetection has failed, let backup */ |
f167cb4e | 743 | v4l_dbg(1, msp_debug, client, "autodetection failed," |
5af0c8f6 | 744 | " switching to backup standard: %s (0x%04x)\n", |
d52c7385 HV |
745 | msp_stdlist[8].name ? |
746 | msp_stdlist[8].name : "unknown", val); | |
de533ccf | 747 | state->std = val = 0x0009; |
7e8b09ea HV |
748 | msp_write_dem(client, 0x20, val); |
749 | } | |
750 | ||
7e8b09ea HV |
751 | /* set stereo */ |
752 | switch (val) { | |
753 | case 0x0008: /* B/G NICAM */ | |
754 | case 0x000a: /* I NICAM */ | |
de533ccf HV |
755 | case 0x000b: /* D/K NICAM */ |
756 | if (val == 0x000a) | |
7e8b09ea | 757 | state->mode = MSP_MODE_FM_NICAM2; |
de533ccf HV |
758 | else |
759 | state->mode = MSP_MODE_FM_NICAM1; | |
7e8b09ea | 760 | /* just turn on stereo */ |
7e8b09ea HV |
761 | state->nicam_on = 1; |
762 | state->watch_stereo = 1; | |
7e8b09ea HV |
763 | break; |
764 | case 0x0009: | |
765 | state->mode = MSP_MODE_AM_NICAM; | |
7e8b09ea | 766 | state->nicam_on = 1; |
7e8b09ea HV |
767 | state->watch_stereo = 1; |
768 | break; | |
769 | case 0x0020: /* BTSC */ | |
8a4b275f | 770 | /* The pre-'G' models only have BTSC-mono */ |
7e8b09ea | 771 | state->mode = MSP_MODE_BTSC; |
7e8b09ea HV |
772 | break; |
773 | case 0x0040: /* FM radio */ | |
7560d7a4 | 774 | state->mode = MSP_MODE_FM_RADIO; |
7e8b09ea | 775 | state->rxsubchans = V4L2_TUNER_SUB_STEREO; |
7560d7a4 | 776 | /* not needed in theory if we have radio, but |
7e8b09ea | 777 | short programming enables carrier mute */ |
8a4b275f HV |
778 | msp3400c_set_mode(client, MSP_MODE_FM_RADIO); |
779 | msp3400c_set_carrier(client, MSP_CARRIER(10.7), | |
7e8b09ea | 780 | MSP_CARRIER(10.7)); |
7e8b09ea | 781 | break; |
de533ccf | 782 | case 0x0002: |
7e8b09ea HV |
783 | case 0x0003: |
784 | case 0x0004: | |
785 | case 0x0005: | |
5af0c8f6 | 786 | state->mode = MSP_MODE_FM_TERRA; |
7e8b09ea HV |
787 | state->watch_stereo = 1; |
788 | break; | |
789 | } | |
790 | ||
de533ccf HV |
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 | ||
5af0c8f6 HV |
797 | if (state->has_i2s_conf) |
798 | msp_write_dem(client, 0x40, state->i2s_mode); | |
7e8b09ea | 799 | |
3bbe5a83 | 800 | /* unmute */ |
8a4b275f | 801 | msp3400c_set_audmode(client); |
3bbe5a83 HV |
802 | state->scan_in_progress = 0; |
803 | msp_set_audio(client); | |
8a4b275f HV |
804 | |
805 | /* monitor tv audio mode, the first time don't wait | |
806 | so long to get a quick stereo/bilingual result */ | |
3bbe5a83 | 807 | count = 3; |
7e8b09ea | 808 | while (state->watch_stereo) { |
3bbe5a83 | 809 | if (msp_sleep(state, count ? 1000 : 5000)) |
8a4b275f | 810 | goto restart; |
d52c7385 HV |
811 | if (count) |
812 | count--; | |
3bbe5a83 | 813 | watch_stereo(client); |
7e8b09ea HV |
814 | } |
815 | } | |
f167cb4e | 816 | v4l_dbg(1, msp_debug, client, "thread: exit\n"); |
7e8b09ea HV |
817 | return 0; |
818 | } | |
819 | ||
820 | /* ----------------------------------------------------------------------- */ | |
821 | ||
de533ccf HV |
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 | */ | |
7e8b09ea | 827 | |
9a80a93d HV |
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 | ||
837 | if (state->v4l2_std & V4L2_STD_PAL) { | |
838 | v4l_dbg(1, msp_debug, client, "selected PAL modus\n"); | |
839 | return 0x7001; | |
840 | } | |
841 | if (state->v4l2_std == V4L2_STD_NTSC_M_JP) { | |
842 | v4l_dbg(1, msp_debug, client, "selected M (EIA-J) modus\n"); | |
843 | return 0x4001; | |
844 | } | |
845 | if (state->v4l2_std == V4L2_STD_NTSC_M_KR) { | |
846 | v4l_dbg(1, msp_debug, client, "selected M (A2) modus\n"); | |
847 | return 0x0001; | |
848 | } | |
849 | if (state->v4l2_std & V4L2_STD_MN) { | |
850 | v4l_dbg(1, msp_debug, client, "selected M (BTSC) modus\n"); | |
851 | return 0x2001; | |
852 | } | |
853 | if (state->v4l2_std & V4L2_STD_SECAM) { | |
854 | v4l_dbg(1, msp_debug, client, "selected SECAM modus\n"); | |
855 | return 0x6001; | |
856 | } | |
857 | return 0x0001; | |
858 | } | |
859 | ||
2474ed44 HV |
860 | static void msp34xxg_set_source(struct i2c_client *client, u16 reg, int in) |
861 | { | |
862 | struct msp_state *state = i2c_get_clientdata(client); | |
863 | int source, matrix; | |
864 | ||
865 | switch (state->audmode) { | |
866 | case V4L2_TUNER_MODE_MONO: | |
867 | source = 0; /* mono only */ | |
868 | matrix = 0x30; | |
869 | break; | |
2474ed44 HV |
870 | case V4L2_TUNER_MODE_LANG2: |
871 | source = 4; /* stereo or B */ | |
872 | matrix = 0x10; | |
873 | break; | |
301e22d6 | 874 | case V4L2_TUNER_MODE_LANG1_LANG2: |
2474ed44 HV |
875 | source = 1; /* stereo or A|B */ |
876 | matrix = 0x20; | |
877 | break; | |
0020d3ef | 878 | case V4L2_TUNER_MODE_LANG1: |
0020d3ef HV |
879 | source = 3; /* stereo or A */ |
880 | matrix = 0x00; | |
881 | break; | |
b331def2 HV |
882 | case V4L2_TUNER_MODE_STEREO: |
883 | default: | |
884 | source = 3; /* stereo or A */ | |
885 | matrix = 0x20; | |
886 | break; | |
2474ed44 HV |
887 | } |
888 | ||
07151724 | 889 | if (in == MSP_DSP_IN_TUNER) |
2474ed44 HV |
890 | source = (source << 8) | 0x20; |
891 | /* the msp34x2g puts the MAIN_AVC, MAIN and AUX sources in 12, 13, 14 | |
892 | instead of 11, 12, 13. So we add one for that msp version. */ | |
07151724 | 893 | else if (in >= MSP_DSP_IN_MAIN_AVC && state->has_dolby_pro_logic) |
2474ed44 HV |
894 | source = ((in + 1) << 8) | matrix; |
895 | else | |
896 | source = (in << 8) | matrix; | |
897 | ||
d52c7385 HV |
898 | v4l_dbg(1, msp_debug, client, |
899 | "set source to %d (0x%x) for output %02x\n", in, source, reg); | |
2474ed44 HV |
900 | msp_write_dsp(client, reg, source); |
901 | } | |
902 | ||
903 | static void msp34xxg_set_sources(struct i2c_client *client) | |
904 | { | |
905 | struct msp_state *state = i2c_get_clientdata(client); | |
906 | u32 in = state->routing.input; | |
907 | ||
908 | msp34xxg_set_source(client, 0x0008, (in >> 4) & 0xf); | |
909 | /* quasi-peak detector is set to same input as the loudspeaker (MAIN) */ | |
910 | msp34xxg_set_source(client, 0x000c, (in >> 4) & 0xf); | |
911 | msp34xxg_set_source(client, 0x0009, (in >> 8) & 0xf); | |
912 | msp34xxg_set_source(client, 0x000a, (in >> 12) & 0xf); | |
0020d3ef | 913 | if (state->has_scart2_out) |
2474ed44 HV |
914 | msp34xxg_set_source(client, 0x0041, (in >> 16) & 0xf); |
915 | msp34xxg_set_source(client, 0x000b, (in >> 20) & 0xf); | |
916 | } | |
917 | ||
de533ccf HV |
918 | /* (re-)initialize the msp34xxg */ |
919 | static void msp34xxg_reset(struct i2c_client *client) | |
7e8b09ea HV |
920 | { |
921 | struct msp_state *state = i2c_get_clientdata(client); | |
2474ed44 | 922 | int tuner = (state->routing.input >> 3) & 1; |
de533ccf | 923 | int modus; |
7e8b09ea | 924 | |
de533ccf HV |
925 | /* initialize std to 1 (autodetect) to signal that no standard is |
926 | selected yet. */ | |
927 | state->std = 1; | |
928 | ||
929 | msp_reset(client); | |
7e8b09ea | 930 | |
5af0c8f6 HV |
931 | if (state->has_i2s_conf) |
932 | msp_write_dem(client, 0x40, state->i2s_mode); | |
7e8b09ea HV |
933 | |
934 | /* step-by-step initialisation, as described in the manual */ | |
9a80a93d | 935 | modus = msp34xxg_modus(client); |
2474ed44 | 936 | modus |= tuner ? 0x100 : 0; |
de533ccf | 937 | msp_write_dem(client, 0x30, modus); |
7e8b09ea HV |
938 | |
939 | /* write the dsps that may have an influence on | |
940 | standard/audio autodetection right now */ | |
2474ed44 | 941 | msp34xxg_set_sources(client); |
7e8b09ea | 942 | |
de533ccf HV |
943 | msp_write_dsp(client, 0x0d, 0x1900); /* scart */ |
944 | msp_write_dsp(client, 0x0e, 0x3000); /* FM */ | |
945 | if (state->has_nicam) | |
946 | msp_write_dsp(client, 0x10, 0x5a00); /* nicam */ | |
7e8b09ea | 947 | |
de533ccf HV |
948 | /* set identification threshold. Personally, I |
949 | * I set it to a higher value than the default | |
950 | * of 0x190 to ignore noisy stereo signals. | |
951 | * this needs tuning. (recommended range 0x00a0-0x03c0) | |
952 | * 0x7f0 = forced mono mode | |
953 | * | |
954 | * a2 threshold for stereo/bilingual. | |
955 | * Note: this register is part of the Manual/Compatibility mode. | |
956 | * It is supported by all 'G'-family chips. | |
957 | */ | |
958 | msp_write_dem(client, 0x22, msp_stereo_thresh); | |
7e8b09ea HV |
959 | } |
960 | ||
961 | int msp34xxg_thread(void *data) | |
962 | { | |
963 | struct i2c_client *client = data; | |
964 | struct msp_state *state = i2c_get_clientdata(client); | |
de533ccf | 965 | int val, i; |
7e8b09ea | 966 | |
f167cb4e | 967 | v4l_dbg(1, msp_debug, client, "msp34xxg daemon started\n"); |
83144186 | 968 | set_freezable(); |
7e8b09ea | 969 | for (;;) { |
f167cb4e | 970 | v4l_dbg(2, msp_debug, client, "msp34xxg thread: sleep\n"); |
7e8b09ea | 971 | msp_sleep(state, -1); |
f167cb4e | 972 | v4l_dbg(2, msp_debug, client, "msp34xxg thread: wakeup\n"); |
7e8b09ea | 973 | |
d52c7385 | 974 | restart: |
f167cb4e | 975 | v4l_dbg(1, msp_debug, client, "thread: restart scan\n"); |
7e8b09ea HV |
976 | state->restart = 0; |
977 | if (kthread_should_stop()) | |
978 | break; | |
979 | ||
2eb606db HV |
980 | if (state->mode == MSP_MODE_EXTERN) { |
981 | /* no carrier scan needed, just unmute */ | |
d52c7385 HV |
982 | v4l_dbg(1, msp_debug, client, |
983 | "thread: no carrier scan\n"); | |
2eb606db HV |
984 | state->scan_in_progress = 0; |
985 | msp_set_audio(client); | |
986 | continue; | |
987 | } | |
988 | ||
7e8b09ea HV |
989 | /* setup the chip*/ |
990 | msp34xxg_reset(client); | |
de98cdaf HV |
991 | state->std = state->radio ? 0x40 : |
992 | (state->force_btsc && msp_standard == 1) ? 32 : msp_standard; | |
de533ccf | 993 | msp_write_dem(client, 0x20, state->std); |
de98cdaf | 994 | /* start autodetect */ |
e335fada HV |
995 | if (state->std != 1) |
996 | goto unmute; | |
7e8b09ea HV |
997 | |
998 | /* watch autodetect */ | |
d52c7385 HV |
999 | v4l_dbg(1, msp_debug, client, |
1000 | "started autodetect, waiting for result\n"); | |
7e8b09ea HV |
1001 | for (i = 0; i < 10; i++) { |
1002 | if (msp_sleep(state, 100)) | |
1003 | goto restart; | |
1004 | ||
1005 | /* check results */ | |
1006 | val = msp_read_dem(client, 0x7e); | |
1007 | if (val < 0x07ff) { | |
de533ccf | 1008 | state->std = val; |
7e8b09ea HV |
1009 | break; |
1010 | } | |
d52c7385 HV |
1011 | v4l_dbg(2, msp_debug, client, |
1012 | "detection still in progress\n"); | |
7e8b09ea | 1013 | } |
de533ccf | 1014 | if (state->std == 1) { |
d52c7385 HV |
1015 | v4l_dbg(1, msp_debug, client, |
1016 | "detection still in progress after 10 tries. giving up.\n"); | |
7e8b09ea HV |
1017 | continue; |
1018 | } | |
1019 | ||
d52c7385 HV |
1020 | unmute: |
1021 | v4l_dbg(1, msp_debug, client, | |
1022 | "detected standard: %s (0x%04x)\n", | |
de533ccf | 1023 | msp_standard_std_name(state->std), state->std); |
7e8b09ea | 1024 | |
2eb606db HV |
1025 | if (state->std == 9) { |
1026 | /* AM NICAM mode */ | |
1027 | msp_write_dsp(client, 0x0e, 0x7c00); | |
1028 | } | |
1029 | ||
7e8b09ea HV |
1030 | /* unmute: dispatch sound to scart output, set scart volume */ |
1031 | msp_set_audio(client); | |
1032 | ||
1033 | /* restore ACB */ | |
1034 | if (msp_write_dsp(client, 0x13, state->acb)) | |
1035 | return -1; | |
1036 | ||
de533ccf HV |
1037 | /* the periodic stereo/SAP check is only relevant for |
1038 | the 0x20 standard (BTSC) */ | |
1039 | if (state->std != 0x20) | |
1040 | continue; | |
1041 | ||
1042 | state->watch_stereo = 1; | |
1043 | ||
1044 | /* monitor tv audio mode, the first time don't wait | |
1045 | in order to get a quick stereo/SAP update */ | |
1046 | watch_stereo(client); | |
1047 | while (state->watch_stereo) { | |
1048 | watch_stereo(client); | |
1049 | if (msp_sleep(state, 5000)) | |
1050 | goto restart; | |
1051 | } | |
7e8b09ea | 1052 | } |
f167cb4e | 1053 | v4l_dbg(1, msp_debug, client, "thread: exit\n"); |
7e8b09ea HV |
1054 | return 0; |
1055 | } | |
1056 | ||
de533ccf | 1057 | static int msp34xxg_detect_stereo(struct i2c_client *client) |
7e8b09ea HV |
1058 | { |
1059 | struct msp_state *state = i2c_get_clientdata(client); | |
7e8b09ea HV |
1060 | int status = msp_read_dem(client, 0x0200); |
1061 | int is_bilingual = status & 0x100; | |
1062 | int is_stereo = status & 0x40; | |
de533ccf | 1063 | int oldrx = state->rxsubchans; |
7e8b09ea | 1064 | |
b331def2 HV |
1065 | if (state->mode == MSP_MODE_EXTERN) |
1066 | return 0; | |
1067 | ||
7e8b09ea HV |
1068 | state->rxsubchans = 0; |
1069 | if (is_stereo) | |
8a4b275f | 1070 | state->rxsubchans = V4L2_TUNER_SUB_STEREO; |
7e8b09ea | 1071 | else |
8a4b275f | 1072 | state->rxsubchans = V4L2_TUNER_SUB_MONO; |
7e8b09ea | 1073 | if (is_bilingual) { |
de533ccf HV |
1074 | if (state->std == 0x20) |
1075 | state->rxsubchans |= V4L2_TUNER_SUB_SAP; | |
1076 | else | |
d52c7385 HV |
1077 | state->rxsubchans = |
1078 | V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2; | |
7e8b09ea | 1079 | } |
d52c7385 HV |
1080 | v4l_dbg(1, msp_debug, client, |
1081 | "status=0x%x, stereo=%d, bilingual=%d -> rxsubchans=%d\n", | |
7e8b09ea | 1082 | status, is_stereo, is_bilingual, state->rxsubchans); |
de533ccf | 1083 | return (oldrx != state->rxsubchans); |
7e8b09ea HV |
1084 | } |
1085 | ||
044f324f | 1086 | static void msp34xxg_set_audmode(struct i2c_client *client) |
7e8b09ea HV |
1087 | { |
1088 | struct msp_state *state = i2c_get_clientdata(client); | |
7e8b09ea | 1089 | |
de533ccf HV |
1090 | if (state->std == 0x20) { |
1091 | if ((state->rxsubchans & V4L2_TUNER_SUB_SAP) && | |
cc33668b | 1092 | (state->audmode == V4L2_TUNER_MODE_LANG1_LANG2 || |
de533ccf HV |
1093 | state->audmode == V4L2_TUNER_MODE_LANG2)) { |
1094 | msp_write_dem(client, 0x20, 0x21); | |
1095 | } else { | |
1096 | msp_write_dem(client, 0x20, 0x20); | |
1097 | } | |
1098 | } | |
1099 | ||
2474ed44 | 1100 | msp34xxg_set_sources(client); |
7e8b09ea HV |
1101 | } |
1102 | ||
8a4b275f HV |
1103 | void msp_set_audmode(struct i2c_client *client) |
1104 | { | |
1105 | struct msp_state *state = i2c_get_clientdata(client); | |
1106 | ||
1107 | switch (state->opmode) { | |
1108 | case OPMODE_MANUAL: | |
1109 | case OPMODE_AUTODETECT: | |
8a4b275f HV |
1110 | msp3400c_set_audmode(client); |
1111 | break; | |
1112 | case OPMODE_AUTOSELECT: | |
1113 | msp34xxg_set_audmode(client); | |
1114 | break; | |
1115 | } | |
1116 | } | |
1117 | ||
de533ccf | 1118 | int msp_detect_stereo(struct i2c_client *client) |
8a4b275f HV |
1119 | { |
1120 | struct msp_state *state = i2c_get_clientdata(client); | |
1121 | ||
1122 | switch (state->opmode) { | |
1123 | case OPMODE_MANUAL: | |
1124 | case OPMODE_AUTODETECT: | |
de533ccf | 1125 | return msp3400c_detect_stereo(client); |
8a4b275f | 1126 | case OPMODE_AUTOSELECT: |
de533ccf | 1127 | return msp34xxg_detect_stereo(client); |
8a4b275f | 1128 | } |
de533ccf | 1129 | return 0; |
8a4b275f HV |
1130 | } |
1131 |