1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * ALSA driver for ICEnsemble ICE1712 (Envy24)
4 *
5 * Lowlevel functions for Hoontech STDSP24
6 *
7 * Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz>
8 */
9
10 #include <linux/delay.h>
11 #include <linux/interrupt.h>
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/mutex.h>
15
16 #include <sound/core.h>
17
18 #include "ice1712.h"
19 #include "hoontech.h"
20
21 /* Hoontech-specific setting */
22 struct hoontech_spec {
23 unsigned char boxbits[4];
24 unsigned int config;
25 unsigned short boxconfig[4];
26 };
27
28 static void snd_ice1712_stdsp24_gpio_write(struct snd_ice1712 *ice, unsigned char byte)
29 {
30 byte |= ICE1712_STDSP24_CLOCK_BIT;
31 udelay(100);
32 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte);
33 byte &= ~ICE1712_STDSP24_CLOCK_BIT;
34 udelay(100);
35 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte);
36 byte |= ICE1712_STDSP24_CLOCK_BIT;
37 udelay(100);
38 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte);
39 }
40
41 static void snd_ice1712_stdsp24_darear(struct snd_ice1712 *ice, int activate)
42 {
43 struct hoontech_spec *spec = ice->spec;
44 mutex_lock(&ice->gpio_mutex);
45 ICE1712_STDSP24_0_DAREAR(spec->boxbits, activate);
46 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]);
47 mutex_unlock(&ice->gpio_mutex);
48 }
49
50 static void snd_ice1712_stdsp24_mute(struct snd_ice1712 *ice, int activate)
51 {
52 struct hoontech_spec *spec = ice->spec;
53 mutex_lock(&ice->gpio_mutex);
54 ICE1712_STDSP24_3_MUTE(spec->boxbits, activate);
55 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]);
56 mutex_unlock(&ice->gpio_mutex);
57 }
58
59 static void snd_ice1712_stdsp24_insel(struct snd_ice1712 *ice, int activate)
60 {
61 struct hoontech_spec *spec = ice->spec;
62 mutex_lock(&ice->gpio_mutex);
63 ICE1712_STDSP24_3_INSEL(spec->boxbits, activate);
64 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]);
65 mutex_unlock(&ice->gpio_mutex);
66 }
67
68 static void snd_ice1712_stdsp24_box_channel(struct snd_ice1712 *ice, int box, int chn, int activate)
69 {
70 struct hoontech_spec *spec = ice->spec;
71
72 mutex_lock(&ice->gpio_mutex);
73
74 /* select box */
75 ICE1712_STDSP24_0_BOX(spec->boxbits, box);
76 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]);
77
78 /* prepare for write */
79 if (chn == 3)
80 ICE1712_STDSP24_2_CHN4(spec->boxbits, 0);
81 ICE1712_STDSP24_2_MIDI1(spec->boxbits, activate);
82 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
83 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]);
84
85 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1);
86 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1);
87 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1);
88 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1);
89 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]);
90 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
91 udelay(100);
92 if (chn == 3) {
93 ICE1712_STDSP24_2_CHN4(spec->boxbits, 0);
94 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
95 } else {
96 switch (chn) {
97 case 0: ICE1712_STDSP24_1_CHN1(spec->boxbits, 0); break;
98 case 1: ICE1712_STDSP24_1_CHN2(spec->boxbits, 0); break;
99 case 2: ICE1712_STDSP24_1_CHN3(spec->boxbits, 0); break;
100 }
101 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]);
102 }
103 udelay(100);
104 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1);
105 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1);
106 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1);
107 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1);
108 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]);
109 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
110 udelay(100);
111
112 ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0);
113 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
114
115 mutex_unlock(&ice->gpio_mutex);
116 }
117
118 static void snd_ice1712_stdsp24_box_midi(struct snd_ice1712 *ice, int box, int master)
119 {
120 struct hoontech_spec *spec = ice->spec;
121
122 mutex_lock(&ice->gpio_mutex);
123
124 /* select box */
125 ICE1712_STDSP24_0_BOX(spec->boxbits, box);
126 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]);
127
128 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1);
129 ICE1712_STDSP24_2_MIDI1(spec->boxbits, master);
130 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
131 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]);
132
133 udelay(100);
134
135 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 0);
136 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
137
138 mdelay(10);
139
140 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1);
141 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]);
142
143 mutex_unlock(&ice->gpio_mutex);
144 }
145
146 static void snd_ice1712_stdsp24_midi2(struct snd_ice1712 *ice, int activate)
147 {
148 struct hoontech_spec *spec = ice->spec;
149 mutex_lock(&ice->gpio_mutex);
150 ICE1712_STDSP24_3_MIDI2(spec->boxbits, activate);
151 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]);
152 mutex_unlock(&ice->gpio_mutex);
153 }
154
155 static int hoontech_init(struct snd_ice1712 *ice, bool staudio)
156 {
157 struct hoontech_spec *spec;
158 int box, chn;
159
160 ice->num_total_dacs = 8;
161 ice->num_total_adcs = 8;
162
163 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
164 if (!spec)
165 return -ENOMEM;
166 ice->spec = spec;
167
168 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 0);
169 ICE1712_STDSP24_CLOCK(spec->boxbits, 0, 1);
170 ICE1712_STDSP24_0_BOX(spec->boxbits, 0);
171 ICE1712_STDSP24_0_DAREAR(spec->boxbits, 0);
172
173 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 1);
174 ICE1712_STDSP24_CLOCK(spec->boxbits, 1, 1);
175 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1);
176 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1);
177 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1);
178
179 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 2);
180 ICE1712_STDSP24_CLOCK(spec->boxbits, 2, 1);
181 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1);
182 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1);
183 ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0);
184
185 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 3);
186 ICE1712_STDSP24_CLOCK(spec->boxbits, 3, 1);
187 ICE1712_STDSP24_3_MIDI2(spec->boxbits, 0);
188 ICE1712_STDSP24_3_MUTE(spec->boxbits, 1);
189 ICE1712_STDSP24_3_INSEL(spec->boxbits, 0);
190
191 /* let's go - activate only functions in first box */
192 if (staudio)
193 spec->config = ICE1712_STDSP24_MUTE;
194 else
195 spec->config = 0;
196 /* ICE1712_STDSP24_MUTE |
197 ICE1712_STDSP24_INSEL |
198 ICE1712_STDSP24_DAREAR; */
199 /* These boxconfigs have caused problems in the past.
200 * The code is not optimal, but should now enable a working config to
201 * be achieved.
202 * ** MIDI IN can only be configured on one box **
203 * ICE1712_STDSP24_BOX_MIDI1 needs to be set for that box.
204 * Tests on a ADAC2000 box suggest the box config flags do not
205 * work as would be expected, and the inputs are crossed.
206 * Setting ICE1712_STDSP24_BOX_MIDI1 and ICE1712_STDSP24_BOX_MIDI2
207 * on the same box connects MIDI-In to both 401 uarts; both outputs
208 * are then active on all boxes.
209 * The default config here sets up everything on the first box.
210 * Alan Horstmann 5.2.2008
211 */
212 spec->boxconfig[0] = ICE1712_STDSP24_BOX_CHN1 |
213 ICE1712_STDSP24_BOX_CHN2 |
214 ICE1712_STDSP24_BOX_CHN3 |
215 ICE1712_STDSP24_BOX_CHN4 |
216 ICE1712_STDSP24_BOX_MIDI1 |
217 ICE1712_STDSP24_BOX_MIDI2;
218 if (staudio) {
219 spec->boxconfig[1] =
220 spec->boxconfig[2] =
221 spec->boxconfig[3] = spec->boxconfig[0];
222 } else {
223 spec->boxconfig[1] =
224 spec->boxconfig[2] =
225 spec->boxconfig[3] = 0;
226 }
227
228 snd_ice1712_stdsp24_darear(ice,
229 (spec->config & ICE1712_STDSP24_DAREAR) ? 1 : 0);
230 snd_ice1712_stdsp24_mute(ice,
231 (spec->config & ICE1712_STDSP24_MUTE) ? 1 : 0);
232 snd_ice1712_stdsp24_insel(ice,
233 (spec->config & ICE1712_STDSP24_INSEL) ? 1 : 0);
234 for (box = 0; box < 4; box++) {
235 if (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI2)
236 snd_ice1712_stdsp24_midi2(ice, 1);
237 for (chn = 0; chn < 4; chn++)
238 snd_ice1712_stdsp24_box_channel(ice, box, chn,
239 (spec->boxconfig[box] & (1 << chn)) ? 1 : 0);
240 if (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI1)
241 snd_ice1712_stdsp24_box_midi(ice, box, 1);
242 }
243
244 return 0;
245 }
246
247 static int snd_ice1712_hoontech_init(struct snd_ice1712 *ice)
248 {
249 return hoontech_init(ice, false);
250 }
251
252 static int snd_ice1712_staudio_init(struct snd_ice1712 *ice)
253 {
254 return hoontech_init(ice, true);
255 }
256
257 /*
258 * AK4524 access
259 */
260
261 /* start callback for STDSP24 with modified hardware */
262 static void stdsp24_ak4524_lock(struct snd_akm4xxx *ak, int chip)
263 {
264 struct snd_ice1712 *ice = ak->private_data[0];
265 unsigned char tmp;
266 snd_ice1712_save_gpio_status(ice);
267 tmp = ICE1712_STDSP24_SERIAL_DATA |
268 ICE1712_STDSP24_SERIAL_CLOCK |
269 ICE1712_STDSP24_AK4524_CS;
270 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
271 ice->gpio.direction | tmp);
272 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
273 }
274
275 static int snd_ice1712_value_init(struct snd_ice1712 *ice)
276 {
277 /* Hoontech STDSP24 with modified hardware */
278 static const struct snd_akm4xxx akm_stdsp24_mv = {
279 .num_adcs = 2,
280 .num_dacs = 2,
281 .type = SND_AK4524,
282 .ops = {
283 .lock = stdsp24_ak4524_lock
284 }
285 };
286
287 static const struct snd_ak4xxx_private akm_stdsp24_mv_priv = {
288 .caddr = 2,
289 .cif = 1, /* CIF high */
290 .data_mask = ICE1712_STDSP24_SERIAL_DATA,
291 .clk_mask = ICE1712_STDSP24_SERIAL_CLOCK,
292 .cs_mask = ICE1712_STDSP24_AK4524_CS,
293 .cs_addr = ICE1712_STDSP24_AK4524_CS,
294 .cs_none = 0,
295 .add_flags = 0,
296 };
297
298 int err;
299 struct snd_akm4xxx *ak;
300
301 /* set the analog DACs */
302 ice->num_total_dacs = 2;
303
304 /* set the analog ADCs */
305 ice->num_total_adcs = 2;
306
307 /* analog section */
308 ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
309 if (! ak)
310 return -ENOMEM;
311 ice->akm_codecs = 1;
312
313 err = snd_ice1712_akm4xxx_init(ak, &akm_stdsp24_mv, &akm_stdsp24_mv_priv, ice);
314 if (err < 0)
315 return err;
316
317 /* ak4524 controls */
318 return snd_ice1712_akm4xxx_build_controls(ice);
319 }
320
321 static int snd_ice1712_ez8_init(struct snd_ice1712 *ice)
322 {
323 ice->gpio.write_mask = ice->eeprom.gpiomask;
324 ice->gpio.direction = ice->eeprom.gpiodir;
325 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask);
326 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir);
327 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate);
328 return 0;
329 }
330
331
332 /* entry point */
333 struct snd_ice1712_card_info snd_ice1712_hoontech_cards[] = {
334 {
335 .subvendor = ICE1712_SUBDEVICE_STDSP24,
336 .name = "Hoontech SoundTrack Audio DSP24",
337 .model = "dsp24",
338 .chip_init = snd_ice1712_hoontech_init,
339 .mpu401_1_name = "MIDI-1 Hoontech/STA DSP24",
340 .mpu401_2_name = "MIDI-2 Hoontech/STA DSP24",
341 },
342 {
343 .subvendor = ICE1712_SUBDEVICE_STDSP24_VALUE, /* a dummy id */
344 .name = "Hoontech SoundTrack Audio DSP24 Value",
345 .model = "dsp24_value",
346 .chip_init = snd_ice1712_value_init,
347 },
348 {
349 .subvendor = ICE1712_SUBDEVICE_STDSP24_MEDIA7_1,
350 .name = "Hoontech STA DSP24 Media 7.1",
351 .model = "dsp24_71",
352 .chip_init = snd_ice1712_hoontech_init,
353 },
354 {
355 .subvendor = ICE1712_SUBDEVICE_EVENT_EZ8, /* a dummy id */
356 .name = "Event Electronics EZ8",
357 .model = "ez8",
358 .chip_init = snd_ice1712_ez8_init,
359 },
360 {
361 /* STAudio ADCIII has the same SSID as Hoontech StA DSP24,
362 * thus identified only via the explicit model option
363 */
364 .subvendor = ICE1712_SUBDEVICE_STAUDIO_ADCIII, /* a dummy id */
365 .name = "STAudio ADCIII",
366 .model = "staudio",
367 .chip_init = snd_ice1712_staudio_init,
368 },
369 { } /* terminator */
370 };
371
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.