Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Stereo and SAP detection for cx88
4 *
5 * Copyright (c) 2009 Marton Balint <cus@fazekas.hu>
6 */
7
8#include "cx88.h"
9#include "cx88-reg.h"
10
11#include <linux/slab.h>
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/jiffies.h>
15#include <asm/div64.h>
16
17#define INT_PI ((s32)(3.141592653589 * 32768.0))
18
19#define compat_remainder(a, b) \
20 ((float)(((s32)((a) * 100)) % ((s32)((b) * 100))) / 100.0)
21
22#define baseband_freq(carrier, srate, tone) ((s32)( \
23 (compat_remainder(carrier + tone, srate)) / srate * 2 * INT_PI))
24
25/*
26 * We calculate the baseband frequencies of the carrier and the pilot tones
27 * based on the sampling rate of the audio rds fifo.
28 */
29
30#define FREQ_A2_CARRIER baseband_freq(54687.5, 2689.36, 0.0)
31#define FREQ_A2_DUAL baseband_freq(54687.5, 2689.36, 274.1)
32#define FREQ_A2_STEREO baseband_freq(54687.5, 2689.36, 117.5)
33
34/*
35 * The frequencies below are from the reference driver. They probably need
36 * further adjustments, because they are not tested at all. You may even need
37 * to play a bit with the registers of the chip to select the proper signal
38 * for the input of the audio rds fifo, and measure it's sampling rate to
39 * calculate the proper baseband frequencies...
40 */
41
42#define FREQ_A2M_CARRIER ((s32)(2.114516 * 32768.0))
43#define FREQ_A2M_DUAL ((s32)(2.754916 * 32768.0))
44#define FREQ_A2M_STEREO ((s32)(2.462326 * 32768.0))
45
46#define FREQ_EIAJ_CARRIER ((s32)(1.963495 * 32768.0)) /* 5pi/8 */
47#define FREQ_EIAJ_DUAL ((s32)(2.562118 * 32768.0))
48#define FREQ_EIAJ_STEREO ((s32)(2.601053 * 32768.0))
49
50#define FREQ_BTSC_DUAL ((s32)(1.963495 * 32768.0)) /* 5pi/8 */
51#define FREQ_BTSC_DUAL_REF ((s32)(1.374446 * 32768.0)) /* 7pi/16 */
52
53#define FREQ_BTSC_SAP ((s32)(2.471532 * 32768.0))
54#define FREQ_BTSC_SAP_REF ((s32)(1.730072 * 32768.0))
55
56/* The spectrum of the signal should be empty between these frequencies. */
57#define FREQ_NOISE_START ((s32)(0.100000 * 32768.0))
58#define FREQ_NOISE_END ((s32)(1.200000 * 32768.0))
59
60static unsigned int dsp_debug;
61module_param(dsp_debug, int, 0644);
62MODULE_PARM_DESC(dsp_debug, "enable audio dsp debug messages");
63
64#define dprintk(level, fmt, arg...) do { \
65 if (dsp_debug >= level) \
66 printk(KERN_DEBUG pr_fmt("%s: dsp:" fmt), \
67 __func__, ##arg); \
68} while (0)
69
70static s32 int_cos(u32 x)
71{
72 u32 t2, t4, t6, t8;
73 s32 ret;
74 u16 period = x / INT_PI;
75
76 if (period % 2)
77 return -int_cos(x - INT_PI);
78 x = x % INT_PI;
79 if (x > INT_PI / 2)
80 return -int_cos(INT_PI / 2 - (x % (INT_PI / 2)));
81 /*
82 * Now x is between 0 and INT_PI/2.
83 * To calculate cos(x) we use it's Taylor polinom.
84 */
85 t2 = x * x / 32768 / 2;
86 t4 = t2 * x / 32768 * x / 32768 / 3 / 4;
87 t6 = t4 * x / 32768 * x / 32768 / 5 / 6;
88 t8 = t6 * x / 32768 * x / 32768 / 7 / 8;
89 ret = 32768 - t2 + t4 - t6 + t8;
90 return ret;
91}
92
93static u32 int_goertzel(s16 x[], u32 N, u32 freq)
94{
95 /*
96 * We use the Goertzel algorithm to determine the power of the
97 * given frequency in the signal
98 */
99 s32 s_prev = 0;
100 s32 s_prev2 = 0;
101 s32 coeff = 2 * int_cos(freq);
102 u32 i;
103
104 u64 tmp;
105 u32 divisor;
106
107 for (i = 0; i < N; i++) {
108 s32 s = x[i] + ((s64)coeff * s_prev / 32768) - s_prev2;
109
110 s_prev2 = s_prev;
111 s_prev = s;
112 }
113
114 tmp = (s64)s_prev2 * s_prev2 + (s64)s_prev * s_prev -
115 (s64)coeff * s_prev2 * s_prev / 32768;
116
117 /*
118 * XXX: N must be low enough so that N*N fits in s32.
119 * Else we need two divisions.
120 */
121 divisor = N * N;
122 do_div(tmp, divisor);
123
124 return (u32)tmp;
125}
126
127static u32 freq_magnitude(s16 x[], u32 N, u32 freq)
128{
129 u32 sum = int_goertzel(x, N, freq);
130
131 return (u32)int_sqrt(sum);
132}
133
134static u32 noise_magnitude(s16 x[], u32 N, u32 freq_start, u32 freq_end)
135{
136 int i;
137 u32 sum = 0;
138 u32 freq_step;
139 int samples = 5;
140
141 if (N > 192) {
142 /* The last 192 samples are enough for noise detection */
143 x += (N - 192);
144 N = 192;
145 }
146
147 freq_step = (freq_end - freq_start) / (samples - 1);
148
149 for (i = 0; i < samples; i++) {
150 sum += int_goertzel(x, N, freq_start);
151 freq_start += freq_step;
152 }
153
154 return (u32)int_sqrt(sum / samples);
155}
156
157static s32 detect_a2_a2m_eiaj(struct cx88_core *core, s16 x[], u32 N)
158{
159 s32 carrier, stereo, dual, noise;
160 s32 carrier_freq, stereo_freq, dual_freq;
161 s32 ret;
162
163 switch (core->tvaudio) {
164 case WW_BG:
165 case WW_DK:
166 carrier_freq = FREQ_A2_CARRIER;
167 stereo_freq = FREQ_A2_STEREO;
168 dual_freq = FREQ_A2_DUAL;
169 break;
170 case WW_M:
171 carrier_freq = FREQ_A2M_CARRIER;
172 stereo_freq = FREQ_A2M_STEREO;
173 dual_freq = FREQ_A2M_DUAL;
174 break;
175 case WW_EIAJ:
176 carrier_freq = FREQ_EIAJ_CARRIER;
177 stereo_freq = FREQ_EIAJ_STEREO;
178 dual_freq = FREQ_EIAJ_DUAL;
179 break;
180 default:
181 pr_warn("unsupported audio mode %d for %s\n",
182 core->tvaudio, __func__);
183 return UNSET;
184 }
185
186 carrier = freq_magnitude(x, N, carrier_freq);
187 stereo = freq_magnitude(x, N, stereo_freq);
188 dual = freq_magnitude(x, N, dual_freq);
189 noise = noise_magnitude(x, N, FREQ_NOISE_START, FREQ_NOISE_END);
190
191 dprintk(1,
192 "detect a2/a2m/eiaj: carrier=%d, stereo=%d, dual=%d, noise=%d\n",
193 carrier, stereo, dual, noise);
194
195 if (stereo > dual)
196 ret = V4L2_TUNER_SUB_STEREO;
197 else
198 ret = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
199
200 if (core->tvaudio == WW_EIAJ) {
201 /* EIAJ checks may need adjustments */
202 if ((carrier > max(stereo, dual) * 2) &&
203 (carrier < max(stereo, dual) * 6) &&
204 (carrier > 20 && carrier < 200) &&
205 (max(stereo, dual) > min(stereo, dual))) {
206 /*
207 * For EIAJ the carrier is always present,
208 * so we probably don't need noise detection
209 */
210 return ret;
211 }
212 } else {
213 if ((carrier > max(stereo, dual) * 2) &&
214 (carrier < max(stereo, dual) * 8) &&
215 (carrier > 20 && carrier < 200) &&
216 (noise < 10) &&
217 (max(stereo, dual) > min(stereo, dual) * 2)) {
218 return ret;
219 }
220 }
221 return V4L2_TUNER_SUB_MONO;
222}
223
224static s32 detect_btsc(struct cx88_core *core, s16 x[], u32 N)
225{
226 s32 sap_ref = freq_magnitude(x, N, FREQ_BTSC_SAP_REF);
227 s32 sap = freq_magnitude(x, N, FREQ_BTSC_SAP);
228 s32 dual_ref = freq_magnitude(x, N, FREQ_BTSC_DUAL_REF);
229 s32 dual = freq_magnitude(x, N, FREQ_BTSC_DUAL);
230
231 dprintk(1, "detect btsc: dual_ref=%d, dual=%d, sap_ref=%d, sap=%d\n",
232 dual_ref, dual, sap_ref, sap);
233 /* FIXME: Currently not supported */
234 return UNSET;
235}
236
237static s16 *read_rds_samples(struct cx88_core *core, u32 *N)
238{
239 const struct sram_channel *srch = &cx88_sram_channels[SRAM_CH27];
240 s16 *samples;
241
242 unsigned int i;
243 unsigned int bpl = srch->fifo_size / AUD_RDS_LINES;
244 unsigned int spl = bpl / 4;
245 unsigned int sample_count = spl * (AUD_RDS_LINES - 1);
246
247 u32 current_address = cx_read(srch->ptr1_reg);
248 u32 offset = (current_address - srch->fifo_start + bpl);
249
250 dprintk(1,
251 "read RDS samples: current_address=%08x (offset=%08x), sample_count=%d, aud_intstat=%08x\n",
252 current_address,
253 current_address - srch->fifo_start, sample_count,
254 cx_read(MO_AUD_INTSTAT));
255 samples = kmalloc_array(sample_count, sizeof(*samples), GFP_KERNEL);
256 if (!samples)
257 return NULL;
258
259 *N = sample_count;
260
261 for (i = 0; i < sample_count; i++) {
262 offset = offset % (AUD_RDS_LINES * bpl);
263 samples[i] = cx_read(srch->fifo_start + offset);
264 offset += 4;
265 }
266
267 dprintk(2, "RDS samples dump: %*ph\n", sample_count, samples);
268
269 return samples;
270}
271
272s32 cx88_dsp_detect_stereo_sap(struct cx88_core *core)
273{
274 s16 *samples;
275 u32 N = 0;
276 s32 ret = UNSET;
277
278 /* If audio RDS fifo is disabled, we can't read the samples */
279 if (!(cx_read(MO_AUD_DMACNTRL) & 0x04))
280 return ret;
281 if (!(cx_read(AUD_CTL) & EN_FMRADIO_EN_RDS))
282 return ret;
283
284 /* Wait at least 500 ms after an audio standard change */
285 if (time_before(jiffies, core->last_change + msecs_to_jiffies(500)))
286 return ret;
287
288 samples = read_rds_samples(core, &N);
289
290 if (!samples)
291 return ret;
292
293 switch (core->tvaudio) {
294 case WW_BG:
295 case WW_DK:
296 case WW_EIAJ:
297 case WW_M:
298 ret = detect_a2_a2m_eiaj(core, samples, N);
299 break;
300 case WW_BTSC:
301 ret = detect_btsc(core, samples, N);
302 break;
303 case WW_NONE:
304 case WW_I:
305 case WW_L:
306 case WW_I2SPT:
307 case WW_FM:
308 case WW_I2SADC:
309 break;
310 }
311
312 kfree(samples);
313
314 if (ret != UNSET)
315 dprintk(1, "stereo/sap detection result:%s%s%s\n",
316 (ret & V4L2_TUNER_SUB_MONO) ? " mono" : "",
317 (ret & V4L2_TUNER_SUB_STEREO) ? " stereo" : "",
318 (ret & V4L2_TUNER_SUB_LANG2) ? " dual" : "");
319
320 return ret;
321}
322EXPORT_SYMBOL(cx88_dsp_detect_stereo_sap);
323
1/*
2 * Stereo and SAP detection for cx88
3 *
4 * Copyright (c) 2009 Marton Balint <cus@fazekas.hu>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17#include "cx88.h"
18#include "cx88-reg.h"
19
20#include <linux/slab.h>
21#include <linux/kernel.h>
22#include <linux/module.h>
23#include <linux/jiffies.h>
24#include <asm/div64.h>
25
26#define INT_PI ((s32)(3.141592653589 * 32768.0))
27
28#define compat_remainder(a, b) \
29 ((float)(((s32)((a) * 100)) % ((s32)((b) * 100))) / 100.0)
30
31#define baseband_freq(carrier, srate, tone) ((s32)( \
32 (compat_remainder(carrier + tone, srate)) / srate * 2 * INT_PI))
33
34/*
35 * We calculate the baseband frequencies of the carrier and the pilot tones
36 * based on the the sampling rate of the audio rds fifo.
37 */
38
39#define FREQ_A2_CARRIER baseband_freq(54687.5, 2689.36, 0.0)
40#define FREQ_A2_DUAL baseband_freq(54687.5, 2689.36, 274.1)
41#define FREQ_A2_STEREO baseband_freq(54687.5, 2689.36, 117.5)
42
43/*
44 * The frequencies below are from the reference driver. They probably need
45 * further adjustments, because they are not tested at all. You may even need
46 * to play a bit with the registers of the chip to select the proper signal
47 * for the input of the audio rds fifo, and measure it's sampling rate to
48 * calculate the proper baseband frequencies...
49 */
50
51#define FREQ_A2M_CARRIER ((s32)(2.114516 * 32768.0))
52#define FREQ_A2M_DUAL ((s32)(2.754916 * 32768.0))
53#define FREQ_A2M_STEREO ((s32)(2.462326 * 32768.0))
54
55#define FREQ_EIAJ_CARRIER ((s32)(1.963495 * 32768.0)) /* 5pi/8 */
56#define FREQ_EIAJ_DUAL ((s32)(2.562118 * 32768.0))
57#define FREQ_EIAJ_STEREO ((s32)(2.601053 * 32768.0))
58
59#define FREQ_BTSC_DUAL ((s32)(1.963495 * 32768.0)) /* 5pi/8 */
60#define FREQ_BTSC_DUAL_REF ((s32)(1.374446 * 32768.0)) /* 7pi/16 */
61
62#define FREQ_BTSC_SAP ((s32)(2.471532 * 32768.0))
63#define FREQ_BTSC_SAP_REF ((s32)(1.730072 * 32768.0))
64
65/* The spectrum of the signal should be empty between these frequencies. */
66#define FREQ_NOISE_START ((s32)(0.100000 * 32768.0))
67#define FREQ_NOISE_END ((s32)(1.200000 * 32768.0))
68
69static unsigned int dsp_debug;
70module_param(dsp_debug, int, 0644);
71MODULE_PARM_DESC(dsp_debug, "enable audio dsp debug messages");
72
73#define dprintk(level, fmt, arg...) do { \
74 if (dsp_debug >= level) \
75 printk(KERN_DEBUG pr_fmt("%s: dsp:" fmt), \
76 __func__, ##arg); \
77} while (0)
78
79static s32 int_cos(u32 x)
80{
81 u32 t2, t4, t6, t8;
82 s32 ret;
83 u16 period = x / INT_PI;
84
85 if (period % 2)
86 return -int_cos(x - INT_PI);
87 x = x % INT_PI;
88 if (x > INT_PI / 2)
89 return -int_cos(INT_PI / 2 - (x % (INT_PI / 2)));
90 /*
91 * Now x is between 0 and INT_PI/2.
92 * To calculate cos(x) we use it's Taylor polinom.
93 */
94 t2 = x * x / 32768 / 2;
95 t4 = t2 * x / 32768 * x / 32768 / 3 / 4;
96 t6 = t4 * x / 32768 * x / 32768 / 5 / 6;
97 t8 = t6 * x / 32768 * x / 32768 / 7 / 8;
98 ret = 32768 - t2 + t4 - t6 + t8;
99 return ret;
100}
101
102static u32 int_goertzel(s16 x[], u32 N, u32 freq)
103{
104 /*
105 * We use the Goertzel algorithm to determine the power of the
106 * given frequency in the signal
107 */
108 s32 s_prev = 0;
109 s32 s_prev2 = 0;
110 s32 coeff = 2 * int_cos(freq);
111 u32 i;
112
113 u64 tmp;
114 u32 divisor;
115
116 for (i = 0; i < N; i++) {
117 s32 s = x[i] + ((s64)coeff * s_prev / 32768) - s_prev2;
118
119 s_prev2 = s_prev;
120 s_prev = s;
121 }
122
123 tmp = (s64)s_prev2 * s_prev2 + (s64)s_prev * s_prev -
124 (s64)coeff * s_prev2 * s_prev / 32768;
125
126 /*
127 * XXX: N must be low enough so that N*N fits in s32.
128 * Else we need two divisions.
129 */
130 divisor = N * N;
131 do_div(tmp, divisor);
132
133 return (u32)tmp;
134}
135
136static u32 freq_magnitude(s16 x[], u32 N, u32 freq)
137{
138 u32 sum = int_goertzel(x, N, freq);
139
140 return (u32)int_sqrt(sum);
141}
142
143static u32 noise_magnitude(s16 x[], u32 N, u32 freq_start, u32 freq_end)
144{
145 int i;
146 u32 sum = 0;
147 u32 freq_step;
148 int samples = 5;
149
150 if (N > 192) {
151 /* The last 192 samples are enough for noise detection */
152 x += (N - 192);
153 N = 192;
154 }
155
156 freq_step = (freq_end - freq_start) / (samples - 1);
157
158 for (i = 0; i < samples; i++) {
159 sum += int_goertzel(x, N, freq_start);
160 freq_start += freq_step;
161 }
162
163 return (u32)int_sqrt(sum / samples);
164}
165
166static s32 detect_a2_a2m_eiaj(struct cx88_core *core, s16 x[], u32 N)
167{
168 s32 carrier, stereo, dual, noise;
169 s32 carrier_freq, stereo_freq, dual_freq;
170 s32 ret;
171
172 switch (core->tvaudio) {
173 case WW_BG:
174 case WW_DK:
175 carrier_freq = FREQ_A2_CARRIER;
176 stereo_freq = FREQ_A2_STEREO;
177 dual_freq = FREQ_A2_DUAL;
178 break;
179 case WW_M:
180 carrier_freq = FREQ_A2M_CARRIER;
181 stereo_freq = FREQ_A2M_STEREO;
182 dual_freq = FREQ_A2M_DUAL;
183 break;
184 case WW_EIAJ:
185 carrier_freq = FREQ_EIAJ_CARRIER;
186 stereo_freq = FREQ_EIAJ_STEREO;
187 dual_freq = FREQ_EIAJ_DUAL;
188 break;
189 default:
190 pr_warn("unsupported audio mode %d for %s\n",
191 core->tvaudio, __func__);
192 return UNSET;
193 }
194
195 carrier = freq_magnitude(x, N, carrier_freq);
196 stereo = freq_magnitude(x, N, stereo_freq);
197 dual = freq_magnitude(x, N, dual_freq);
198 noise = noise_magnitude(x, N, FREQ_NOISE_START, FREQ_NOISE_END);
199
200 dprintk(1,
201 "detect a2/a2m/eiaj: carrier=%d, stereo=%d, dual=%d, noise=%d\n",
202 carrier, stereo, dual, noise);
203
204 if (stereo > dual)
205 ret = V4L2_TUNER_SUB_STEREO;
206 else
207 ret = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
208
209 if (core->tvaudio == WW_EIAJ) {
210 /* EIAJ checks may need adjustments */
211 if ((carrier > max(stereo, dual) * 2) &&
212 (carrier < max(stereo, dual) * 6) &&
213 (carrier > 20 && carrier < 200) &&
214 (max(stereo, dual) > min(stereo, dual))) {
215 /*
216 * For EIAJ the carrier is always present,
217 * so we probably don't need noise detection
218 */
219 return ret;
220 }
221 } else {
222 if ((carrier > max(stereo, dual) * 2) &&
223 (carrier < max(stereo, dual) * 8) &&
224 (carrier > 20 && carrier < 200) &&
225 (noise < 10) &&
226 (max(stereo, dual) > min(stereo, dual) * 2)) {
227 return ret;
228 }
229 }
230 return V4L2_TUNER_SUB_MONO;
231}
232
233static s32 detect_btsc(struct cx88_core *core, s16 x[], u32 N)
234{
235 s32 sap_ref = freq_magnitude(x, N, FREQ_BTSC_SAP_REF);
236 s32 sap = freq_magnitude(x, N, FREQ_BTSC_SAP);
237 s32 dual_ref = freq_magnitude(x, N, FREQ_BTSC_DUAL_REF);
238 s32 dual = freq_magnitude(x, N, FREQ_BTSC_DUAL);
239
240 dprintk(1, "detect btsc: dual_ref=%d, dual=%d, sap_ref=%d, sap=%d\n",
241 dual_ref, dual, sap_ref, sap);
242 /* FIXME: Currently not supported */
243 return UNSET;
244}
245
246static s16 *read_rds_samples(struct cx88_core *core, u32 *N)
247{
248 const struct sram_channel *srch = &cx88_sram_channels[SRAM_CH27];
249 s16 *samples;
250
251 unsigned int i;
252 unsigned int bpl = srch->fifo_size / AUD_RDS_LINES;
253 unsigned int spl = bpl / 4;
254 unsigned int sample_count = spl * (AUD_RDS_LINES - 1);
255
256 u32 current_address = cx_read(srch->ptr1_reg);
257 u32 offset = (current_address - srch->fifo_start + bpl);
258
259 dprintk(1,
260 "read RDS samples: current_address=%08x (offset=%08x), sample_count=%d, aud_intstat=%08x\n",
261 current_address,
262 current_address - srch->fifo_start, sample_count,
263 cx_read(MO_AUD_INTSTAT));
264 samples = kmalloc_array(sample_count, sizeof(*samples), GFP_KERNEL);
265 if (!samples)
266 return NULL;
267
268 *N = sample_count;
269
270 for (i = 0; i < sample_count; i++) {
271 offset = offset % (AUD_RDS_LINES * bpl);
272 samples[i] = cx_read(srch->fifo_start + offset);
273 offset += 4;
274 }
275
276 dprintk(2, "RDS samples dump: %*ph\n", sample_count, samples);
277
278 return samples;
279}
280
281s32 cx88_dsp_detect_stereo_sap(struct cx88_core *core)
282{
283 s16 *samples;
284 u32 N = 0;
285 s32 ret = UNSET;
286
287 /* If audio RDS fifo is disabled, we can't read the samples */
288 if (!(cx_read(MO_AUD_DMACNTRL) & 0x04))
289 return ret;
290 if (!(cx_read(AUD_CTL) & EN_FMRADIO_EN_RDS))
291 return ret;
292
293 /* Wait at least 500 ms after an audio standard change */
294 if (time_before(jiffies, core->last_change + msecs_to_jiffies(500)))
295 return ret;
296
297 samples = read_rds_samples(core, &N);
298
299 if (!samples)
300 return ret;
301
302 switch (core->tvaudio) {
303 case WW_BG:
304 case WW_DK:
305 case WW_EIAJ:
306 case WW_M:
307 ret = detect_a2_a2m_eiaj(core, samples, N);
308 break;
309 case WW_BTSC:
310 ret = detect_btsc(core, samples, N);
311 break;
312 case WW_NONE:
313 case WW_I:
314 case WW_L:
315 case WW_I2SPT:
316 case WW_FM:
317 case WW_I2SADC:
318 break;
319 }
320
321 kfree(samples);
322
323 if (ret != UNSET)
324 dprintk(1, "stereo/sap detection result:%s%s%s\n",
325 (ret & V4L2_TUNER_SUB_MONO) ? " mono" : "",
326 (ret & V4L2_TUNER_SUB_STEREO) ? " stereo" : "",
327 (ret & V4L2_TUNER_SUB_LANG2) ? " dual" : "");
328
329 return ret;
330}
331EXPORT_SYMBOL(cx88_dsp_detect_stereo_sap);
332