mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
11 KiB
370 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* ALSA driver for ICEnsemble ICE1712 (Envy24) |
|
* |
|
* Lowlevel functions for Hoontech STDSP24 |
|
* |
|
* Copyright (c) 2000 Jaroslav Kysela <[email protected]> |
|
*/ |
|
|
|
#include <linux/delay.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/init.h> |
|
#include <linux/slab.h> |
|
#include <linux/mutex.h> |
|
|
|
#include <sound/core.h> |
|
|
|
#include "ice1712.h" |
|
#include "hoontech.h" |
|
|
|
/* Hoontech-specific setting */ |
|
struct hoontech_spec { |
|
unsigned char boxbits[4]; |
|
unsigned int config; |
|
unsigned short boxconfig[4]; |
|
}; |
|
|
|
static void snd_ice1712_stdsp24_gpio_write(struct snd_ice1712 *ice, unsigned char byte) |
|
{ |
|
byte |= ICE1712_STDSP24_CLOCK_BIT; |
|
udelay(100); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); |
|
byte &= ~ICE1712_STDSP24_CLOCK_BIT; |
|
udelay(100); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); |
|
byte |= ICE1712_STDSP24_CLOCK_BIT; |
|
udelay(100); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_darear(struct snd_ice1712 *ice, int activate) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
mutex_lock(&ice->gpio_mutex); |
|
ICE1712_STDSP24_0_DAREAR(spec->boxbits, activate); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); |
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_mute(struct snd_ice1712 *ice, int activate) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
mutex_lock(&ice->gpio_mutex); |
|
ICE1712_STDSP24_3_MUTE(spec->boxbits, activate); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); |
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_insel(struct snd_ice1712 *ice, int activate) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
mutex_lock(&ice->gpio_mutex); |
|
ICE1712_STDSP24_3_INSEL(spec->boxbits, activate); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); |
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_box_channel(struct snd_ice1712 *ice, int box, int chn, int activate) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
|
|
mutex_lock(&ice->gpio_mutex); |
|
|
|
/* select box */ |
|
ICE1712_STDSP24_0_BOX(spec->boxbits, box); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); |
|
|
|
/* prepare for write */ |
|
if (chn == 3) |
|
ICE1712_STDSP24_2_CHN4(spec->boxbits, 0); |
|
ICE1712_STDSP24_2_MIDI1(spec->boxbits, activate); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); |
|
|
|
ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); |
|
ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
udelay(100); |
|
if (chn == 3) { |
|
ICE1712_STDSP24_2_CHN4(spec->boxbits, 0); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
} else { |
|
switch (chn) { |
|
case 0: ICE1712_STDSP24_1_CHN1(spec->boxbits, 0); break; |
|
case 1: ICE1712_STDSP24_1_CHN2(spec->boxbits, 0); break; |
|
case 2: ICE1712_STDSP24_1_CHN3(spec->boxbits, 0); break; |
|
} |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); |
|
} |
|
udelay(100); |
|
ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); |
|
ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
udelay(100); |
|
|
|
ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
|
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_box_midi(struct snd_ice1712 *ice, int box, int master) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
|
|
mutex_lock(&ice->gpio_mutex); |
|
|
|
/* select box */ |
|
ICE1712_STDSP24_0_BOX(spec->boxbits, box); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); |
|
|
|
ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); |
|
ICE1712_STDSP24_2_MIDI1(spec->boxbits, master); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); |
|
|
|
udelay(100); |
|
|
|
ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 0); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
|
|
mdelay(10); |
|
|
|
ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); |
|
|
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static void snd_ice1712_stdsp24_midi2(struct snd_ice1712 *ice, int activate) |
|
{ |
|
struct hoontech_spec *spec = ice->spec; |
|
mutex_lock(&ice->gpio_mutex); |
|
ICE1712_STDSP24_3_MIDI2(spec->boxbits, activate); |
|
snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); |
|
mutex_unlock(&ice->gpio_mutex); |
|
} |
|
|
|
static int hoontech_init(struct snd_ice1712 *ice, bool staudio) |
|
{ |
|
struct hoontech_spec *spec; |
|
int box, chn; |
|
|
|
ice->num_total_dacs = 8; |
|
ice->num_total_adcs = 8; |
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
|
if (!spec) |
|
return -ENOMEM; |
|
ice->spec = spec; |
|
|
|
ICE1712_STDSP24_SET_ADDR(spec->boxbits, 0); |
|
ICE1712_STDSP24_CLOCK(spec->boxbits, 0, 1); |
|
ICE1712_STDSP24_0_BOX(spec->boxbits, 0); |
|
ICE1712_STDSP24_0_DAREAR(spec->boxbits, 0); |
|
|
|
ICE1712_STDSP24_SET_ADDR(spec->boxbits, 1); |
|
ICE1712_STDSP24_CLOCK(spec->boxbits, 1, 1); |
|
ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); |
|
ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); |
|
|
|
ICE1712_STDSP24_SET_ADDR(spec->boxbits, 2); |
|
ICE1712_STDSP24_CLOCK(spec->boxbits, 2, 1); |
|
ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); |
|
ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); |
|
ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0); |
|
|
|
ICE1712_STDSP24_SET_ADDR(spec->boxbits, 3); |
|
ICE1712_STDSP24_CLOCK(spec->boxbits, 3, 1); |
|
ICE1712_STDSP24_3_MIDI2(spec->boxbits, 0); |
|
ICE1712_STDSP24_3_MUTE(spec->boxbits, 1); |
|
ICE1712_STDSP24_3_INSEL(spec->boxbits, 0); |
|
|
|
/* let's go - activate only functions in first box */ |
|
if (staudio) |
|
spec->config = ICE1712_STDSP24_MUTE; |
|
else |
|
spec->config = 0; |
|
/* ICE1712_STDSP24_MUTE | |
|
ICE1712_STDSP24_INSEL | |
|
ICE1712_STDSP24_DAREAR; */ |
|
/* These boxconfigs have caused problems in the past. |
|
* The code is not optimal, but should now enable a working config to |
|
* be achieved. |
|
* ** MIDI IN can only be configured on one box ** |
|
* ICE1712_STDSP24_BOX_MIDI1 needs to be set for that box. |
|
* Tests on a ADAC2000 box suggest the box config flags do not |
|
* work as would be expected, and the inputs are crossed. |
|
* Setting ICE1712_STDSP24_BOX_MIDI1 and ICE1712_STDSP24_BOX_MIDI2 |
|
* on the same box connects MIDI-In to both 401 uarts; both outputs |
|
* are then active on all boxes. |
|
* The default config here sets up everything on the first box. |
|
* Alan Horstmann 5.2.2008 |
|
*/ |
|
spec->boxconfig[0] = ICE1712_STDSP24_BOX_CHN1 | |
|
ICE1712_STDSP24_BOX_CHN2 | |
|
ICE1712_STDSP24_BOX_CHN3 | |
|
ICE1712_STDSP24_BOX_CHN4 | |
|
ICE1712_STDSP24_BOX_MIDI1 | |
|
ICE1712_STDSP24_BOX_MIDI2; |
|
if (staudio) { |
|
spec->boxconfig[1] = |
|
spec->boxconfig[2] = |
|
spec->boxconfig[3] = spec->boxconfig[0]; |
|
} else { |
|
spec->boxconfig[1] = |
|
spec->boxconfig[2] = |
|
spec->boxconfig[3] = 0; |
|
} |
|
|
|
snd_ice1712_stdsp24_darear(ice, |
|
(spec->config & ICE1712_STDSP24_DAREAR) ? 1 : 0); |
|
snd_ice1712_stdsp24_mute(ice, |
|
(spec->config & ICE1712_STDSP24_MUTE) ? 1 : 0); |
|
snd_ice1712_stdsp24_insel(ice, |
|
(spec->config & ICE1712_STDSP24_INSEL) ? 1 : 0); |
|
for (box = 0; box < 4; box++) { |
|
if (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI2) |
|
snd_ice1712_stdsp24_midi2(ice, 1); |
|
for (chn = 0; chn < 4; chn++) |
|
snd_ice1712_stdsp24_box_channel(ice, box, chn, |
|
(spec->boxconfig[box] & (1 << chn)) ? 1 : 0); |
|
if (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI1) |
|
snd_ice1712_stdsp24_box_midi(ice, box, 1); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int snd_ice1712_hoontech_init(struct snd_ice1712 *ice) |
|
{ |
|
return hoontech_init(ice, false); |
|
} |
|
|
|
static int snd_ice1712_staudio_init(struct snd_ice1712 *ice) |
|
{ |
|
return hoontech_init(ice, true); |
|
} |
|
|
|
/* |
|
* AK4524 access |
|
*/ |
|
|
|
/* start callback for STDSP24 with modified hardware */ |
|
static void stdsp24_ak4524_lock(struct snd_akm4xxx *ak, int chip) |
|
{ |
|
struct snd_ice1712 *ice = ak->private_data[0]; |
|
unsigned char tmp; |
|
snd_ice1712_save_gpio_status(ice); |
|
tmp = ICE1712_STDSP24_SERIAL_DATA | |
|
ICE1712_STDSP24_SERIAL_CLOCK | |
|
ICE1712_STDSP24_AK4524_CS; |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, |
|
ice->gpio.direction | tmp); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp); |
|
} |
|
|
|
static int snd_ice1712_value_init(struct snd_ice1712 *ice) |
|
{ |
|
/* Hoontech STDSP24 with modified hardware */ |
|
static const struct snd_akm4xxx akm_stdsp24_mv = { |
|
.num_adcs = 2, |
|
.num_dacs = 2, |
|
.type = SND_AK4524, |
|
.ops = { |
|
.lock = stdsp24_ak4524_lock |
|
} |
|
}; |
|
|
|
static const struct snd_ak4xxx_private akm_stdsp24_mv_priv = { |
|
.caddr = 2, |
|
.cif = 1, /* CIF high */ |
|
.data_mask = ICE1712_STDSP24_SERIAL_DATA, |
|
.clk_mask = ICE1712_STDSP24_SERIAL_CLOCK, |
|
.cs_mask = ICE1712_STDSP24_AK4524_CS, |
|
.cs_addr = ICE1712_STDSP24_AK4524_CS, |
|
.cs_none = 0, |
|
.add_flags = 0, |
|
}; |
|
|
|
int err; |
|
struct snd_akm4xxx *ak; |
|
|
|
/* set the analog DACs */ |
|
ice->num_total_dacs = 2; |
|
|
|
/* set the analog ADCs */ |
|
ice->num_total_adcs = 2; |
|
|
|
/* analog section */ |
|
ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); |
|
if (! ak) |
|
return -ENOMEM; |
|
ice->akm_codecs = 1; |
|
|
|
err = snd_ice1712_akm4xxx_init(ak, &akm_stdsp24_mv, &akm_stdsp24_mv_priv, ice); |
|
if (err < 0) |
|
return err; |
|
|
|
/* ak4524 controls */ |
|
return snd_ice1712_akm4xxx_build_controls(ice); |
|
} |
|
|
|
static int snd_ice1712_ez8_init(struct snd_ice1712 *ice) |
|
{ |
|
ice->gpio.write_mask = ice->eeprom.gpiomask; |
|
ice->gpio.direction = ice->eeprom.gpiodir; |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir); |
|
snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate); |
|
return 0; |
|
} |
|
|
|
|
|
/* entry point */ |
|
struct snd_ice1712_card_info snd_ice1712_hoontech_cards[] = { |
|
{ |
|
.subvendor = ICE1712_SUBDEVICE_STDSP24, |
|
.name = "Hoontech SoundTrack Audio DSP24", |
|
.model = "dsp24", |
|
.chip_init = snd_ice1712_hoontech_init, |
|
.mpu401_1_name = "MIDI-1 Hoontech/STA DSP24", |
|
.mpu401_2_name = "MIDI-2 Hoontech/STA DSP24", |
|
}, |
|
{ |
|
.subvendor = ICE1712_SUBDEVICE_STDSP24_VALUE, /* a dummy id */ |
|
.name = "Hoontech SoundTrack Audio DSP24 Value", |
|
.model = "dsp24_value", |
|
.chip_init = snd_ice1712_value_init, |
|
}, |
|
{ |
|
.subvendor = ICE1712_SUBDEVICE_STDSP24_MEDIA7_1, |
|
.name = "Hoontech STA DSP24 Media 7.1", |
|
.model = "dsp24_71", |
|
.chip_init = snd_ice1712_hoontech_init, |
|
}, |
|
{ |
|
.subvendor = ICE1712_SUBDEVICE_EVENT_EZ8, /* a dummy id */ |
|
.name = "Event Electronics EZ8", |
|
.model = "ez8", |
|
.chip_init = snd_ice1712_ez8_init, |
|
}, |
|
{ |
|
/* STAudio ADCIII has the same SSID as Hoontech StA DSP24, |
|
* thus identified only via the explicit model option |
|
*/ |
|
.subvendor = ICE1712_SUBDEVICE_STAUDIO_ADCIII, /* a dummy id */ |
|
.name = "STAudio ADCIII", |
|
.model = "staudio", |
|
.chip_init = snd_ice1712_staudio_init, |
|
}, |
|
{ } /* terminator */ |
|
};
|
|
|