1 /* 2 * ALSA driver for ICEnsemble ICE1712 (Envy24) 3 * 4 * Lowlevel functions for Hoontech STDSP24 5 * 6 * Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <asm/io.h> 25 #include <linux/delay.h> 26 #include <linux/interrupt.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/mutex.h> 30 31 #include <sound/core.h> 32 33 #include "ice1712.h" 34 #include "hoontech.h" 35 36 /* Hoontech-specific setting */ 37 struct hoontech_spec { 38 unsigned char boxbits[4]; 39 unsigned int config; 40 unsigned short boxconfig[4]; 41 }; 42 43 static void __devinit snd_ice1712_stdsp24_gpio_write(struct snd_ice1712 *ice, unsigned char byte) 44 { 45 byte |= ICE1712_STDSP24_CLOCK_BIT; 46 udelay(100); 47 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); 48 byte &= ~ICE1712_STDSP24_CLOCK_BIT; 49 udelay(100); 50 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); 51 byte |= ICE1712_STDSP24_CLOCK_BIT; 52 udelay(100); 53 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); 54 } 55 56 static void __devinit snd_ice1712_stdsp24_darear(struct snd_ice1712 *ice, int activate) 57 { 58 struct hoontech_spec *spec = ice->spec; 59 mutex_lock(&ice->gpio_mutex); 60 ICE1712_STDSP24_0_DAREAR(spec->boxbits, activate); 61 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); 62 mutex_unlock(&ice->gpio_mutex); 63 } 64 65 static void __devinit snd_ice1712_stdsp24_mute(struct snd_ice1712 *ice, int activate) 66 { 67 struct hoontech_spec *spec = ice->spec; 68 mutex_lock(&ice->gpio_mutex); 69 ICE1712_STDSP24_3_MUTE(spec->boxbits, activate); 70 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); 71 mutex_unlock(&ice->gpio_mutex); 72 } 73 74 static void __devinit snd_ice1712_stdsp24_insel(struct snd_ice1712 *ice, int activate) 75 { 76 struct hoontech_spec *spec = ice->spec; 77 mutex_lock(&ice->gpio_mutex); 78 ICE1712_STDSP24_3_INSEL(spec->boxbits, activate); 79 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); 80 mutex_unlock(&ice->gpio_mutex); 81 } 82 83 static void __devinit snd_ice1712_stdsp24_box_channel(struct snd_ice1712 *ice, int box, int chn, int activate) 84 { 85 struct hoontech_spec *spec = ice->spec; 86 87 mutex_lock(&ice->gpio_mutex); 88 89 /* select box */ 90 ICE1712_STDSP24_0_BOX(spec->boxbits, box); 91 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); 92 93 /* prepare for write */ 94 if (chn == 3) 95 ICE1712_STDSP24_2_CHN4(spec->boxbits, 0); 96 ICE1712_STDSP24_2_MIDI1(spec->boxbits, activate); 97 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 98 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); 99 100 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); 101 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); 102 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); 103 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); 104 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); 105 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 106 udelay(100); 107 if (chn == 3) { 108 ICE1712_STDSP24_2_CHN4(spec->boxbits, 0); 109 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 110 } else { 111 switch (chn) { 112 case 0: ICE1712_STDSP24_1_CHN1(spec->boxbits, 0); break; 113 case 1: ICE1712_STDSP24_1_CHN2(spec->boxbits, 0); break; 114 case 2: ICE1712_STDSP24_1_CHN3(spec->boxbits, 0); break; 115 } 116 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); 117 } 118 udelay(100); 119 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); 120 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); 121 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); 122 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); 123 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[1]); 124 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 125 udelay(100); 126 127 ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0); 128 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 129 130 mutex_unlock(&ice->gpio_mutex); 131 } 132 133 static void __devinit snd_ice1712_stdsp24_box_midi(struct snd_ice1712 *ice, int box, int master) 134 { 135 struct hoontech_spec *spec = ice->spec; 136 137 mutex_lock(&ice->gpio_mutex); 138 139 /* select box */ 140 ICE1712_STDSP24_0_BOX(spec->boxbits, box); 141 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[0]); 142 143 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); 144 ICE1712_STDSP24_2_MIDI1(spec->boxbits, master); 145 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 146 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); 147 148 udelay(100); 149 150 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 0); 151 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 152 153 mdelay(10); 154 155 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); 156 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[2]); 157 158 mutex_unlock(&ice->gpio_mutex); 159 } 160 161 static void __devinit snd_ice1712_stdsp24_midi2(struct snd_ice1712 *ice, int activate) 162 { 163 struct hoontech_spec *spec = ice->spec; 164 mutex_lock(&ice->gpio_mutex); 165 ICE1712_STDSP24_3_MIDI2(spec->boxbits, activate); 166 snd_ice1712_stdsp24_gpio_write(ice, spec->boxbits[3]); 167 mutex_unlock(&ice->gpio_mutex); 168 } 169 170 static int __devinit snd_ice1712_hoontech_init(struct snd_ice1712 *ice) 171 { 172 struct hoontech_spec *spec; 173 int box, chn; 174 175 ice->num_total_dacs = 8; 176 ice->num_total_adcs = 8; 177 178 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 179 if (!spec) 180 return -ENOMEM; 181 ice->spec = spec; 182 183 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 0); 184 ICE1712_STDSP24_CLOCK(spec->boxbits, 0, 1); 185 ICE1712_STDSP24_0_BOX(spec->boxbits, 0); 186 ICE1712_STDSP24_0_DAREAR(spec->boxbits, 0); 187 188 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 1); 189 ICE1712_STDSP24_CLOCK(spec->boxbits, 1, 1); 190 ICE1712_STDSP24_1_CHN1(spec->boxbits, 1); 191 ICE1712_STDSP24_1_CHN2(spec->boxbits, 1); 192 ICE1712_STDSP24_1_CHN3(spec->boxbits, 1); 193 194 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 2); 195 ICE1712_STDSP24_CLOCK(spec->boxbits, 2, 1); 196 ICE1712_STDSP24_2_CHN4(spec->boxbits, 1); 197 ICE1712_STDSP24_2_MIDIIN(spec->boxbits, 1); 198 ICE1712_STDSP24_2_MIDI1(spec->boxbits, 0); 199 200 ICE1712_STDSP24_SET_ADDR(spec->boxbits, 3); 201 ICE1712_STDSP24_CLOCK(spec->boxbits, 3, 1); 202 ICE1712_STDSP24_3_MIDI2(spec->boxbits, 0); 203 ICE1712_STDSP24_3_MUTE(spec->boxbits, 1); 204 ICE1712_STDSP24_3_INSEL(spec->boxbits, 0); 205 206 /* let's go - activate only functions in first box */ 207 spec->config = 0; 208 /* ICE1712_STDSP24_MUTE | 209 ICE1712_STDSP24_INSEL | 210 ICE1712_STDSP24_DAREAR; */ 211 spec->boxconfig[0] = ICE1712_STDSP24_BOX_CHN1 | 212 ICE1712_STDSP24_BOX_CHN2 | 213 ICE1712_STDSP24_BOX_CHN3 | 214 ICE1712_STDSP24_BOX_CHN4 | 215 ICE1712_STDSP24_BOX_MIDI1 | 216 ICE1712_STDSP24_BOX_MIDI2; 217 spec->boxconfig[1] = 218 spec->boxconfig[2] = 219 spec->boxconfig[3] = 0; 220 snd_ice1712_stdsp24_darear(ice, 221 (spec->config & ICE1712_STDSP24_DAREAR) ? 1 : 0); 222 snd_ice1712_stdsp24_mute(ice, 223 (spec->config & ICE1712_STDSP24_MUTE) ? 1 : 0); 224 snd_ice1712_stdsp24_insel(ice, 225 (spec->config & ICE1712_STDSP24_INSEL) ? 1 : 0); 226 for (box = 0; box < 1; box++) { 227 if (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI2) 228 snd_ice1712_stdsp24_midi2(ice, 1); 229 for (chn = 0; chn < 4; chn++) 230 snd_ice1712_stdsp24_box_channel(ice, box, chn, 231 (spec->boxconfig[box] & (1 << chn)) ? 1 : 0); 232 snd_ice1712_stdsp24_box_midi(ice, box, 233 (spec->boxconfig[box] & ICE1712_STDSP24_BOX_MIDI1) ? 1 : 0); 234 } 235 236 return 0; 237 } 238 239 /* 240 * AK4524 access 241 */ 242 243 /* start callback for STDSP24 with modified hardware */ 244 static void stdsp24_ak4524_lock(struct snd_akm4xxx *ak, int chip) 245 { 246 struct snd_ice1712 *ice = ak->private_data[0]; 247 unsigned char tmp; 248 snd_ice1712_save_gpio_status(ice); 249 tmp = ICE1712_STDSP24_SERIAL_DATA | 250 ICE1712_STDSP24_SERIAL_CLOCK | 251 ICE1712_STDSP24_AK4524_CS; 252 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, 253 ice->gpio.direction | tmp); 254 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp); 255 } 256 257 static int __devinit snd_ice1712_value_init(struct snd_ice1712 *ice) 258 { 259 /* Hoontech STDSP24 with modified hardware */ 260 static struct snd_akm4xxx akm_stdsp24_mv __devinitdata = { 261 .num_adcs = 2, 262 .num_dacs = 2, 263 .type = SND_AK4524, 264 .ops = { 265 .lock = stdsp24_ak4524_lock 266 } 267 }; 268 269 static struct snd_ak4xxx_private akm_stdsp24_mv_priv __devinitdata = { 270 .caddr = 2, 271 .cif = 1, /* CIF high */ 272 .data_mask = ICE1712_STDSP24_SERIAL_DATA, 273 .clk_mask = ICE1712_STDSP24_SERIAL_CLOCK, 274 .cs_mask = ICE1712_STDSP24_AK4524_CS, 275 .cs_addr = ICE1712_STDSP24_AK4524_CS, 276 .cs_none = 0, 277 .add_flags = 0, 278 }; 279 280 int err; 281 struct snd_akm4xxx *ak; 282 283 /* set the analog DACs */ 284 ice->num_total_dacs = 2; 285 286 /* set the analog ADCs */ 287 ice->num_total_adcs = 2; 288 289 /* analog section */ 290 ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); 291 if (! ak) 292 return -ENOMEM; 293 ice->akm_codecs = 1; 294 295 err = snd_ice1712_akm4xxx_init(ak, &akm_stdsp24_mv, &akm_stdsp24_mv_priv, ice); 296 if (err < 0) 297 return err; 298 299 /* ak4524 controls */ 300 err = snd_ice1712_akm4xxx_build_controls(ice); 301 if (err < 0) 302 return err; 303 304 return 0; 305 } 306 307 static int __devinit snd_ice1712_ez8_init(struct snd_ice1712 *ice) 308 { 309 ice->gpio.write_mask = ice->eeprom.gpiomask; 310 ice->gpio.direction = ice->eeprom.gpiodir; 311 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask); 312 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir); 313 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate); 314 return 0; 315 } 316 317 318 /* entry point */ 319 struct snd_ice1712_card_info snd_ice1712_hoontech_cards[] __devinitdata = { 320 { 321 .subvendor = ICE1712_SUBDEVICE_STDSP24, 322 .name = "Hoontech SoundTrack Audio DSP24", 323 .model = "dsp24", 324 .chip_init = snd_ice1712_hoontech_init, 325 }, 326 { 327 .subvendor = ICE1712_SUBDEVICE_STDSP24_VALUE, /* a dummy id */ 328 .name = "Hoontech SoundTrack Audio DSP24 Value", 329 .model = "dsp24_value", 330 .chip_init = snd_ice1712_value_init, 331 }, 332 { 333 .subvendor = ICE1712_SUBDEVICE_STDSP24_MEDIA7_1, 334 .name = "Hoontech STA DSP24 Media 7.1", 335 .model = "dsp24_71", 336 .chip_init = snd_ice1712_hoontech_init, 337 }, 338 { 339 .subvendor = ICE1712_SUBDEVICE_EVENT_EZ8, /* a dummy id */ 340 .name = "Event Electronics EZ8", 341 .model = "ez8", 342 .chip_init = snd_ice1712_ez8_init, 343 }, 344 { } /* terminator */ 345 }; 346