git.oblomov.eu Git - linux-2.6/blob - sound/pci/ice1712/hoontech.c

   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 };