GNU Linux-libre 6.9.1-gnu
[releases.git] / sound / pci / au88x0 / au88x0_synth.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  */
4
5 /*
6  * Someday its supposed to make use of the WT DMA engine
7  * for a Wavetable synthesizer.
8  */
9
10 #include "au88x0.h"
11 #include "au88x0_wt.h"
12
13 static void vortex_fifo_setwtvalid(vortex_t * vortex, int fifo, int en);
14 static void vortex_connection_adb_mixin(vortex_t * vortex, int en,
15                                         unsigned char channel,
16                                         unsigned char source,
17                                         unsigned char mixin);
18 static void vortex_connection_mixin_mix(vortex_t * vortex, int en,
19                                         unsigned char mixin,
20                                         unsigned char mix, int a);
21 static void vortex_fifo_wtinitialize(vortex_t * vortex, int fifo, int j);
22 static int vortex_wt_SetReg(vortex_t * vortex, unsigned char reg, int wt,
23                             u32 val);
24
25 /* WT */
26
27 /* Put 2 WT channels together for one stereo interlaced channel. */
28 static void vortex_wt_setstereo(vortex_t * vortex, u32 wt, u32 stereo)
29 {
30         int temp;
31
32         //temp = hwread(vortex->mmio, 0x80 + ((wt >> 0x5)<< 0xf) + (((wt & 0x1f) >> 1) << 2));
33         temp = hwread(vortex->mmio, WT_STEREO(wt));
34         temp = (temp & 0xfe) | (stereo & 1);
35         //hwwrite(vortex->mmio, 0x80 + ((wt >> 0x5)<< 0xf) + (((wt & 0x1f) >> 1) << 2), temp);
36         hwwrite(vortex->mmio, WT_STEREO(wt), temp);
37 }
38
39 /* Join to mixdown route. */
40 static void vortex_wt_setdsout(vortex_t * vortex, u32 wt, int en)
41 {
42         int temp;
43
44         /* There is one DSREG register for each bank (32 voices each). */
45         temp = hwread(vortex->mmio, WT_DSREG((wt >= 0x20) ? 1 : 0));
46         if (en)
47                 temp |= (1 << (wt & 0x1f));
48         else
49                 temp &= ~(1 << (wt & 0x1f));
50         hwwrite(vortex->mmio, WT_DSREG((wt >= 0x20) ? 1 : 0), temp);
51 }
52
53 /* Setup WT route. */
54 static int vortex_wt_allocroute(vortex_t * vortex, int wt, int nr_ch)
55 {
56         wt_voice_t *voice = &(vortex->wt_voice[wt]);
57         int temp;
58
59         //FIXME: WT audio routing.
60         if (nr_ch) {
61                 vortex_fifo_wtinitialize(vortex, wt, 1);
62                 vortex_fifo_setwtvalid(vortex, wt, 1);
63                 vortex_wt_setstereo(vortex, wt, nr_ch - 1);
64         } else
65                 vortex_fifo_setwtvalid(vortex, wt, 0);
66         
67         /* Set mixdown mode. */
68         vortex_wt_setdsout(vortex, wt, 1);
69         /* Set other parameter registers. */
70         hwwrite(vortex->mmio, WT_SRAMP(0), 0x880000);
71         //hwwrite(vortex->mmio, WT_GMODE(0), 0xffffffff);
72 #ifdef CHIP_AU8830
73         hwwrite(vortex->mmio, WT_SRAMP(1), 0x880000);
74         //hwwrite(vortex->mmio, WT_GMODE(1), 0xffffffff);
75 #endif
76         hwwrite(vortex->mmio, WT_PARM(wt, 0), 0);
77         hwwrite(vortex->mmio, WT_PARM(wt, 1), 0);
78         hwwrite(vortex->mmio, WT_PARM(wt, 2), 0);
79
80         temp = hwread(vortex->mmio, WT_PARM(wt, 3));
81         dev_dbg(vortex->card->dev, "WT PARM3: %x\n", temp);
82         //hwwrite(vortex->mmio, WT_PARM(wt, 3), temp);
83
84         hwwrite(vortex->mmio, WT_DELAY(wt, 0), 0);
85         hwwrite(vortex->mmio, WT_DELAY(wt, 1), 0);
86         hwwrite(vortex->mmio, WT_DELAY(wt, 2), 0);
87         hwwrite(vortex->mmio, WT_DELAY(wt, 3), 0);
88
89         dev_dbg(vortex->card->dev, "WT GMODE: %x\n",
90                 hwread(vortex->mmio, WT_GMODE(wt)));
91
92         hwwrite(vortex->mmio, WT_PARM(wt, 2), 0xffffffff);
93         hwwrite(vortex->mmio, WT_PARM(wt, 3), 0xcff1c810);
94
95         voice->parm0 = voice->parm1 = 0xcfb23e2f;
96         hwwrite(vortex->mmio, WT_PARM(wt, 0), voice->parm0);
97         hwwrite(vortex->mmio, WT_PARM(wt, 1), voice->parm1);
98         dev_dbg(vortex->card->dev, "WT GMODE 2 : %x\n",
99                 hwread(vortex->mmio, WT_GMODE(wt)));
100         return 0;
101 }
102
103
104 static void vortex_wt_connect(vortex_t * vortex, int en)
105 {
106         int i, ii, mix;
107
108 #define NR_WTROUTES 6
109 #ifdef CHIP_AU8830
110 #define NR_WTBLOCKS 2
111 #else
112 #define NR_WTBLOCKS 1
113 #endif
114
115         for (i = 0; i < NR_WTBLOCKS; i++) {
116                 for (ii = 0; ii < NR_WTROUTES; ii++) {
117                         mix =
118                             vortex_adb_checkinout(vortex,
119                                                   vortex->fixed_res, en,
120                                                   VORTEX_RESOURCE_MIXIN);
121                         vortex->mixwt[(i * NR_WTROUTES) + ii] = mix;
122
123                         vortex_route(vortex, en, 0x11,
124                                      ADB_WTOUT(i, ii + 0x20), ADB_MIXIN(mix));
125
126                         vortex_connection_mixin_mix(vortex, en, mix,
127                                                     vortex->mixplayb[ii % 2], 0);
128                         if (VORTEX_IS_QUAD(vortex))
129                                 vortex_connection_mixin_mix(vortex, en,
130                                                             mix,
131                                                             vortex->mixplayb[2 +
132                                                                      (ii % 2)], 0);
133                 }
134         }
135         for (i = 0; i < NR_WT; i++) {
136                 hwwrite(vortex->mmio, WT_RUN(i), 1);
137         }
138 }
139
140 /* Read WT Register */
141 #if 0
142 static int vortex_wt_GetReg(vortex_t * vortex, char reg, int wt)
143 {
144         //int eax, esi;
145
146         if (reg == 4) {
147                 return hwread(vortex->mmio, WT_PARM(wt, 3));
148         }
149         if (reg == 7) {
150                 return hwread(vortex->mmio, WT_GMODE(wt));
151         }
152
153         return 0;
154 }
155
156 /* WT hardware abstraction layer generic register interface. */
157 static int
158 vortex_wt_SetReg2(vortex_t * vortex, unsigned char reg, int wt,
159                   u16 val)
160 {
161         /*
162            int eax, edx;
163
164            if (wt >= NR_WT)  // 0x40 -> NR_WT
165            return 0;
166
167            if ((reg - 0x20) > 0) {
168            if ((reg - 0x21) != 0) 
169            return 0;
170            eax = ((((b & 0xff) << 0xb) + (edx & 0xff)) << 4) + 0x208; // param 2
171            } else {
172            eax = ((((b & 0xff) << 0xb) + (edx & 0xff)) << 4) + 0x20a; // param 3
173            }
174            hwwrite(vortex->mmio, eax, c);
175          */
176         return 1;
177 }
178
179 /*public: static void __thiscall CWTHal::SetReg(unsigned char,int,unsigned long) */
180 #endif
181 static int
182 vortex_wt_SetReg(vortex_t * vortex, unsigned char reg, int wt,
183                  u32 val)
184 {
185         int ecx;
186
187         if ((reg == 5) || ((reg >= 7) && (reg <= 10)) || (reg == 0xc)) {
188                 if (wt >= (NR_WT / NR_WT_PB)) {
189                         dev_warn(vortex->card->dev,
190                                  "WT SetReg: bank out of range. reg=0x%x, wt=%d\n",
191                                  reg, wt);
192                         return 0;
193                 }
194         } else {
195                 if (wt >= NR_WT) {
196                         dev_err(vortex->card->dev,
197                                 "WT SetReg: voice out of range\n");
198                         return 0;
199                 }
200         }
201         if (reg > 0xc)
202                 return 0;
203
204         switch (reg) {
205                 /* Voice specific parameters */
206         case 0:         /* running */
207                 /*
208                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
209                        WT_RUN(wt), (int)val);
210                 */
211                 hwwrite(vortex->mmio, WT_RUN(wt), val);
212                 return 0xc;
213         case 1:         /* param 0 */
214                 /*
215                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
216                        WT_PARM(wt,0), (int)val);
217                 */
218                 hwwrite(vortex->mmio, WT_PARM(wt, 0), val);
219                 return 0xc;
220         case 2:         /* param 1 */
221                 /*
222                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
223                        WT_PARM(wt,1), (int)val);
224                 */
225                 hwwrite(vortex->mmio, WT_PARM(wt, 1), val);
226                 return 0xc;
227         case 3:         /* param 2 */
228                 /*
229                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
230                        WT_PARM(wt,2), (int)val);
231                 */
232                 hwwrite(vortex->mmio, WT_PARM(wt, 2), val);
233                 return 0xc;
234         case 4:         /* param 3 */
235                 /*
236                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
237                        WT_PARM(wt,3), (int)val);
238                 */
239                 hwwrite(vortex->mmio, WT_PARM(wt, 3), val);
240                 return 0xc;
241         case 6:         /* mute */
242                 /*
243                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
244                        WT_MUTE(wt), (int)val);
245                 */
246                 hwwrite(vortex->mmio, WT_MUTE(wt), val);
247                 return 0xc;
248         case 0xb:
249                         /* delay */
250                 /*
251                 pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n",
252                        WT_DELAY(wt,0), (int)val);
253                 */
254                 hwwrite(vortex->mmio, WT_DELAY(wt, 3), val);
255                 hwwrite(vortex->mmio, WT_DELAY(wt, 2), val);
256                 hwwrite(vortex->mmio, WT_DELAY(wt, 1), val);
257                 hwwrite(vortex->mmio, WT_DELAY(wt, 0), val);
258                 return 0xc;
259                 /* Global WT block parameters */
260         case 5:         /* sramp */
261                 ecx = WT_SRAMP(wt);
262                 break;
263         case 8:         /* aramp */
264                 ecx = WT_ARAMP(wt);
265                 break;
266         case 9:         /* mramp */
267                 ecx = WT_MRAMP(wt);
268                 break;
269         case 0xa:               /* ctrl */
270                 ecx = WT_CTRL(wt);
271                 break;
272         case 0xc:               /* ds_reg */
273                 ecx = WT_DSREG(wt);
274                 break;
275         default:
276                 return 0;
277         }
278         /*
279         pr_debug( "vortex: WT SetReg(0x%x) = 0x%08x\n", ecx, (int)val);
280         */
281         hwwrite(vortex->mmio, ecx, val);
282         return 1;
283 }
284
285 static void vortex_wt_init(vortex_t * vortex)
286 {
287         u32 var4, var8, varc, var10 = 0, edi;
288
289         var10 &= 0xFFFFFFE3;
290         var10 |= 0x22;
291         var10 &= 0xFFFFFEBF;
292         var10 |= 0x80;
293         var10 |= 0x200;
294         var10 &= 0xfffffffe;
295         var10 &= 0xfffffbff;
296         var10 |= 0x1800;
297         // var10 = 0x1AA2
298         var4 = 0x10000000;
299         varc = 0x00830000;
300         var8 = 0x00830000;
301
302         /* Init Bank registers. */
303         for (edi = 0; edi < (NR_WT / NR_WT_PB); edi++) {
304                 vortex_wt_SetReg(vortex, 0xc, edi, 0);  /* ds_reg */
305                 vortex_wt_SetReg(vortex, 0xa, edi, var10);      /* ctrl  */
306                 vortex_wt_SetReg(vortex, 0x9, edi, var4);       /* mramp */
307                 vortex_wt_SetReg(vortex, 0x8, edi, varc);       /* aramp */
308                 vortex_wt_SetReg(vortex, 0x5, edi, var8);       /* sramp */
309         }
310         /* Init Voice registers. */
311         for (edi = 0; edi < NR_WT; edi++) {
312                 vortex_wt_SetReg(vortex, 0x4, edi, 0);  /* param 3 0x20c */
313                 vortex_wt_SetReg(vortex, 0x3, edi, 0);  /* param 2 0x208 */
314                 vortex_wt_SetReg(vortex, 0x2, edi, 0);  /* param 1 0x204 */
315                 vortex_wt_SetReg(vortex, 0x1, edi, 0);  /* param 0 0x200 */
316                 vortex_wt_SetReg(vortex, 0xb, edi, 0);  /* delay 0x400 - 0x40c */
317         }
318         var10 |= 1;
319         for (edi = 0; edi < (NR_WT / NR_WT_PB); edi++)
320                 vortex_wt_SetReg(vortex, 0xa, edi, var10);      /* ctrl */
321 }
322
323 /* Extract of CAdbTopology::SetVolume(struct _ASPVOLUME *) */
324 #if 0
325 static void vortex_wt_SetVolume(vortex_t * vortex, int wt, int vol[])
326 {
327         wt_voice_t *voice = &(vortex->wt_voice[wt]);
328         int ecx = vol[1], eax = vol[0];
329
330         /* This is pure guess */
331         voice->parm0 &= 0xff00ffff;
332         voice->parm0 |= (vol[0] & 0xff) << 0x10;
333         voice->parm1 &= 0xff00ffff;
334         voice->parm1 |= (vol[1] & 0xff) << 0x10;
335
336         /* This is real */
337         hwwrite(vortex, WT_PARM(wt, 0), voice->parm0);
338         hwwrite(vortex, WT_PARM(wt, 1), voice->parm0);
339
340         if (voice->this_1D0 & 4) {
341                 eax >>= 8;
342                 ecx = eax;
343                 if (ecx < 0x80)
344                         ecx = 0x7f;
345                 voice->parm3 &= 0xFFFFC07F;
346                 voice->parm3 |= (ecx & 0x7f) << 7;
347                 voice->parm3 &= 0xFFFFFF80;
348                 voice->parm3 |= (eax & 0x7f);
349         } else {
350                 voice->parm3 &= 0xFFE03FFF;
351                 voice->parm3 |= (eax & 0xFE00) << 5;
352         }
353
354         hwwrite(vortex, WT_PARM(wt, 3), voice->parm3);
355 }
356
357 /* Extract of CAdbTopology::SetFrequency(unsigned long arg_0) */
358 static void vortex_wt_SetFrequency(vortex_t * vortex, int wt, unsigned int sr)
359 {
360         wt_voice_t *voice = &(vortex->wt_voice[wt]);
361         u32 eax, edx;
362
363         //FIXME: 64 bit operation.
364         eax = ((sr << 0xf) * 0x57619F1) & 0xffffffff;
365         edx = (((sr << 0xf) * 0x57619F1)) >> 0x20;
366
367         edx >>= 0xa;
368         edx <<= 1;
369         if (edx) {
370                 if (edx & 0x0FFF80000)
371                         eax = 0x7fff;
372                 else {
373                         edx <<= 0xd;
374                         eax = 7;
375                         while ((edx & 0x80000000) == 0) {
376                                 edx <<= 1;
377                                 eax--;
378                                 if (eax == 0)
379                                         break;
380                         }
381                         if (eax)
382                                 edx <<= 1;
383                         eax <<= 0xc;
384                         edx >>= 0x14;
385                         eax |= edx;
386                 }
387         } else
388                 eax = 0;
389         voice->parm0 &= 0xffff0001;
390         voice->parm0 |= (eax & 0x7fff) << 1;
391         voice->parm1 = voice->parm0 | 1;
392         // Wt: this_1D4
393         //AuWt::WriteReg((ulong)(this_1DC<<4)+0x200, (ulong)this_1E4);
394         //AuWt::WriteReg((ulong)(this_1DC<<4)+0x204, (ulong)this_1E8);
395         hwwrite(vortex->mmio, WT_PARM(wt, 0), voice->parm0);
396         hwwrite(vortex->mmio, WT_PARM(wt, 1), voice->parm1);
397 }
398 #endif
399
400 /* End of File */