git.oblomov.eu Git - linux-2.6/blob - sound/pci/rme9652/hdsp.c

   1 /*
   2  *   ALSA driver for RME Hammerfall DSP audio interface(s)
   3  *
   4  *      Copyright (c) 2002  Paul Davis
   5  *                          Marcus Andersson
   6  *                          Thomas Charbonnel
   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 <sound/driver.h>
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <linux/firmware.h>
  31 #include <linux/moduleparam.h>
  32
  33 #include <sound/core.h>
  34 #include <sound/control.h>
  35 #include <sound/pcm.h>
  36 #include <sound/info.h>
  37 #include <sound/asoundef.h>
  38 #include <sound/rawmidi.h>
  39 #include <sound/hwdep.h>
  40 #include <sound/initval.h>
  41 #include <sound/hdsp.h>
  42
  43 #include <asm/byteorder.h>
  44 #include <asm/current.h>
  45 #include <asm/io.h>
  46
  47 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  48 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  49 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
  50
  51 module_param_array(index, int, NULL, 0444);
  52 MODULE_PARM_DESC(index, "Index value for RME Hammerfall DSP interface.");
  53 module_param_array(id, charp, NULL, 0444);
  54 MODULE_PARM_DESC(id, "ID string for RME Hammerfall DSP interface.");
  55 module_param_array(enable, bool, NULL, 0444);
  56 MODULE_PARM_DESC(enable, "Enable/disable specific Hammerfall DSP soundcards.");
  57 MODULE_AUTHOR("Paul Davis <paul@linuxaudiosystems.com>, Marcus Andersson, Thomas Charbonnel <thomas@undata.org>");
  58 MODULE_DESCRIPTION("RME Hammerfall DSP");
  59 MODULE_LICENSE("GPL");
  60 MODULE_SUPPORTED_DEVICE("{{RME Hammerfall-DSP},"
  61                 "{RME HDSP-9652},"
  62                 "{RME HDSP-9632}}");
  63
  64 #define HDSP_MAX_CHANNELS        26
  65 #define HDSP_MAX_DS_CHANNELS     14
  66 #define HDSP_MAX_QS_CHANNELS     8
  67 #define DIGIFACE_SS_CHANNELS     26
  68 #define DIGIFACE_DS_CHANNELS     14
  69 #define MULTIFACE_SS_CHANNELS    18
  70 #define MULTIFACE_DS_CHANNELS    14
  71 #define H9652_SS_CHANNELS        26
  72 #define H9652_DS_CHANNELS        14
  73 /* This does not include possible Analog Extension Boards
  74    AEBs are detected at card initialization
  75 */
  76 #define H9632_SS_CHANNELS        12
  77 #define H9632_DS_CHANNELS        8
  78 #define H9632_QS_CHANNELS        4
  79
  80 /* Write registers. These are defined as byte-offsets from the iobase value.
  81  */
  82 #define HDSP_resetPointer               0
  83 #define HDSP_outputBufferAddress        32
  84 #define HDSP_inputBufferAddress         36
  85 #define HDSP_controlRegister            64
  86 #define HDSP_interruptConfirmation      96
  87 #define HDSP_outputEnable               128
  88 #define HDSP_control2Reg                256
  89 #define HDSP_midiDataOut0               352
  90 #define HDSP_midiDataOut1               356
  91 #define HDSP_fifoData                   368
  92 #define HDSP_inputEnable                384
  93
  94 /* Read registers. These are defined as byte-offsets from the iobase value
  95  */
  96
  97 #define HDSP_statusRegister    0
  98 #define HDSP_timecode        128
  99 #define HDSP_status2Register 192
 100 #define HDSP_midiDataOut0    352
 101 #define HDSP_midiDataOut1    356
 102 #define HDSP_midiDataIn0     360
 103 #define HDSP_midiDataIn1     364
 104 #define HDSP_midiStatusOut0  384
 105 #define HDSP_midiStatusOut1  388
 106 #define HDSP_midiStatusIn0   392
 107 #define HDSP_midiStatusIn1   396
 108 #define HDSP_fifoStatus      400
 109
 110 /* the meters are regular i/o-mapped registers, but offset
 111    considerably from the rest. the peak registers are reset
 112    when read; the least-significant 4 bits are full-scale counters;
 113    the actual peak value is in the most-significant 24 bits.
 114 */
 115
 116 #define HDSP_playbackPeakLevel  4096  /* 26 * 32 bit values */
 117 #define HDSP_inputPeakLevel     4224  /* 26 * 32 bit values */
 118 #define HDSP_outputPeakLevel    4352  /* (26+2) * 32 bit values */
 119 #define HDSP_playbackRmsLevel   4612  /* 26 * 64 bit values */
 120 #define HDSP_inputRmsLevel      4868  /* 26 * 64 bit values */
 121
 122
 123 /* This is for H9652 cards
 124    Peak values are read downward from the base
 125    Rms values are read upward
 126    There are rms values for the outputs too
 127    26*3 values are read in ss mode
 128    14*3 in ds mode, with no gap between values
 129 */
 130 #define HDSP_9652_peakBase      7164
 131 #define HDSP_9652_rmsBase       4096
 132
 133 /* c.f. the hdsp_9632_meters_t struct */
 134 #define HDSP_9632_metersBase    4096
 135
 136 #define HDSP_IO_EXTENT     7168
 137
 138 /* control2 register bits */
 139
 140 #define HDSP_TMS                0x01
 141 #define HDSP_TCK                0x02
 142 #define HDSP_TDI                0x04
 143 #define HDSP_JTAG               0x08
 144 #define HDSP_PWDN               0x10
 145 #define HDSP_PROGRAM            0x020
 146 #define HDSP_CONFIG_MODE_0      0x040
 147 #define HDSP_CONFIG_MODE_1      0x080
 148 #define HDSP_VERSION_BIT        0x100
 149 #define HDSP_BIGENDIAN_MODE     0x200
 150 #define HDSP_RD_MULTIPLE        0x400
 151 #define HDSP_9652_ENABLE_MIXER  0x800
 152 #define HDSP_TDO                0x10000000
 153
 154 #define HDSP_S_PROGRAM          (HDSP_PROGRAM|HDSP_CONFIG_MODE_0)
 155 #define HDSP_S_LOAD             (HDSP_PROGRAM|HDSP_CONFIG_MODE_1)
 156
 157 /* Control Register bits */
 158
 159 #define HDSP_Start                (1<<0)  /* start engine */
 160 #define HDSP_Latency0             (1<<1)  /* buffer size = 2^n where n is defined by Latency{2,1,0} */
 161 #define HDSP_Latency1             (1<<2)  /* [ see above ] */
 162 #define HDSP_Latency2             (1<<3)  /* [ see above ] */
 163 #define HDSP_ClockModeMaster      (1<<4)  /* 1=Master, 0=Slave/Autosync */
 164 #define HDSP_AudioInterruptEnable (1<<5)  /* what do you think ? */
 165 #define HDSP_Frequency0           (1<<6)  /* 0=44.1kHz/88.2kHz/176.4kHz 1=48kHz/96kHz/192kHz */
 166 #define HDSP_Frequency1           (1<<7)  /* 0=32kHz/64kHz/128kHz */
 167 #define HDSP_DoubleSpeed          (1<<8)  /* 0=normal speed, 1=double speed */
 168 #define HDSP_SPDIFProfessional    (1<<9)  /* 0=consumer, 1=professional */
 169 #define HDSP_SPDIFEmphasis        (1<<10) /* 0=none, 1=on */
 170 #define HDSP_SPDIFNonAudio        (1<<11) /* 0=off, 1=on */
 171 #define HDSP_SPDIFOpticalOut      (1<<12) /* 1=use 1st ADAT connector for SPDIF, 0=do not */
 172 #define HDSP_SyncRef2             (1<<13)
 173 #define HDSP_SPDIFInputSelect0    (1<<14)
 174 #define HDSP_SPDIFInputSelect1    (1<<15)
 175 #define HDSP_SyncRef0             (1<<16)
 176 #define HDSP_SyncRef1             (1<<17)
 177 #define HDSP_AnalogExtensionBoard (1<<18) /* For H9632 cards */
 178 #define HDSP_XLRBreakoutCable     (1<<20) /* For H9632 cards */
 179 #define HDSP_Midi0InterruptEnable (1<<22)
 180 #define HDSP_Midi1InterruptEnable (1<<23)
 181 #define HDSP_LineOut              (1<<24)
 182 #define HDSP_ADGain0              (1<<25) /* From here : H9632 specific */
 183 #define HDSP_ADGain1              (1<<26)
 184 #define HDSP_DAGain0              (1<<27)
 185 #define HDSP_DAGain1              (1<<28)
 186 #define HDSP_PhoneGain0           (1<<29)
 187 #define HDSP_PhoneGain1           (1<<30)
 188 #define HDSP_QuadSpeed            (1<<31)
 189
 190 #define HDSP_ADGainMask       (HDSP_ADGain0|HDSP_ADGain1)
 191 #define HDSP_ADGainMinus10dBV  HDSP_ADGainMask
 192 #define HDSP_ADGainPlus4dBu   (HDSP_ADGain0)
 193 #define HDSP_ADGainLowGain     0
 194
 195 #define HDSP_DAGainMask         (HDSP_DAGain0|HDSP_DAGain1)
 196 #define HDSP_DAGainHighGain      HDSP_DAGainMask
 197 #define HDSP_DAGainPlus4dBu     (HDSP_DAGain0)
 198 #define HDSP_DAGainMinus10dBV    0
 199
 200 #define HDSP_PhoneGainMask      (HDSP_PhoneGain0|HDSP_PhoneGain1)
 201 #define HDSP_PhoneGain0dB        HDSP_PhoneGainMask
 202 #define HDSP_PhoneGainMinus6dB  (HDSP_PhoneGain0)
 203 #define HDSP_PhoneGainMinus12dB  0
 204
 205 #define HDSP_LatencyMask    (HDSP_Latency0|HDSP_Latency1|HDSP_Latency2)
 206 #define HDSP_FrequencyMask  (HDSP_Frequency0|HDSP_Frequency1|HDSP_DoubleSpeed|HDSP_QuadSpeed)
 207
 208 #define HDSP_SPDIFInputMask    (HDSP_SPDIFInputSelect0|HDSP_SPDIFInputSelect1)
 209 #define HDSP_SPDIFInputADAT1    0
 210 #define HDSP_SPDIFInputCoaxial (HDSP_SPDIFInputSelect0)
 211 #define HDSP_SPDIFInputCdrom   (HDSP_SPDIFInputSelect1)
 212 #define HDSP_SPDIFInputAES     (HDSP_SPDIFInputSelect0|HDSP_SPDIFInputSelect1)
 213
 214 #define HDSP_SyncRefMask        (HDSP_SyncRef0|HDSP_SyncRef1|HDSP_SyncRef2)
 215 #define HDSP_SyncRef_ADAT1       0
 216 #define HDSP_SyncRef_ADAT2      (HDSP_SyncRef0)
 217 #define HDSP_SyncRef_ADAT3      (HDSP_SyncRef1)
 218 #define HDSP_SyncRef_SPDIF      (HDSP_SyncRef0|HDSP_SyncRef1)
 219 #define HDSP_SyncRef_WORD       (HDSP_SyncRef2)
 220 #define HDSP_SyncRef_ADAT_SYNC  (HDSP_SyncRef0|HDSP_SyncRef2)
 221
 222 /* Sample Clock Sources */
 223
 224 #define HDSP_CLOCK_SOURCE_AUTOSYNC           0
 225 #define HDSP_CLOCK_SOURCE_INTERNAL_32KHZ     1
 226 #define HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ   2
 227 #define HDSP_CLOCK_SOURCE_INTERNAL_48KHZ     3
 228 #define HDSP_CLOCK_SOURCE_INTERNAL_64KHZ     4
 229 #define HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ   5
 230 #define HDSP_CLOCK_SOURCE_INTERNAL_96KHZ     6
 231 #define HDSP_CLOCK_SOURCE_INTERNAL_128KHZ    7
 232 #define HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ  8
 233 #define HDSP_CLOCK_SOURCE_INTERNAL_192KHZ    9
 234
 235 /* Preferred sync reference choices - used by "pref_sync_ref" control switch */
 236
 237 #define HDSP_SYNC_FROM_WORD      0
 238 #define HDSP_SYNC_FROM_SPDIF     1
 239 #define HDSP_SYNC_FROM_ADAT1     2
 240 #define HDSP_SYNC_FROM_ADAT_SYNC 3
 241 #define HDSP_SYNC_FROM_ADAT2     4
 242 #define HDSP_SYNC_FROM_ADAT3     5
 243
 244 /* SyncCheck status */
 245
 246 #define HDSP_SYNC_CHECK_NO_LOCK 0
 247 #define HDSP_SYNC_CHECK_LOCK    1
 248 #define HDSP_SYNC_CHECK_SYNC    2
 249
 250 /* AutoSync references - used by "autosync_ref" control switch */
 251
 252 #define HDSP_AUTOSYNC_FROM_WORD      0
 253 #define HDSP_AUTOSYNC_FROM_ADAT_SYNC 1
 254 #define HDSP_AUTOSYNC_FROM_SPDIF     2
 255 #define HDSP_AUTOSYNC_FROM_NONE      3
 256 #define HDSP_AUTOSYNC_FROM_ADAT1     4
 257 #define HDSP_AUTOSYNC_FROM_ADAT2     5
 258 #define HDSP_AUTOSYNC_FROM_ADAT3     6
 259
 260 /* Possible sources of S/PDIF input */
 261
 262 #define HDSP_SPDIFIN_OPTICAL  0 /* optical  (ADAT1) */
 263 #define HDSP_SPDIFIN_COAXIAL  1 /* coaxial (RCA) */
 264 #define HDSP_SPDIFIN_INTERNAL 2 /* internal (CDROM) */
 265 #define HDSP_SPDIFIN_AES      3 /* xlr for H9632 (AES)*/
 266
 267 #define HDSP_Frequency32KHz    HDSP_Frequency0
 268 #define HDSP_Frequency44_1KHz  HDSP_Frequency1
 269 #define HDSP_Frequency48KHz    (HDSP_Frequency1|HDSP_Frequency0)
 270 #define HDSP_Frequency64KHz    (HDSP_DoubleSpeed|HDSP_Frequency0)
 271 #define HDSP_Frequency88_2KHz  (HDSP_DoubleSpeed|HDSP_Frequency1)
 272 #define HDSP_Frequency96KHz    (HDSP_DoubleSpeed|HDSP_Frequency1|HDSP_Frequency0)
 273 /* For H9632 cards */
 274 #define HDSP_Frequency128KHz   (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency0)
 275 #define HDSP_Frequency176_4KHz (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency1)
 276 #define HDSP_Frequency192KHz   (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency1|HDSP_Frequency0)
 277
 278 #define hdsp_encode_latency(x)       (((x)<<1) & HDSP_LatencyMask)
 279 #define hdsp_decode_latency(x)       (((x) & HDSP_LatencyMask)>>1)
 280
 281 #define hdsp_encode_spdif_in(x) (((x)&0x3)<<14)
 282 #define hdsp_decode_spdif_in(x) (((x)>>14)&0x3)
 283
 284 /* Status Register bits */
 285
 286 #define HDSP_audioIRQPending    (1<<0)
 287 #define HDSP_Lock2              (1<<1)     /* this is for Digiface and H9652 */
 288 #define HDSP_spdifFrequency3    HDSP_Lock2 /* this is for H9632 only */
 289 #define HDSP_Lock1              (1<<2)
 290 #define HDSP_Lock0              (1<<3)
 291 #define HDSP_SPDIFSync          (1<<4)
 292 #define HDSP_TimecodeLock       (1<<5)
 293 #define HDSP_BufferPositionMask 0x000FFC0 /* Bit 6..15 : h/w buffer pointer */
 294 #define HDSP_Sync2              (1<<16)
 295 #define HDSP_Sync1              (1<<17)
 296 #define HDSP_Sync0              (1<<18)
 297 #define HDSP_DoubleSpeedStatus  (1<<19)
 298 #define HDSP_ConfigError        (1<<20)
 299 #define HDSP_DllError           (1<<21)
 300 #define HDSP_spdifFrequency0    (1<<22)
 301 #define HDSP_spdifFrequency1    (1<<23)
 302 #define HDSP_spdifFrequency2    (1<<24)
 303 #define HDSP_SPDIFErrorFlag     (1<<25)
 304 #define HDSP_BufferID           (1<<26)
 305 #define HDSP_TimecodeSync       (1<<27)
 306 #define HDSP_AEBO               (1<<28) /* H9632 specific Analog Extension Boards */
 307 #define HDSP_AEBI               (1<<29) /* 0 = present, 1 = absent */
 308 #define HDSP_midi0IRQPending    (1<<30)
 309 #define HDSP_midi1IRQPending    (1<<31)
 310
 311 #define HDSP_spdifFrequencyMask    (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
 312
 313 #define HDSP_spdifFrequency32KHz   (HDSP_spdifFrequency0)
 314 #define HDSP_spdifFrequency44_1KHz (HDSP_spdifFrequency1)
 315 #define HDSP_spdifFrequency48KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1)
 316
 317 #define HDSP_spdifFrequency64KHz   (HDSP_spdifFrequency2)
 318 #define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
 319 #define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
 320
 321 /* This is for H9632 cards */
 322 #define HDSP_spdifFrequency128KHz   HDSP_spdifFrequencyMask
 323 #define HDSP_spdifFrequency176_4KHz HDSP_spdifFrequency3
 324 #define HDSP_spdifFrequency192KHz   (HDSP_spdifFrequency3|HDSP_spdifFrequency0)
 325
 326 /* Status2 Register bits */
 327
 328 #define HDSP_version0     (1<<0)
 329 #define HDSP_version1     (1<<1)
 330 #define HDSP_version2     (1<<2)
 331 #define HDSP_wc_lock      (1<<3)
 332 #define HDSP_wc_sync      (1<<4)
 333 #define HDSP_inp_freq0    (1<<5)
 334 #define HDSP_inp_freq1    (1<<6)
 335 #define HDSP_inp_freq2    (1<<7)
 336 #define HDSP_SelSyncRef0  (1<<8)
 337 #define HDSP_SelSyncRef1  (1<<9)
 338 #define HDSP_SelSyncRef2  (1<<10)
 339
 340 #define HDSP_wc_valid (HDSP_wc_lock|HDSP_wc_sync)
 341
 342 #define HDSP_systemFrequencyMask (HDSP_inp_freq0|HDSP_inp_freq1|HDSP_inp_freq2)
 343 #define HDSP_systemFrequency32   (HDSP_inp_freq0)
 344 #define HDSP_systemFrequency44_1 (HDSP_inp_freq1)
 345 #define HDSP_systemFrequency48   (HDSP_inp_freq0|HDSP_inp_freq1)
 346 #define HDSP_systemFrequency64   (HDSP_inp_freq2)
 347 #define HDSP_systemFrequency88_2 (HDSP_inp_freq0|HDSP_inp_freq2)
 348 #define HDSP_systemFrequency96   (HDSP_inp_freq1|HDSP_inp_freq2)
 349 /* FIXME : more values for 9632 cards ? */
 350
 351 #define HDSP_SelSyncRefMask        (HDSP_SelSyncRef0|HDSP_SelSyncRef1|HDSP_SelSyncRef2)
 352 #define HDSP_SelSyncRef_ADAT1      0
 353 #define HDSP_SelSyncRef_ADAT2      (HDSP_SelSyncRef0)
 354 #define HDSP_SelSyncRef_ADAT3      (HDSP_SelSyncRef1)
 355 #define HDSP_SelSyncRef_SPDIF      (HDSP_SelSyncRef0|HDSP_SelSyncRef1)
 356 #define HDSP_SelSyncRef_WORD       (HDSP_SelSyncRef2)
 357 #define HDSP_SelSyncRef_ADAT_SYNC  (HDSP_SelSyncRef0|HDSP_SelSyncRef2)
 358
 359 /* Card state flags */
 360
 361 #define HDSP_InitializationComplete  (1<<0)
 362 #define HDSP_FirmwareLoaded          (1<<1)
 363 #define HDSP_FirmwareCached          (1<<2)
 364
 365 /* FIFO wait times, defined in terms of 1/10ths of msecs */
 366
 367 #define HDSP_LONG_WAIT   5000
 368 #define HDSP_SHORT_WAIT  30
 369
 370 #define UNITY_GAIN                       32768
 371 #define MINUS_INFINITY_GAIN              0
 372
 373 /* the size of a substream (1 mono data stream) */
 374
 375 #define HDSP_CHANNEL_BUFFER_SAMPLES  (16*1024)
 376 #define HDSP_CHANNEL_BUFFER_BYTES    (4*HDSP_CHANNEL_BUFFER_SAMPLES)
 377
 378 /* the size of the area we need to allocate for DMA transfers. the
 379    size is the same regardless of the number of channels - the
 380    Multiface still uses the same memory area.
 381
 382    Note that we allocate 1 more channel than is apparently needed
 383    because the h/w seems to write 1 byte beyond the end of the last
 384    page. Sigh.
 385 */
 386
 387 #define HDSP_DMA_AREA_BYTES ((HDSP_MAX_CHANNELS+1) * HDSP_CHANNEL_BUFFER_BYTES)
 388 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 389
 390 /* use hotplug firmeare loader? */
 391 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
 392 #ifndef HDSP_USE_HWDEP_LOADER
 393 #define HDSP_FW_LOADER
 394 #endif
 395 #endif
 396
 397 struct hdsp_9632_meters {
 398     u32 input_peak[16];
 399     u32 playback_peak[16];
 400     u32 output_peak[16];
 401     u32 xxx_peak[16];
 402     u32 padding[64];
 403     u32 input_rms_low[16];
 404     u32 playback_rms_low[16];
 405     u32 output_rms_low[16];
 406     u32 xxx_rms_low[16];
 407     u32 input_rms_high[16];
 408     u32 playback_rms_high[16];
 409     u32 output_rms_high[16];
 410     u32 xxx_rms_high[16];
 411 };
 412
 413 struct hdsp_midi {
 414     struct hdsp             *hdsp;
 415     int                      id;
 416     struct snd_rawmidi           *rmidi;
 417     struct snd_rawmidi_substream *input;
 418     struct snd_rawmidi_substream *output;
 419     char                     istimer; /* timer in use */
 420     struct timer_list        timer;
 421     spinlock_t               lock;
 422     int                      pending;
 423 };
 424
 425 struct hdsp {
 426         spinlock_t            lock;
 427         struct snd_pcm_substream *capture_substream;
 428         struct snd_pcm_substream *playback_substream;
 429         struct hdsp_midi      midi[2];
 430         struct tasklet_struct midi_tasklet;
 431         int                   use_midi_tasklet;
 432         int                   precise_ptr;
 433         u32                   control_register;      /* cached value */
 434         u32                   control2_register;     /* cached value */
 435         u32                   creg_spdif;
 436         u32                   creg_spdif_stream;
 437         int                   clock_source_locked;
 438         char                 *card_name;             /* digiface/multiface */
 439         enum HDSP_IO_Type     io_type;               /* ditto, but for code use */
 440         unsigned short        firmware_rev;
 441         unsigned short        state;                 /* stores state bits */
 442         u32                   firmware_cache[24413]; /* this helps recover from accidental iobox power failure */
 443         size_t                period_bytes;          /* guess what this is */
 444         unsigned char         max_channels;
 445         unsigned char         qs_in_channels;        /* quad speed mode for H9632 */
 446         unsigned char         ds_in_channels;
 447         unsigned char         ss_in_channels;       /* different for multiface/digiface */
 448         unsigned char         qs_out_channels;
 449         unsigned char         ds_out_channels;
 450         unsigned char         ss_out_channels;
 451
 452         struct snd_dma_buffer capture_dma_buf;
 453         struct snd_dma_buffer playback_dma_buf;
 454         unsigned char        *capture_buffer;       /* suitably aligned address */
 455         unsigned char        *playback_buffer;      /* suitably aligned address */
 456
 457         pid_t                 capture_pid;
 458         pid_t                 playback_pid;
 459         int                   running;
 460         int                   system_sample_rate;
 461         char                 *channel_map;
 462         int                   dev;
 463         int                   irq;
 464         unsigned long         port;
 465         void __iomem         *iobase;
 466         struct snd_card *card;
 467         struct snd_pcm *pcm;
 468         struct snd_hwdep          *hwdep;
 469         struct pci_dev       *pci;
 470         struct snd_kcontrol *spdif_ctl;
 471         unsigned short        mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
 472 };
 473
 474 /* These tables map the ALSA channels 1..N to the channels that we
 475    need to use in order to find the relevant channel buffer. RME
 476    refer to this kind of mapping as between "the ADAT channel and
 477    the DMA channel." We index it using the logical audio channel,
 478    and the value is the DMA channel (i.e. channel buffer number)
 479    where the data for that channel can be read/written from/to.
 480 */
 481
 482 static char channel_map_df_ss[HDSP_MAX_CHANNELS] = {
 483         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
 484         18, 19, 20, 21, 22, 23, 24, 25
 485 };
 486
 487 static char channel_map_mf_ss[HDSP_MAX_CHANNELS] = { /* Multiface */
 488         /* Analog */
 489         0, 1, 2, 3, 4, 5, 6, 7,
 490         /* ADAT 2 */
 491         16, 17, 18, 19, 20, 21, 22, 23,
 492         /* SPDIF */
 493         24, 25,
 494         -1, -1, -1, -1, -1, -1, -1, -1
 495 };
 496
 497 static char channel_map_ds[HDSP_MAX_CHANNELS] = {
 498         /* ADAT channels are remapped */
 499         1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
 500         /* channels 12 and 13 are S/PDIF */
 501         24, 25,
 502         /* others don't exist */
 503         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 504 };
 505
 506 static char channel_map_H9632_ss[HDSP_MAX_CHANNELS] = {
 507         /* ADAT channels */
 508         0, 1, 2, 3, 4, 5, 6, 7,
 509         /* SPDIF */
 510         8, 9,
 511         /* Analog */
 512         10, 11,
 513         /* AO4S-192 and AI4S-192 extension boards */
 514         12, 13, 14, 15,
 515         /* others don't exist */
 516         -1, -1, -1, -1, -1, -1, -1, -1,
 517         -1, -1
 518 };
 519
 520 static char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
 521         /* ADAT */
 522         1, 3, 5, 7,
 523         /* SPDIF */
 524         8, 9,
 525         /* Analog */
 526         10, 11,
 527         /* AO4S-192 and AI4S-192 extension boards */
 528         12, 13, 14, 15,
 529         /* others don't exist */
 530         -1, -1, -1, -1, -1, -1, -1, -1,
 531         -1, -1, -1, -1, -1, -1
 532 };
 533
 534 static char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = {
 535         /* ADAT is disabled in this mode */
 536         /* SPDIF */
 537         8, 9,
 538         /* Analog */
 539         10, 11,
 540         /* AO4S-192 and AI4S-192 extension boards */
 541         12, 13, 14, 15,
 542         /* others don't exist */
 543         -1, -1, -1, -1, -1, -1, -1, -1,
 544         -1, -1, -1, -1, -1, -1, -1, -1,
 545         -1, -1
 546 };
 547
 548 static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size)
 549 {
 550         dmab->dev.type = SNDRV_DMA_TYPE_DEV;
 551         dmab->dev.dev = snd_dma_pci_data(pci);
 552         if (snd_dma_get_reserved_buf(dmab, snd_dma_pci_buf_id(pci))) {
 553                 if (dmab->bytes >= size)
 554                         return 0;
 555         }
 556         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
 557                                 size, dmab) < 0)
 558                 return -ENOMEM;
 559         return 0;
 560 }
 561
 562 static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci)
 563 {
 564         if (dmab->area) {
 565                 dmab->dev.dev = NULL; /* make it anonymous */
 566                 snd_dma_reserve_buf(dmab, snd_dma_pci_buf_id(pci));
 567         }
 568 }
 569
 570
 571 static struct pci_device_id snd_hdsp_ids[] __devinitdata = {
 572         {
 573                 .vendor = PCI_VENDOR_ID_XILINX,
 574                 .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP,
 575                 .subvendor = PCI_ANY_ID,
 576                 .subdevice = PCI_ANY_ID,
 577         }, /* RME Hammerfall-DSP */
 578         { 0, },
 579 };
 580
 581 MODULE_DEVICE_TABLE(pci, snd_hdsp_ids);
 582
 583 /* prototypes */
 584 static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp);
 585 static int snd_hdsp_create_pcm(struct snd_card *card, struct hdsp *hdsp);
 586 static int snd_hdsp_enable_io (struct hdsp *hdsp);
 587 static void snd_hdsp_initialize_midi_flush (struct hdsp *hdsp);
 588 static void snd_hdsp_initialize_channels (struct hdsp *hdsp);
 589 static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout);
 590 static int hdsp_autosync_ref(struct hdsp *hdsp);
 591 static int snd_hdsp_set_defaults(struct hdsp *hdsp);
 592 static void snd_hdsp_9652_enable_mixer (struct hdsp *hdsp);
 593
 594 static int hdsp_playback_to_output_key (struct hdsp *hdsp, int in, int out)
 595 {
 596         switch (hdsp->firmware_rev) {
 597         case 0xa:
 598                 return (64 * out) + (32 + (in));
 599         case 0x96:
 600         case 0x97:
 601                 return (32 * out) + (16 + (in));
 602         default:
 603                 return (52 * out) + (26 + (in));
 604         }
 605 }
 606
 607 static int hdsp_input_to_output_key (struct hdsp *hdsp, int in, int out)
 608 {
 609         switch (hdsp->firmware_rev) {
 610         case 0xa:
 611                 return (64 * out) + in;
 612         case 0x96:
 613         case 0x97:
 614                 return (32 * out) + in;
 615         default:
 616                 return (52 * out) + in;
 617         }
 618 }
 619
 620 static void hdsp_write(struct hdsp *hdsp, int reg, int val)
 621 {
 622         writel(val, hdsp->iobase + reg);
 623 }
 624
 625 static unsigned int hdsp_read(struct hdsp *hdsp, int reg)
 626 {
 627         return readl (hdsp->iobase + reg);
 628 }
 629
 630 static int hdsp_check_for_iobox (struct hdsp *hdsp)
 631 {
 632
 633         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
 634         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
 635                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
 636                 hdsp->state &= ~HDSP_FirmwareLoaded;
 637                 return -EIO;
 638         }
 639         return 0;
 640
 641 }
 642
 643 static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
 644
 645         int i;
 646         unsigned long flags;
 647
 648         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 649
 650                 snd_printk ("Hammerfall-DSP: loading firmware\n");
 651
 652                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_PROGRAM);
 653                 hdsp_write (hdsp, HDSP_fifoData, 0);
 654
 655                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
 656                         snd_printk ("Hammerfall-DSP: timeout waiting for download preparation\n");
 657                         return -EIO;
 658                 }
 659
 660                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 661
 662                 for (i = 0; i < 24413; ++i) {
 663                         hdsp_write(hdsp, HDSP_fifoData, hdsp->firmware_cache[i]);
 664                         if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
 665                                 snd_printk ("Hammerfall-DSP: timeout during firmware loading\n");
 666                                 return -EIO;
 667                         }
 668                 }
 669
 670                 ssleep(3);
 671
 672                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
 673                         snd_printk ("Hammerfall-DSP: timeout at end of firmware loading\n");
 674                         return -EIO;
 675                 }
 676
 677 #ifdef SNDRV_BIG_ENDIAN
 678                 hdsp->control2_register = HDSP_BIGENDIAN_MODE;
 679 #else
 680                 hdsp->control2_register = 0;
 681 #endif
 682                 hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
 683                 snd_printk ("Hammerfall-DSP: finished firmware loading\n");
 684
 685         }
 686         if (hdsp->state & HDSP_InitializationComplete) {
 687                 snd_printk(KERN_INFO "Hammerfall-DSP: firmware loaded from cache, restoring defaults\n");
 688                 spin_lock_irqsave(&hdsp->lock, flags);
 689                 snd_hdsp_set_defaults(hdsp);
 690                 spin_unlock_irqrestore(&hdsp->lock, flags);
 691         }
 692
 693         hdsp->state |= HDSP_FirmwareLoaded;
 694
 695         return 0;
 696 }
 697
 698 static int hdsp_get_iobox_version (struct hdsp *hdsp)
 699 {
 700         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 701
 702                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_PROGRAM);
 703                 hdsp_write (hdsp, HDSP_fifoData, 0);
 704                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0)
 705                         return -EIO;
 706
 707                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 708                 hdsp_write (hdsp, HDSP_fifoData, 0);
 709
 710                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
 711                         hdsp->io_type = Multiface;
 712                         hdsp_write (hdsp, HDSP_control2Reg, HDSP_VERSION_BIT);
 713                         hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 714                         hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
 715                 } else {
 716                         hdsp->io_type = Digiface;
 717                 }
 718         } else {
 719                 /* firmware was already loaded, get iobox type */
 720                 if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1)
 721                         hdsp->io_type = Multiface;
 722                 else
 723                         hdsp->io_type = Digiface;
 724         }
 725         return 0;
 726 }
 727
 728
 729 static int hdsp_check_for_firmware (struct hdsp *hdsp, int show_err)
 730 {
 731         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
 732         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 733                 snd_printk(KERN_ERR "Hammerfall-DSP: firmware not present.\n");
 734                 hdsp->state &= ~HDSP_FirmwareLoaded;
 735                 if (! show_err)
 736                         return -EIO;
 737                 /* try to load firmware */
 738                 if (hdsp->state & HDSP_FirmwareCached) {
 739                         if (snd_hdsp_load_firmware_from_cache(hdsp) != 0)
 740                                 snd_printk(KERN_ERR "Hammerfall-DSP: Firmware loading from cache failed, please upload manually.\n");
 741                 } else {
 742                         snd_printk(KERN_ERR "Hammerfall-DSP: No firmware loaded nor cached, please upload firmware.\n");
 743                 }
 744                 return -EIO;
 745         }
 746         return 0;
 747 }
 748
 749
 750 static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout)
 751 {
 752         int i;
 753
 754         /* the fifoStatus registers reports on how many words
 755            are available in the command FIFO.
 756         */
 757
 758         for (i = 0; i < timeout; i++) {
 759
 760                 if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
 761                         return 0;
 762
 763                 /* not very friendly, but we only do this during a firmware
 764                    load and changing the mixer, so we just put up with it.
 765                 */
 766
 767                 udelay (100);
 768         }
 769
 770         snd_printk ("Hammerfall-DSP: wait for FIFO status <= %d failed after %d iterations\n",
 771                     count, timeout);
 772         return -1;
 773 }
 774
 775 static int hdsp_read_gain (struct hdsp *hdsp, unsigned int addr)
 776 {
 777         if (addr >= HDSP_MATRIX_MIXER_SIZE)
 778                 return 0;
 779
 780         return hdsp->mixer_matrix[addr];
 781 }
 782
 783 static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short data)
 784 {
 785         unsigned int ad;
 786
 787         if (addr >= HDSP_MATRIX_MIXER_SIZE)
 788                 return -1;
 789
 790         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) {
 791
 792                 /* from martin bjornsen:
 793
 794                    "You can only write dwords to the
 795                    mixer memory which contain two
 796                    mixer values in the low and high
 797                    word. So if you want to change
 798                    value 0 you have to read value 1
 799                    from the cache and write both to
 800                    the first dword in the mixer
 801                    memory."
 802                 */
 803
 804                 if (hdsp->io_type == H9632 && addr >= 512)
 805                         return 0;
 806
 807                 if (hdsp->io_type == H9652 && addr >= 1352)
 808                         return 0;
 809
 810                 hdsp->mixer_matrix[addr] = data;
 811
 812
 813                 /* `addr' addresses a 16-bit wide address, but
 814                    the address space accessed via hdsp_write
 815                    uses byte offsets. put another way, addr
 816                    varies from 0 to 1351, but to access the
 817                    corresponding memory location, we need
 818                    to access 0 to 2703 ...
 819                 */
 820                 ad = addr/2;
 821
 822                 hdsp_write (hdsp, 4096 + (ad*4),
 823                             (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) +
 824                             hdsp->mixer_matrix[addr&0x7fe]);
 825
 826                 return 0;
 827
 828         } else {
 829
 830                 ad = (addr << 16) + data;
 831
 832                 if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT))
 833                         return -1;
 834
 835                 hdsp_write (hdsp, HDSP_fifoData, ad);
 836                 hdsp->mixer_matrix[addr] = data;
 837
 838         }
 839
 840         return 0;
 841 }
 842
 843 static int snd_hdsp_use_is_exclusive(struct hdsp *hdsp)
 844 {
 845         unsigned long flags;
 846         int ret = 1;
 847
 848         spin_lock_irqsave(&hdsp->lock, flags);
 849         if ((hdsp->playback_pid != hdsp->capture_pid) &&
 850             (hdsp->playback_pid >= 0) && (hdsp->capture_pid >= 0))
 851                 ret = 0;
 852         spin_unlock_irqrestore(&hdsp->lock, flags);
 853         return ret;
 854 }
 855
 856 static int hdsp_external_sample_rate (struct hdsp *hdsp)
 857 {
 858         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
 859         unsigned int rate_bits = status2 & HDSP_systemFrequencyMask;
 860
 861         switch (rate_bits) {
 862         case HDSP_systemFrequency32:   return 32000;
 863         case HDSP_systemFrequency44_1: return 44100;
 864         case HDSP_systemFrequency48:   return 48000;
 865         case HDSP_systemFrequency64:   return 64000;
 866         case HDSP_systemFrequency88_2: return 88200;
 867         case HDSP_systemFrequency96:   return 96000;
 868         default:
 869                 return 0;
 870         }
 871 }
 872
 873 static int hdsp_spdif_sample_rate(struct hdsp *hdsp)
 874 {
 875         unsigned int status = hdsp_read(hdsp, HDSP_statusRegister);
 876         unsigned int rate_bits = (status & HDSP_spdifFrequencyMask);
 877
 878         if (status & HDSP_SPDIFErrorFlag)
 879                 return 0;
 880
 881         switch (rate_bits) {
 882         case HDSP_spdifFrequency32KHz: return 32000;
 883         case HDSP_spdifFrequency44_1KHz: return 44100;
 884         case HDSP_spdifFrequency48KHz: return 48000;
 885         case HDSP_spdifFrequency64KHz: return 64000;
 886         case HDSP_spdifFrequency88_2KHz: return 88200;
 887         case HDSP_spdifFrequency96KHz: return 96000;
 888         case HDSP_spdifFrequency128KHz:
 889                 if (hdsp->io_type == H9632) return 128000;
 890                 break;
 891         case HDSP_spdifFrequency176_4KHz:
 892                 if (hdsp->io_type == H9632) return 176400;
 893                 break;
 894         case HDSP_spdifFrequency192KHz:
 895                 if (hdsp->io_type == H9632) return 192000;
 896                 break;
 897         default:
 898                 break;
 899         }
 900         snd_printk ("Hammerfall-DSP: unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
 901         return 0;
 902 }
 903
 904 static void hdsp_compute_period_size(struct hdsp *hdsp)
 905 {
 906         hdsp->period_bytes = 1 << ((hdsp_decode_latency(hdsp->control_register) + 8));
 907 }
 908
 909 static snd_pcm_uframes_t hdsp_hw_pointer(struct hdsp *hdsp)
 910 {
 911         int position;
 912
 913         position = hdsp_read(hdsp, HDSP_statusRegister);
 914
 915         if (!hdsp->precise_ptr)
 916                 return (position & HDSP_BufferID) ? (hdsp->period_bytes / 4) : 0;
 917
 918         position &= HDSP_BufferPositionMask;
 919         position /= 4;
 920         position &= (hdsp->period_bytes/2) - 1;
 921         return position;
 922 }
 923
 924 static void hdsp_reset_hw_pointer(struct hdsp *hdsp)
 925 {
 926         hdsp_write (hdsp, HDSP_resetPointer, 0);
 927 }
 928
 929 static void hdsp_start_audio(struct hdsp *s)
 930 {
 931         s->control_register |= (HDSP_AudioInterruptEnable | HDSP_Start);
 932         hdsp_write(s, HDSP_controlRegister, s->control_register);
 933 }
 934
 935 static void hdsp_stop_audio(struct hdsp *s)
 936 {
 937         s->control_register &= ~(HDSP_Start | HDSP_AudioInterruptEnable);
 938         hdsp_write(s, HDSP_controlRegister, s->control_register);
 939 }
 940
 941 static void hdsp_silence_playback(struct hdsp *hdsp)
 942 {
 943         memset(hdsp->playback_buffer, 0, HDSP_DMA_AREA_BYTES);
 944 }
 945
 946 static int hdsp_set_interrupt_interval(struct hdsp *s, unsigned int frames)
 947 {
 948         int n;
 949
 950         spin_lock_irq(&s->lock);
 951
 952         frames >>= 7;
 953         n = 0;
 954         while (frames) {
 955                 n++;
 956                 frames >>= 1;
 957         }
 958
 959         s->control_register &= ~HDSP_LatencyMask;
 960         s->control_register |= hdsp_encode_latency(n);
 961
 962         hdsp_write(s, HDSP_controlRegister, s->control_register);
 963
 964         hdsp_compute_period_size(s);
 965
 966         spin_unlock_irq(&s->lock);
 967
 968         return 0;
 969 }
 970
 971 static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
 972 {
 973         int reject_if_open = 0;
 974         int current_rate;
 975         int rate_bits;
 976
 977         /* ASSUMPTION: hdsp->lock is either held, or
 978            there is no need for it (e.g. during module
 979            initialization).
 980         */
 981
 982         if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
 983                 if (called_internally) {
 984                         /* request from ctl or card initialization */
 985                         snd_printk(KERN_ERR "Hammerfall-DSP: device is not running as a clock master: cannot set sample rate.\n");
 986                         return -1;
 987                 } else {
 988                         /* hw_param request while in AutoSync mode */
 989                         int external_freq = hdsp_external_sample_rate(hdsp);
 990                         int spdif_freq = hdsp_spdif_sample_rate(hdsp);
 991
 992                         if ((spdif_freq == external_freq*2) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
 993                                 snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in double speed mode\n");
 994                         else if (hdsp->io_type == H9632 && (spdif_freq == external_freq*4) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
 995                                 snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in quad speed mode\n");
 996                         else if (rate != external_freq) {
 997                                 snd_printk(KERN_INFO "Hammerfall-DSP: No AutoSync source for requested rate\n");
 998                                 return -1;
 999                         }
1000                 }
1001         }
1002
1003         current_rate = hdsp->system_sample_rate;
1004
1005         /* Changing from a "single speed" to a "double speed" rate is
1006            not allowed if any substreams are open. This is because
1007            such a change causes a shift in the location of
1008            the DMA buffers and a reduction in the number of available
1009            buffers.
1010
1011            Note that a similar but essentially insoluble problem
1012            exists for externally-driven rate changes. All we can do
1013            is to flag rate changes in the read/write routines.  */
1014
1015         if (rate > 96000 && hdsp->io_type != H9632)
1016                 return -EINVAL;
1017
1018         switch (rate) {
1019         case 32000:
1020                 if (current_rate > 48000)
1021                         reject_if_open = 1;
1022                 rate_bits = HDSP_Frequency32KHz;
1023                 break;
1024         case 44100:
1025                 if (current_rate > 48000)
1026                         reject_if_open = 1;
1027                 rate_bits = HDSP_Frequency44_1KHz;
1028                 break;
1029         case 48000:
1030                 if (current_rate > 48000)
1031                         reject_if_open = 1;
1032                 rate_bits = HDSP_Frequency48KHz;
1033                 break;
1034         case 64000:
1035                 if (current_rate <= 48000 || current_rate > 96000)
1036                         reject_if_open = 1;
1037                 rate_bits = HDSP_Frequency64KHz;
1038                 break;
1039         case 88200:
1040                 if (current_rate <= 48000 || current_rate > 96000)
1041                         reject_if_open = 1;
1042                 rate_bits = HDSP_Frequency88_2KHz;
1043                 break;
1044         case 96000:
1045                 if (current_rate <= 48000 || current_rate > 96000)
1046                         reject_if_open = 1;
1047                 rate_bits = HDSP_Frequency96KHz;
1048                 break;
1049         case 128000:
1050                 if (current_rate < 128000)
1051                         reject_if_open = 1;
1052                 rate_bits = HDSP_Frequency128KHz;
1053                 break;
1054         case 176400:
1055                 if (current_rate < 128000)
1056                         reject_if_open = 1;
1057                 rate_bits = HDSP_Frequency176_4KHz;
1058                 break;
1059         case 192000:
1060                 if (current_rate < 128000)
1061                         reject_if_open = 1;
1062                 rate_bits = HDSP_Frequency192KHz;
1063                 break;
1064         default:
1065                 return -EINVAL;
1066         }
1067
1068         if (reject_if_open && (hdsp->capture_pid >= 0 || hdsp->playback_pid >= 0)) {
1069                 snd_printk ("Hammerfall-DSP: cannot change speed mode (capture PID = %d, playback PID = %d)\n",
1070                             hdsp->capture_pid,
1071                             hdsp->playback_pid);
1072                 return -EBUSY;
1073         }
1074
1075         hdsp->control_register &= ~HDSP_FrequencyMask;
1076         hdsp->control_register |= rate_bits;
1077         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1078
1079         if (rate >= 128000) {
1080                 hdsp->channel_map = channel_map_H9632_qs;
1081         } else if (rate > 48000) {
1082                 if (hdsp->io_type == H9632)
1083                         hdsp->channel_map = channel_map_H9632_ds;
1084                 else
1085                         hdsp->channel_map = channel_map_ds;
1086         } else {
1087                 switch (hdsp->io_type) {
1088                 case Multiface:
1089                         hdsp->channel_map = channel_map_mf_ss;
1090                         break;
1091                 case Digiface:
1092                 case H9652:
1093                         hdsp->channel_map = channel_map_df_ss;
1094                         break;
1095                 case H9632:
1096                         hdsp->channel_map = channel_map_H9632_ss;
1097                         break;
1098                 default:
1099                         /* should never happen */
1100                         break;
1101                 }
1102         }
1103
1104         hdsp->system_sample_rate = rate;
1105
1106         return 0;
1107 }
1108
1109 /*----------------------------------------------------------------------------
1110    MIDI
1111   ----------------------------------------------------------------------------*/
1112
1113 static unsigned char snd_hdsp_midi_read_byte (struct hdsp *hdsp, int id)
1114 {
1115         /* the hardware already does the relevant bit-mask with 0xff */
1116         if (id)
1117                 return hdsp_read(hdsp, HDSP_midiDataIn1);
1118         else
1119                 return hdsp_read(hdsp, HDSP_midiDataIn0);
1120 }
1121
1122 static void snd_hdsp_midi_write_byte (struct hdsp *hdsp, int id, int val)
1123 {
1124         /* the hardware already does the relevant bit-mask with 0xff */
1125         if (id)
1126                 hdsp_write(hdsp, HDSP_midiDataOut1, val);
1127         else
1128                 hdsp_write(hdsp, HDSP_midiDataOut0, val);
1129 }
1130
1131 static int snd_hdsp_midi_input_available (struct hdsp *hdsp, int id)
1132 {
1133         if (id)
1134                 return (hdsp_read(hdsp, HDSP_midiStatusIn1) & 0xff);
1135         else
1136                 return (hdsp_read(hdsp, HDSP_midiStatusIn0) & 0xff);
1137 }
1138
1139 static int snd_hdsp_midi_output_possible (struct hdsp *hdsp, int id)
1140 {
1141         int fifo_bytes_used;
1142
1143         if (id)
1144                 fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff;
1145         else
1146                 fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff;
1147
1148         if (fifo_bytes_used < 128)
1149                 return  128 - fifo_bytes_used;
1150         else
1151                 return 0;
1152 }
1153
1154 static void snd_hdsp_flush_midi_input (struct hdsp *hdsp, int id)
1155 {
1156         while (snd_hdsp_midi_input_available (hdsp, id))
1157                 snd_hdsp_midi_read_byte (hdsp, id);
1158 }
1159
1160 static int snd_hdsp_midi_output_write (struct hdsp_midi *hmidi)
1161 {
1162         unsigned long flags;
1163         int n_pending;
1164         int to_write;
1165         int i;
1166         unsigned char buf[128];
1167
1168         /* Output is not interrupt driven */
1169
1170         spin_lock_irqsave (&hmidi->lock, flags);
1171         if (hmidi->output) {
1172                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
1173                         if ((n_pending = snd_hdsp_midi_output_possible (hmidi->hdsp, hmidi->id)) > 0) {
1174                                 if (n_pending > (int)sizeof (buf))
1175                                         n_pending = sizeof (buf);
1176
1177                                 if ((to_write = snd_rawmidi_transmit (hmidi->output, buf, n_pending)) > 0) {
1178                                         for (i = 0; i < to_write; ++i)
1179                                                 snd_hdsp_midi_write_byte (hmidi->hdsp, hmidi->id, buf[i]);
1180                                 }
1181                         }
1182                 }
1183         }
1184         spin_unlock_irqrestore (&hmidi->lock, flags);
1185         return 0;
1186 }
1187
1188 static int snd_hdsp_midi_input_read (struct hdsp_midi *hmidi)
1189 {
1190         unsigned char buf[128]; /* this buffer is designed to match the MIDI input FIFO size */
1191         unsigned long flags;
1192         int n_pending;
1193         int i;
1194
1195         spin_lock_irqsave (&hmidi->lock, flags);
1196         if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
1197                 if (hmidi->input) {
1198                         if (n_pending > (int)sizeof (buf))
1199                                 n_pending = sizeof (buf);
1200                         for (i = 0; i < n_pending; ++i)
1201                                 buf[i] = snd_hdsp_midi_read_byte (hmidi->hdsp, hmidi->id);
1202                         if (n_pending)
1203                                 snd_rawmidi_receive (hmidi->input, buf, n_pending);
1204                 } else {
1205                         /* flush the MIDI input FIFO */
1206                         while (--n_pending)
1207                                 snd_hdsp_midi_read_byte (hmidi->hdsp, hmidi->id);
1208                 }
1209         }
1210         hmidi->pending = 0;
1211         if (hmidi->id)
1212                 hmidi->hdsp->control_register |= HDSP_Midi1InterruptEnable;
1213         else
1214                 hmidi->hdsp->control_register |= HDSP_Midi0InterruptEnable;
1215         hdsp_write(hmidi->hdsp, HDSP_controlRegister, hmidi->hdsp->control_register);
1216         spin_unlock_irqrestore (&hmidi->lock, flags);
1217         return snd_hdsp_midi_output_write (hmidi);
1218 }
1219
1220 static void snd_hdsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
1221 {
1222         struct hdsp *hdsp;
1223         struct hdsp_midi *hmidi;
1224         unsigned long flags;
1225         u32 ie;
1226
1227         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1228         hdsp = hmidi->hdsp;
1229         ie = hmidi->id ? HDSP_Midi1InterruptEnable : HDSP_Midi0InterruptEnable;
1230         spin_lock_irqsave (&hdsp->lock, flags);
1231         if (up) {
1232                 if (!(hdsp->control_register & ie)) {
1233                         snd_hdsp_flush_midi_input (hdsp, hmidi->id);
1234                         hdsp->control_register |= ie;
1235                 }
1236         } else {
1237                 hdsp->control_register &= ~ie;
1238                 tasklet_kill(&hdsp->midi_tasklet);
1239         }
1240
1241         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1242         spin_unlock_irqrestore (&hdsp->lock, flags);
1243 }
1244
1245 static void snd_hdsp_midi_output_timer(unsigned long data)
1246 {
1247         struct hdsp_midi *hmidi = (struct hdsp_midi *) data;
1248         unsigned long flags;
1249
1250         snd_hdsp_midi_output_write(hmidi);
1251         spin_lock_irqsave (&hmidi->lock, flags);
1252
1253         /* this does not bump hmidi->istimer, because the
1254            kernel automatically removed the timer when it
1255            expired, and we are now adding it back, thus
1256            leaving istimer wherever it was set before.
1257         */
1258
1259         if (hmidi->istimer) {
1260                 hmidi->timer.expires = 1 + jiffies;
1261                 add_timer(&hmidi->timer);
1262         }
1263
1264         spin_unlock_irqrestore (&hmidi->lock, flags);
1265 }
1266
1267 static void snd_hdsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
1268 {
1269         struct hdsp_midi *hmidi;
1270         unsigned long flags;
1271
1272         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1273         spin_lock_irqsave (&hmidi->lock, flags);
1274         if (up) {
1275                 if (!hmidi->istimer) {
1276                         init_timer(&hmidi->timer);
1277                         hmidi->timer.function = snd_hdsp_midi_output_timer;
1278                         hmidi->timer.data = (unsigned long) hmidi;
1279                         hmidi->timer.expires = 1 + jiffies;
1280                         add_timer(&hmidi->timer);
1281                         hmidi->istimer++;
1282                 }
1283         } else {
1284                 if (hmidi->istimer && --hmidi->istimer <= 0)
1285                         del_timer (&hmidi->timer);
1286         }
1287         spin_unlock_irqrestore (&hmidi->lock, flags);
1288         if (up)
1289                 snd_hdsp_midi_output_write(hmidi);
1290 }
1291
1292 static int snd_hdsp_midi_input_open(struct snd_rawmidi_substream *substream)
1293 {
1294         struct hdsp_midi *hmidi;
1295
1296         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1297         spin_lock_irq (&hmidi->lock);
1298         snd_hdsp_flush_midi_input (hmidi->hdsp, hmidi->id);
1299         hmidi->input = substream;
1300         spin_unlock_irq (&hmidi->lock);
1301
1302         return 0;
1303 }
1304
1305 static int snd_hdsp_midi_output_open(struct snd_rawmidi_substream *substream)
1306 {
1307         struct hdsp_midi *hmidi;
1308
1309         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1310         spin_lock_irq (&hmidi->lock);
1311         hmidi->output = substream;
1312         spin_unlock_irq (&hmidi->lock);
1313
1314         return 0;
1315 }
1316
1317 static int snd_hdsp_midi_input_close(struct snd_rawmidi_substream *substream)
1318 {
1319         struct hdsp_midi *hmidi;
1320
1321         snd_hdsp_midi_input_trigger (substream, 0);
1322
1323         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1324         spin_lock_irq (&hmidi->lock);
1325         hmidi->input = NULL;
1326         spin_unlock_irq (&hmidi->lock);
1327
1328         return 0;
1329 }
1330
1331 static int snd_hdsp_midi_output_close(struct snd_rawmidi_substream *substream)
1332 {
1333         struct hdsp_midi *hmidi;
1334
1335         snd_hdsp_midi_output_trigger (substream, 0);
1336
1337         hmidi = (struct hdsp_midi *) substream->rmidi->private_data;
1338         spin_lock_irq (&hmidi->lock);
1339         hmidi->output = NULL;
1340         spin_unlock_irq (&hmidi->lock);
1341
1342         return 0;
1343 }
1344
1345 static struct snd_rawmidi_ops snd_hdsp_midi_output =
1346 {
1347         .open =         snd_hdsp_midi_output_open,
1348         .close =        snd_hdsp_midi_output_close,
1349         .trigger =      snd_hdsp_midi_output_trigger,
1350 };
1351
1352 static struct snd_rawmidi_ops snd_hdsp_midi_input =
1353 {
1354         .open =         snd_hdsp_midi_input_open,
1355         .close =        snd_hdsp_midi_input_close,
1356         .trigger =      snd_hdsp_midi_input_trigger,
1357 };
1358
1359 static int __devinit snd_hdsp_create_midi (struct snd_card *card, struct hdsp *hdsp, int id)
1360 {
1361         char buf[32];
1362
1363         hdsp->midi[id].id = id;
1364         hdsp->midi[id].rmidi = NULL;
1365         hdsp->midi[id].input = NULL;
1366         hdsp->midi[id].output = NULL;
1367         hdsp->midi[id].hdsp = hdsp;
1368         hdsp->midi[id].istimer = 0;
1369         hdsp->midi[id].pending = 0;
1370         spin_lock_init (&hdsp->midi[id].lock);
1371
1372         sprintf (buf, "%s MIDI %d", card->shortname, id+1);
1373         if (snd_rawmidi_new (card, buf, id, 1, 1, &hdsp->midi[id].rmidi) < 0)
1374                 return -1;
1375
1376         sprintf (hdsp->midi[id].rmidi->name, "%s MIDI %d", card->id, id+1);
1377         hdsp->midi[id].rmidi->private_data = &hdsp->midi[id];
1378
1379         snd_rawmidi_set_ops (hdsp->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_hdsp_midi_output);
1380         snd_rawmidi_set_ops (hdsp->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_hdsp_midi_input);
1381
1382         hdsp->midi[id].rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
1383                 SNDRV_RAWMIDI_INFO_INPUT |
1384                 SNDRV_RAWMIDI_INFO_DUPLEX;
1385
1386         return 0;
1387 }
1388
1389 /*-----------------------------------------------------------------------------
1390   Control Interface
1391   ----------------------------------------------------------------------------*/
1392
1393 static u32 snd_hdsp_convert_from_aes(struct snd_aes_iec958 *aes)
1394 {
1395         u32 val = 0;
1396         val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? HDSP_SPDIFProfessional : 0;
1397         val |= (aes->status[0] & IEC958_AES0_NONAUDIO) ? HDSP_SPDIFNonAudio : 0;
1398         if (val & HDSP_SPDIFProfessional)
1399                 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? HDSP_SPDIFEmphasis : 0;
1400         else
1401                 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? HDSP_SPDIFEmphasis : 0;
1402         return val;
1403 }
1404
1405 static void snd_hdsp_convert_to_aes(struct snd_aes_iec958 *aes, u32 val)
1406 {
1407         aes->status[0] = ((val & HDSP_SPDIFProfessional) ? IEC958_AES0_PROFESSIONAL : 0) |
1408                          ((val & HDSP_SPDIFNonAudio) ? IEC958_AES0_NONAUDIO : 0);
1409         if (val & HDSP_SPDIFProfessional)
1410                 aes->status[0] |= (val & HDSP_SPDIFEmphasis) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0;
1411         else
1412                 aes->status[0] |= (val & HDSP_SPDIFEmphasis) ? IEC958_AES0_CON_EMPHASIS_5015 : 0;
1413 }
1414
1415 static int snd_hdsp_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1416 {
1417         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1418         uinfo->count = 1;
1419         return 0;
1420 }
1421
1422 static int snd_hdsp_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1423 {
1424         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1425
1426         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif);
1427         return 0;
1428 }
1429
1430 static int snd_hdsp_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1431 {
1432         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1433         int change;
1434         u32 val;
1435
1436         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
1437         spin_lock_irq(&hdsp->lock);
1438         change = val != hdsp->creg_spdif;
1439         hdsp->creg_spdif = val;
1440         spin_unlock_irq(&hdsp->lock);
1441         return change;
1442 }
1443
1444 static int snd_hdsp_control_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1445 {
1446         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1447         uinfo->count = 1;
1448         return 0;
1449 }
1450
1451 static int snd_hdsp_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1452 {
1453         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1454
1455         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif_stream);
1456         return 0;
1457 }
1458
1459 static int snd_hdsp_control_spdif_stream_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1460 {
1461         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1462         int change;
1463         u32 val;
1464
1465         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
1466         spin_lock_irq(&hdsp->lock);
1467         change = val != hdsp->creg_spdif_stream;
1468         hdsp->creg_spdif_stream = val;
1469         hdsp->control_register &= ~(HDSP_SPDIFProfessional | HDSP_SPDIFNonAudio | HDSP_SPDIFEmphasis);
1470         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register |= val);
1471         spin_unlock_irq(&hdsp->lock);
1472         return change;
1473 }
1474
1475 static int snd_hdsp_control_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1476 {
1477         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1478         uinfo->count = 1;
1479         return 0;
1480 }
1481
1482 static int snd_hdsp_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1483 {
1484         ucontrol->value.iec958.status[0] = kcontrol->private_value;
1485         return 0;
1486 }
1487
1488 #define HDSP_SPDIF_IN(xname, xindex) \
1489 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1490   .name = xname, \
1491   .index = xindex, \
1492   .info = snd_hdsp_info_spdif_in, \
1493   .get = snd_hdsp_get_spdif_in, \
1494   .put = snd_hdsp_put_spdif_in }
1495
1496 static unsigned int hdsp_spdif_in(struct hdsp *hdsp)
1497 {
1498         return hdsp_decode_spdif_in(hdsp->control_register & HDSP_SPDIFInputMask);
1499 }
1500
1501 static int hdsp_set_spdif_input(struct hdsp *hdsp, int in)
1502 {
1503         hdsp->control_register &= ~HDSP_SPDIFInputMask;
1504         hdsp->control_register |= hdsp_encode_spdif_in(in);
1505         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1506         return 0;
1507 }
1508
1509 static int snd_hdsp_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1510 {
1511         static char *texts[4] = {"Optical", "Coaxial", "Internal", "AES"};
1512         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1513
1514         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1515         uinfo->count = 1;
1516         uinfo->value.enumerated.items = ((hdsp->io_type == H9632) ? 4 : 3);
1517         if (uinfo->value.enumerated.item > ((hdsp->io_type == H9632) ? 3 : 2))
1518                 uinfo->value.enumerated.item = ((hdsp->io_type == H9632) ? 3 : 2);
1519         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1520         return 0;
1521 }
1522
1523 static int snd_hdsp_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1524 {
1525         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1526
1527         ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp);
1528         return 0;
1529 }
1530
1531 static int snd_hdsp_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1532 {
1533         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1534         int change;
1535         unsigned int val;
1536
1537         if (!snd_hdsp_use_is_exclusive(hdsp))
1538                 return -EBUSY;
1539         val = ucontrol->value.enumerated.item[0] % ((hdsp->io_type == H9632) ? 4 : 3);
1540         spin_lock_irq(&hdsp->lock);
1541         change = val != hdsp_spdif_in(hdsp);
1542         if (change)
1543                 hdsp_set_spdif_input(hdsp, val);
1544         spin_unlock_irq(&hdsp->lock);
1545         return change;
1546 }
1547
1548 #define HDSP_SPDIF_OUT(xname, xindex) \
1549 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1550   .info = snd_hdsp_info_spdif_bits, \
1551   .get = snd_hdsp_get_spdif_out, .put = snd_hdsp_put_spdif_out }
1552
1553 static int hdsp_spdif_out(struct hdsp *hdsp)
1554 {
1555         return (hdsp->control_register & HDSP_SPDIFOpticalOut) ? 1 : 0;
1556 }
1557
1558 static int hdsp_set_spdif_output(struct hdsp *hdsp, int out)
1559 {
1560         if (out)
1561                 hdsp->control_register |= HDSP_SPDIFOpticalOut;
1562         else
1563                 hdsp->control_register &= ~HDSP_SPDIFOpticalOut;
1564         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1565         return 0;
1566 }
1567
1568 static int snd_hdsp_info_spdif_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1569 {
1570         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1571         uinfo->count = 1;
1572         uinfo->value.integer.min = 0;
1573         uinfo->value.integer.max = 1;
1574         return 0;
1575 }
1576
1577 static int snd_hdsp_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1578 {
1579         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1580
1581         ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp);
1582         return 0;
1583 }
1584
1585 static int snd_hdsp_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1586 {
1587         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1588         int change;
1589         unsigned int val;
1590
1591         if (!snd_hdsp_use_is_exclusive(hdsp))
1592                 return -EBUSY;
1593         val = ucontrol->value.integer.value[0] & 1;
1594         spin_lock_irq(&hdsp->lock);
1595         change = (int)val != hdsp_spdif_out(hdsp);
1596         hdsp_set_spdif_output(hdsp, val);
1597         spin_unlock_irq(&hdsp->lock);
1598         return change;
1599 }
1600
1601 #define HDSP_SPDIF_PROFESSIONAL(xname, xindex) \
1602 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1603   .info = snd_hdsp_info_spdif_bits, \
1604   .get = snd_hdsp_get_spdif_professional, .put = snd_hdsp_put_spdif_professional }
1605
1606 static int hdsp_spdif_professional(struct hdsp *hdsp)
1607 {
1608         return (hdsp->control_register & HDSP_SPDIFProfessional) ? 1 : 0;
1609 }
1610
1611 static int hdsp_set_spdif_professional(struct hdsp *hdsp, int val)
1612 {
1613         if (val)
1614                 hdsp->control_register |= HDSP_SPDIFProfessional;
1615         else
1616                 hdsp->control_register &= ~HDSP_SPDIFProfessional;
1617         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1618         return 0;
1619 }
1620
1621 static int snd_hdsp_get_spdif_professional(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1622 {
1623         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1624
1625         ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp);
1626         return 0;
1627 }
1628
1629 static int snd_hdsp_put_spdif_professional(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1630 {
1631         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1632         int change;
1633         unsigned int val;
1634
1635         if (!snd_hdsp_use_is_exclusive(hdsp))
1636                 return -EBUSY;
1637         val = ucontrol->value.integer.value[0] & 1;
1638         spin_lock_irq(&hdsp->lock);
1639         change = (int)val != hdsp_spdif_professional(hdsp);
1640         hdsp_set_spdif_professional(hdsp, val);
1641         spin_unlock_irq(&hdsp->lock);
1642         return change;
1643 }
1644
1645 #define HDSP_SPDIF_EMPHASIS(xname, xindex) \
1646 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1647   .info = snd_hdsp_info_spdif_bits, \
1648   .get = snd_hdsp_get_spdif_emphasis, .put = snd_hdsp_put_spdif_emphasis }
1649
1650 static int hdsp_spdif_emphasis(struct hdsp *hdsp)
1651 {
1652         return (hdsp->control_register & HDSP_SPDIFEmphasis) ? 1 : 0;
1653 }
1654
1655 static int hdsp_set_spdif_emphasis(struct hdsp *hdsp, int val)
1656 {
1657         if (val)
1658                 hdsp->control_register |= HDSP_SPDIFEmphasis;
1659         else
1660                 hdsp->control_register &= ~HDSP_SPDIFEmphasis;
1661         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1662         return 0;
1663 }
1664
1665 static int snd_hdsp_get_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1666 {
1667         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1668
1669         ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp);
1670         return 0;
1671 }
1672
1673 static int snd_hdsp_put_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1674 {
1675         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1676         int change;
1677         unsigned int val;
1678
1679         if (!snd_hdsp_use_is_exclusive(hdsp))
1680                 return -EBUSY;
1681         val = ucontrol->value.integer.value[0] & 1;
1682         spin_lock_irq(&hdsp->lock);
1683         change = (int)val != hdsp_spdif_emphasis(hdsp);
1684         hdsp_set_spdif_emphasis(hdsp, val);
1685         spin_unlock_irq(&hdsp->lock);
1686         return change;
1687 }
1688
1689 #define HDSP_SPDIF_NON_AUDIO(xname, xindex) \
1690 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1691   .info = snd_hdsp_info_spdif_bits, \
1692   .get = snd_hdsp_get_spdif_nonaudio, .put = snd_hdsp_put_spdif_nonaudio }
1693
1694 static int hdsp_spdif_nonaudio(struct hdsp *hdsp)
1695 {
1696         return (hdsp->control_register & HDSP_SPDIFNonAudio) ? 1 : 0;
1697 }
1698
1699 static int hdsp_set_spdif_nonaudio(struct hdsp *hdsp, int val)
1700 {
1701         if (val)
1702                 hdsp->control_register |= HDSP_SPDIFNonAudio;
1703         else
1704                 hdsp->control_register &= ~HDSP_SPDIFNonAudio;
1705         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1706         return 0;
1707 }
1708
1709 static int snd_hdsp_get_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1710 {
1711         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1712
1713         ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp);
1714         return 0;
1715 }
1716
1717 static int snd_hdsp_put_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1718 {
1719         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1720         int change;
1721         unsigned int val;
1722
1723         if (!snd_hdsp_use_is_exclusive(hdsp))
1724                 return -EBUSY;
1725         val = ucontrol->value.integer.value[0] & 1;
1726         spin_lock_irq(&hdsp->lock);
1727         change = (int)val != hdsp_spdif_nonaudio(hdsp);
1728         hdsp_set_spdif_nonaudio(hdsp, val);
1729         spin_unlock_irq(&hdsp->lock);
1730         return change;
1731 }
1732
1733 #define HDSP_SPDIF_SAMPLE_RATE(xname, xindex) \
1734 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1735   .name = xname, \
1736   .index = xindex, \
1737   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1738   .info = snd_hdsp_info_spdif_sample_rate, \
1739   .get = snd_hdsp_get_spdif_sample_rate \
1740 }
1741
1742 static int snd_hdsp_info_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1743 {
1744         static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
1745         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1746
1747         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1748         uinfo->count = 1;
1749         uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7;
1750         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1751                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1752         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1753         return 0;
1754 }
1755
1756 static int snd_hdsp_get_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1757 {
1758         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1759
1760         switch (hdsp_spdif_sample_rate(hdsp)) {
1761         case 32000:
1762                 ucontrol->value.enumerated.item[0] = 0;
1763                 break;
1764         case 44100:
1765                 ucontrol->value.enumerated.item[0] = 1;
1766                 break;
1767         case 48000:
1768                 ucontrol->value.enumerated.item[0] = 2;
1769                 break;
1770         case 64000:
1771                 ucontrol->value.enumerated.item[0] = 3;
1772                 break;
1773         case 88200:
1774                 ucontrol->value.enumerated.item[0] = 4;
1775                 break;
1776         case 96000:
1777                 ucontrol->value.enumerated.item[0] = 5;
1778                 break;
1779         case 128000:
1780                 ucontrol->value.enumerated.item[0] = 7;
1781                 break;
1782         case 176400:
1783                 ucontrol->value.enumerated.item[0] = 8;
1784                 break;
1785         case 192000:
1786                 ucontrol->value.enumerated.item[0] = 9;
1787                 break;
1788         default:
1789                 ucontrol->value.enumerated.item[0] = 6;
1790         }
1791         return 0;
1792 }
1793
1794 #define HDSP_SYSTEM_SAMPLE_RATE(xname, xindex) \
1795 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1796   .name = xname, \
1797   .index = xindex, \
1798   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1799   .info = snd_hdsp_info_system_sample_rate, \
1800   .get = snd_hdsp_get_system_sample_rate \
1801 }
1802
1803 static int snd_hdsp_info_system_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1804 {
1805         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1806         uinfo->count = 1;
1807         return 0;
1808 }
1809
1810 static int snd_hdsp_get_system_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1811 {
1812         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1813
1814         ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate;
1815         return 0;
1816 }
1817
1818 #define HDSP_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
1819 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1820   .name = xname, \
1821   .index = xindex, \
1822   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1823   .info = snd_hdsp_info_autosync_sample_rate, \
1824   .get = snd_hdsp_get_autosync_sample_rate \
1825 }
1826
1827 static int snd_hdsp_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1828 {
1829         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1830         static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
1831         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1832         uinfo->count = 1;
1833         uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7 ;
1834         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1835                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1836         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1837         return 0;
1838 }
1839
1840 static int snd_hdsp_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1841 {
1842         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1843
1844         switch (hdsp_external_sample_rate(hdsp)) {
1845         case 32000:
1846                 ucontrol->value.enumerated.item[0] = 0;
1847                 break;
1848         case 44100:
1849                 ucontrol->value.enumerated.item[0] = 1;
1850                 break;
1851         case 48000:
1852                 ucontrol->value.enumerated.item[0] = 2;
1853                 break;
1854         case 64000:
1855                 ucontrol->value.enumerated.item[0] = 3;
1856                 break;
1857         case 88200:
1858                 ucontrol->value.enumerated.item[0] = 4;
1859                 break;
1860         case 96000:
1861                 ucontrol->value.enumerated.item[0] = 5;
1862                 break;
1863         case 128000:
1864                 ucontrol->value.enumerated.item[0] = 7;
1865                 break;
1866         case 176400:
1867                 ucontrol->value.enumerated.item[0] = 8;
1868                 break;
1869         case 192000:
1870                 ucontrol->value.enumerated.item[0] = 9;
1871                 break;
1872         default:
1873                 ucontrol->value.enumerated.item[0] = 6;
1874         }
1875         return 0;
1876 }
1877
1878 #define HDSP_SYSTEM_CLOCK_MODE(xname, xindex) \
1879 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1880   .name = xname, \
1881   .index = xindex, \
1882   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1883   .info = snd_hdsp_info_system_clock_mode, \
1884   .get = snd_hdsp_get_system_clock_mode \
1885 }
1886
1887 static int hdsp_system_clock_mode(struct hdsp *hdsp)
1888 {
1889         if (hdsp->control_register & HDSP_ClockModeMaster)
1890                 return 0;
1891         else if (hdsp_external_sample_rate(hdsp) != hdsp->system_sample_rate)
1892                         return 0;
1893         return 1;
1894 }
1895
1896 static int snd_hdsp_info_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1897 {
1898         static char *texts[] = {"Master", "Slave" };
1899
1900         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1901         uinfo->count = 1;
1902         uinfo->value.enumerated.items = 2;
1903         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1904                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1905         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1906         return 0;
1907 }
1908
1909 static int snd_hdsp_get_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1910 {
1911         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
1912
1913         ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp);
1914         return 0;
1915 }
1916
1917 #define HDSP_CLOCK_SOURCE(xname, xindex) \
1918 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1919   .name = xname, \
1920   .index = xindex, \
1921   .info = snd_hdsp_info_clock_source, \
1922   .get = snd_hdsp_get_clock_source, \
1923   .put = snd_hdsp_put_clock_source \
1924 }
1925
1926 static int hdsp_clock_source(struct hdsp *hdsp)
1927 {
1928         if (hdsp->control_register & HDSP_ClockModeMaster) {
1929                 switch (hdsp->system_sample_rate) {
1930                 case 32000:
1931                         return 1;
1932                 case 44100:
1933                         return 2;
1934                 case 48000:
1935                         return 3;
1936                 case 64000:
1937                         return 4;
1938                 case 88200:
1939                         return 5;
1940                 case 96000:
1941                         return 6;
1942                 case 128000:
1943                         return 7;
1944                 case 176400:
1945                         return 8;
1946                 case 192000:
1947                         return 9;
1948                 default:
1949                         return 3;
1950                 }
1951         } else {
1952                 return 0;
1953         }
1954 }
1955
1956 static int hdsp_set_clock_source(struct hdsp *hdsp, int mode)
1957 {
1958         int rate;
1959         switch (mode) {
1960         case HDSP_CLOCK_SOURCE_AUTOSYNC:
1961                 if (hdsp_external_sample_rate(hdsp) != 0) {
1962                     if (!hdsp_set_rate(hdsp, hdsp_external_sample_rate(hdsp), 1)) {
1963                         hdsp->control_register &= ~HDSP_ClockModeMaster;
1964                         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1965                         return 0;
1966                     }
1967                 }
1968                 return -1;
1969         case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
1970                 rate = 32000;
1971                 break;
1972         case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
1973                 rate = 44100;
1974                 break;
1975         case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
1976                 rate = 48000;
1977                 break;
1978         case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
1979                 rate = 64000;
1980                 break;
1981         case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
1982                 rate = 88200;
1983                 break;
1984         case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
1985                 rate = 96000;
1986                 break;
1987         case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
1988                 rate = 128000;
1989                 break;
1990         case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
1991                 rate = 176400;
1992                 break;
1993         case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
1994                 rate = 192000;
1995                 break;
1996         default:
1997                 rate = 48000;
1998         }
1999         hdsp->control_register |= HDSP_ClockModeMaster;
2000         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2001         hdsp_set_rate(hdsp, rate, 1);
2002         return 0;
2003 }
2004
2005 static int snd_hdsp_info_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2006 {
2007         static char *texts[] = {"AutoSync", "Internal 32.0 kHz", "Internal 44.1 kHz", "Internal 48.0 kHz", "Internal 64.0 kHz", "Internal 88.2 kHz", "Internal 96.0 kHz", "Internal 128 kHz", "Internal 176.4 kHz", "Internal 192.0 KHz" };
2008         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2009
2010         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2011         uinfo->count = 1;
2012         if (hdsp->io_type == H9632)
2013             uinfo->value.enumerated.items = 10;
2014         else
2015             uinfo->value.enumerated.items = 7;
2016         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2017                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2018         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2019         return 0;
2020 }
2021
2022 static int snd_hdsp_get_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2023 {
2024         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2025
2026         ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp);
2027         return 0;
2028 }
2029
2030 static int snd_hdsp_put_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2031 {
2032         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2033         int change;
2034         int val;
2035
2036         if (!snd_hdsp_use_is_exclusive(hdsp))
2037                 return -EBUSY;
2038         val = ucontrol->value.enumerated.item[0];
2039         if (val < 0) val = 0;
2040         if (hdsp->io_type == H9632) {
2041                 if (val > 9)
2042                         val = 9;
2043         } else {
2044                 if (val > 6)
2045                         val = 6;
2046         }
2047         spin_lock_irq(&hdsp->lock);
2048         if (val != hdsp_clock_source(hdsp))
2049                 change = (hdsp_set_clock_source(hdsp, val) == 0) ? 1 : 0;
2050         else
2051                 change = 0;
2052         spin_unlock_irq(&hdsp->lock);
2053         return change;
2054 }
2055
2056 static int snd_hdsp_info_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2057 {
2058         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2059         uinfo->count = 1;
2060         uinfo->value.integer.min = 0;
2061         uinfo->value.integer.max = 1;
2062         return 0;
2063 }
2064
2065 static int snd_hdsp_get_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2066 {
2067         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2068
2069         ucontrol->value.integer.value[0] = hdsp->clock_source_locked;
2070         return 0;
2071 }
2072
2073 static int snd_hdsp_put_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2074 {
2075         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2076         int change;
2077
2078         change = (int)ucontrol->value.integer.value[0] != hdsp->clock_source_locked;
2079         if (change)
2080                 hdsp->clock_source_locked = ucontrol->value.integer.value[0];
2081         return change;
2082 }
2083
2084 #define HDSP_DA_GAIN(xname, xindex) \
2085 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2086   .name = xname, \
2087   .index = xindex, \
2088   .info = snd_hdsp_info_da_gain, \
2089   .get = snd_hdsp_get_da_gain, \
2090   .put = snd_hdsp_put_da_gain \
2091 }
2092
2093 static int hdsp_da_gain(struct hdsp *hdsp)
2094 {
2095         switch (hdsp->control_register & HDSP_DAGainMask) {
2096         case HDSP_DAGainHighGain:
2097                 return 0;
2098         case HDSP_DAGainPlus4dBu:
2099                 return 1;
2100         case HDSP_DAGainMinus10dBV:
2101                 return 2;
2102         default:
2103                 return 1;
2104         }
2105 }
2106
2107 static int hdsp_set_da_gain(struct hdsp *hdsp, int mode)
2108 {
2109         hdsp->control_register &= ~HDSP_DAGainMask;
2110         switch (mode) {
2111         case 0:
2112                 hdsp->control_register |= HDSP_DAGainHighGain;
2113                 break;
2114         case 1:
2115                 hdsp->control_register |= HDSP_DAGainPlus4dBu;
2116                 break;
2117         case 2:
2118                 hdsp->control_register |= HDSP_DAGainMinus10dBV;
2119                 break;
2120         default:
2121                 return -1;
2122
2123         }
2124         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2125         return 0;
2126 }
2127
2128 static int snd_hdsp_info_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2129 {
2130         static char *texts[] = {"Hi Gain", "+4 dBu", "-10 dbV"};
2131
2132         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2133         uinfo->count = 1;
2134         uinfo->value.enumerated.items = 3;
2135         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2136                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2137         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2138         return 0;
2139 }
2140
2141 static int snd_hdsp_get_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2142 {
2143         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2144
2145         ucontrol->value.enumerated.item[0] = hdsp_da_gain(hdsp);
2146         return 0;
2147 }
2148
2149 static int snd_hdsp_put_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2150 {
2151         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2152         int change;
2153         int val;
2154
2155         if (!snd_hdsp_use_is_exclusive(hdsp))
2156                 return -EBUSY;
2157         val = ucontrol->value.enumerated.item[0];
2158         if (val < 0) val = 0;
2159         if (val > 2) val = 2;
2160         spin_lock_irq(&hdsp->lock);
2161         if (val != hdsp_da_gain(hdsp))
2162                 change = (hdsp_set_da_gain(hdsp, val) == 0) ? 1 : 0;
2163         else
2164                 change = 0;
2165         spin_unlock_irq(&hdsp->lock);
2166         return change;
2167 }
2168
2169 #define HDSP_AD_GAIN(xname, xindex) \
2170 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2171   .name = xname, \
2172   .index = xindex, \
2173   .info = snd_hdsp_info_ad_gain, \
2174   .get = snd_hdsp_get_ad_gain, \
2175   .put = snd_hdsp_put_ad_gain \
2176 }
2177
2178 static int hdsp_ad_gain(struct hdsp *hdsp)
2179 {
2180         switch (hdsp->control_register & HDSP_ADGainMask) {
2181         case HDSP_ADGainMinus10dBV:
2182                 return 0;
2183         case HDSP_ADGainPlus4dBu:
2184                 return 1;
2185         case HDSP_ADGainLowGain:
2186                 return 2;
2187         default:
2188                 return 1;
2189         }
2190 }
2191
2192 static int hdsp_set_ad_gain(struct hdsp *hdsp, int mode)
2193 {
2194         hdsp->control_register &= ~HDSP_ADGainMask;
2195         switch (mode) {
2196         case 0:
2197                 hdsp->control_register |= HDSP_ADGainMinus10dBV;
2198                 break;
2199         case 1:
2200                 hdsp->control_register |= HDSP_ADGainPlus4dBu;
2201                 break;
2202         case 2:
2203                 hdsp->control_register |= HDSP_ADGainLowGain;
2204                 break;
2205         default:
2206                 return -1;
2207
2208         }
2209         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2210         return 0;
2211 }
2212
2213 static int snd_hdsp_info_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2214 {
2215         static char *texts[] = {"-10 dBV", "+4 dBu", "Lo Gain"};
2216
2217         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2218         uinfo->count = 1;
2219         uinfo->value.enumerated.items = 3;
2220         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2221                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2222         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2223         return 0;
2224 }
2225
2226 static int snd_hdsp_get_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2227 {
2228         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2229
2230         ucontrol->value.enumerated.item[0] = hdsp_ad_gain(hdsp);
2231         return 0;
2232 }
2233
2234 static int snd_hdsp_put_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2235 {
2236         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2237         int change;
2238         int val;
2239
2240         if (!snd_hdsp_use_is_exclusive(hdsp))
2241                 return -EBUSY;
2242         val = ucontrol->value.enumerated.item[0];
2243         if (val < 0) val = 0;
2244         if (val > 2) val = 2;
2245         spin_lock_irq(&hdsp->lock);
2246         if (val != hdsp_ad_gain(hdsp))
2247                 change = (hdsp_set_ad_gain(hdsp, val) == 0) ? 1 : 0;
2248         else
2249                 change = 0;
2250         spin_unlock_irq(&hdsp->lock);
2251         return change;
2252 }
2253
2254 #define HDSP_PHONE_GAIN(xname, xindex) \
2255 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2256   .name = xname, \
2257   .index = xindex, \
2258   .info = snd_hdsp_info_phone_gain, \
2259   .get = snd_hdsp_get_phone_gain, \
2260   .put = snd_hdsp_put_phone_gain \
2261 }
2262
2263 static int hdsp_phone_gain(struct hdsp *hdsp)
2264 {
2265         switch (hdsp->control_register & HDSP_PhoneGainMask) {
2266         case HDSP_PhoneGain0dB:
2267                 return 0;
2268         case HDSP_PhoneGainMinus6dB:
2269                 return 1;
2270         case HDSP_PhoneGainMinus12dB:
2271                 return 2;
2272         default:
2273                 return 0;
2274         }
2275 }
2276
2277 static int hdsp_set_phone_gain(struct hdsp *hdsp, int mode)
2278 {
2279         hdsp->control_register &= ~HDSP_PhoneGainMask;
2280         switch (mode) {
2281         case 0:
2282                 hdsp->control_register |= HDSP_PhoneGain0dB;
2283                 break;
2284         case 1:
2285                 hdsp->control_register |= HDSP_PhoneGainMinus6dB;
2286                 break;
2287         case 2:
2288                 hdsp->control_register |= HDSP_PhoneGainMinus12dB;
2289                 break;
2290         default:
2291                 return -1;
2292
2293         }
2294         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2295         return 0;
2296 }
2297
2298 static int snd_hdsp_info_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2299 {
2300         static char *texts[] = {"0 dB", "-6 dB", "-12 dB"};
2301
2302         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2303         uinfo->count = 1;
2304         uinfo->value.enumerated.items = 3;
2305         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2306                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2307         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2308         return 0;
2309 }
2310
2311 static int snd_hdsp_get_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2312 {
2313         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2314
2315         ucontrol->value.enumerated.item[0] = hdsp_phone_gain(hdsp);
2316         return 0;
2317 }
2318
2319 static int snd_hdsp_put_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2320 {
2321         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2322         int change;
2323         int val;
2324
2325         if (!snd_hdsp_use_is_exclusive(hdsp))
2326                 return -EBUSY;
2327         val = ucontrol->value.enumerated.item[0];
2328         if (val < 0) val = 0;
2329         if (val > 2) val = 2;
2330         spin_lock_irq(&hdsp->lock);
2331         if (val != hdsp_phone_gain(hdsp))
2332                 change = (hdsp_set_phone_gain(hdsp, val) == 0) ? 1 : 0;
2333         else
2334                 change = 0;
2335         spin_unlock_irq(&hdsp->lock);
2336         return change;
2337 }
2338
2339 #define HDSP_XLR_BREAKOUT_CABLE(xname, xindex) \
2340 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2341   .name = xname, \
2342   .index = xindex, \
2343   .info = snd_hdsp_info_xlr_breakout_cable, \
2344   .get = snd_hdsp_get_xlr_breakout_cable, \
2345   .put = snd_hdsp_put_xlr_breakout_cable \
2346 }
2347
2348 static int hdsp_xlr_breakout_cable(struct hdsp *hdsp)
2349 {
2350         if (hdsp->control_register & HDSP_XLRBreakoutCable)
2351                 return 1;
2352         return 0;
2353 }
2354
2355 static int hdsp_set_xlr_breakout_cable(struct hdsp *hdsp, int mode)
2356 {
2357         if (mode)
2358                 hdsp->control_register |= HDSP_XLRBreakoutCable;
2359         else
2360                 hdsp->control_register &= ~HDSP_XLRBreakoutCable;
2361         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2362         return 0;
2363 }
2364
2365 static int snd_hdsp_info_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2366 {
2367         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2368         uinfo->count = 1;
2369         uinfo->value.integer.min = 0;
2370         uinfo->value.integer.max = 1;
2371         return 0;
2372 }
2373
2374 static int snd_hdsp_get_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2375 {
2376         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2377
2378         ucontrol->value.enumerated.item[0] = hdsp_xlr_breakout_cable(hdsp);
2379         return 0;
2380 }
2381
2382 static int snd_hdsp_put_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2383 {
2384         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2385         int change;
2386         int val;
2387
2388         if (!snd_hdsp_use_is_exclusive(hdsp))
2389                 return -EBUSY;
2390         val = ucontrol->value.integer.value[0] & 1;
2391         spin_lock_irq(&hdsp->lock);
2392         change = (int)val != hdsp_xlr_breakout_cable(hdsp);
2393         hdsp_set_xlr_breakout_cable(hdsp, val);
2394         spin_unlock_irq(&hdsp->lock);
2395         return change;
2396 }
2397
2398 /* (De)activates old RME Analog Extension Board
2399    These are connected to the internal ADAT connector
2400    Switching this on desactivates external ADAT
2401 */
2402 #define HDSP_AEB(xname, xindex) \
2403 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2404   .name = xname, \
2405   .index = xindex, \
2406   .info = snd_hdsp_info_aeb, \
2407   .get = snd_hdsp_get_aeb, \
2408   .put = snd_hdsp_put_aeb \
2409 }
2410
2411 static int hdsp_aeb(struct hdsp *hdsp)
2412 {
2413         if (hdsp->control_register & HDSP_AnalogExtensionBoard)
2414                 return 1;
2415         return 0;
2416 }
2417
2418 static int hdsp_set_aeb(struct hdsp *hdsp, int mode)
2419 {
2420         if (mode)
2421                 hdsp->control_register |= HDSP_AnalogExtensionBoard;
2422         else
2423                 hdsp->control_register &= ~HDSP_AnalogExtensionBoard;
2424         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2425         return 0;
2426 }
2427
2428 static int snd_hdsp_info_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2429 {
2430         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2431         uinfo->count = 1;
2432         uinfo->value.integer.min = 0;
2433         uinfo->value.integer.max = 1;
2434         return 0;
2435 }
2436
2437 static int snd_hdsp_get_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2438 {
2439         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2440
2441         ucontrol->value.enumerated.item[0] = hdsp_aeb(hdsp);
2442         return 0;
2443 }
2444
2445 static int snd_hdsp_put_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2446 {
2447         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2448         int change;
2449         int val;
2450
2451         if (!snd_hdsp_use_is_exclusive(hdsp))
2452                 return -EBUSY;
2453         val = ucontrol->value.integer.value[0] & 1;
2454         spin_lock_irq(&hdsp->lock);
2455         change = (int)val != hdsp_aeb(hdsp);
2456         hdsp_set_aeb(hdsp, val);
2457         spin_unlock_irq(&hdsp->lock);
2458         return change;
2459 }
2460
2461 #define HDSP_PREF_SYNC_REF(xname, xindex) \
2462 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2463   .name = xname, \
2464   .index = xindex, \
2465   .info = snd_hdsp_info_pref_sync_ref, \
2466   .get = snd_hdsp_get_pref_sync_ref, \
2467   .put = snd_hdsp_put_pref_sync_ref \
2468 }
2469
2470 static int hdsp_pref_sync_ref(struct hdsp *hdsp)
2471 {
2472         /* Notice that this looks at the requested sync source,
2473            not the one actually in use.
2474         */
2475
2476         switch (hdsp->control_register & HDSP_SyncRefMask) {
2477         case HDSP_SyncRef_ADAT1:
2478                 return HDSP_SYNC_FROM_ADAT1;
2479         case HDSP_SyncRef_ADAT2:
2480                 return HDSP_SYNC_FROM_ADAT2;
2481         case HDSP_SyncRef_ADAT3:
2482                 return HDSP_SYNC_FROM_ADAT3;
2483         case HDSP_SyncRef_SPDIF:
2484                 return HDSP_SYNC_FROM_SPDIF;
2485         case HDSP_SyncRef_WORD:
2486                 return HDSP_SYNC_FROM_WORD;
2487         case HDSP_SyncRef_ADAT_SYNC:
2488                 return HDSP_SYNC_FROM_ADAT_SYNC;
2489         default:
2490                 return HDSP_SYNC_FROM_WORD;
2491         }
2492         return 0;
2493 }
2494
2495 static int hdsp_set_pref_sync_ref(struct hdsp *hdsp, int pref)
2496 {
2497         hdsp->control_register &= ~HDSP_SyncRefMask;
2498         switch (pref) {
2499         case HDSP_SYNC_FROM_ADAT1:
2500                 hdsp->control_register &= ~HDSP_SyncRefMask; /* clear SyncRef bits */
2501                 break;
2502         case HDSP_SYNC_FROM_ADAT2:
2503                 hdsp->control_register |= HDSP_SyncRef_ADAT2;
2504                 break;
2505         case HDSP_SYNC_FROM_ADAT3:
2506                 hdsp->control_register |= HDSP_SyncRef_ADAT3;
2507                 break;
2508         case HDSP_SYNC_FROM_SPDIF:
2509                 hdsp->control_register |= HDSP_SyncRef_SPDIF;
2510                 break;
2511         case HDSP_SYNC_FROM_WORD:
2512                 hdsp->control_register |= HDSP_SyncRef_WORD;
2513                 break;
2514         case HDSP_SYNC_FROM_ADAT_SYNC:
2515                 hdsp->control_register |= HDSP_SyncRef_ADAT_SYNC;
2516                 break;
2517         default:
2518                 return -1;
2519         }
2520         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2521         return 0;
2522 }
2523
2524 static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2525 {
2526         static char *texts[] = {"Word", "IEC958", "ADAT1", "ADAT Sync", "ADAT2", "ADAT3" };
2527         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2528
2529         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2530         uinfo->count = 1;
2531
2532         switch (hdsp->io_type) {
2533         case Digiface:
2534         case H9652:
2535                 uinfo->value.enumerated.items = 6;
2536                 break;
2537         case Multiface:
2538                 uinfo->value.enumerated.items = 4;
2539                 break;
2540         case H9632:
2541                 uinfo->value.enumerated.items = 3;
2542                 break;
2543         default:
2544                 uinfo->value.enumerated.items = 0;
2545                 break;
2546         }
2547
2548         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2549                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2550         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2551         return 0;
2552 }
2553
2554 static int snd_hdsp_get_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2555 {
2556         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2557
2558         ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
2559         return 0;
2560 }
2561
2562 static int snd_hdsp_put_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2563 {
2564         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2565         int change, max;
2566         unsigned int val;
2567
2568         if (!snd_hdsp_use_is_exclusive(hdsp))
2569                 return -EBUSY;
2570
2571         switch (hdsp->io_type) {
2572         case Digiface:
2573         case H9652:
2574                 max = 6;
2575                 break;
2576         case Multiface:
2577                 max = 4;
2578                 break;
2579         case H9632:
2580                 max = 3;
2581                 break;
2582         default:
2583                 return -EIO;
2584         }
2585
2586         val = ucontrol->value.enumerated.item[0] % max;
2587         spin_lock_irq(&hdsp->lock);
2588         change = (int)val != hdsp_pref_sync_ref(hdsp);
2589         hdsp_set_pref_sync_ref(hdsp, val);
2590         spin_unlock_irq(&hdsp->lock);
2591         return change;
2592 }
2593
2594 #define HDSP_AUTOSYNC_REF(xname, xindex) \
2595 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2596   .name = xname, \
2597   .index = xindex, \
2598   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
2599   .info = snd_hdsp_info_autosync_ref, \
2600   .get = snd_hdsp_get_autosync_ref, \
2601 }
2602
2603 static int hdsp_autosync_ref(struct hdsp *hdsp)
2604 {
2605         /* This looks at the autosync selected sync reference */
2606         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
2607
2608         switch (status2 & HDSP_SelSyncRefMask) {
2609         case HDSP_SelSyncRef_WORD:
2610                 return HDSP_AUTOSYNC_FROM_WORD;
2611         case HDSP_SelSyncRef_ADAT_SYNC:
2612                 return HDSP_AUTOSYNC_FROM_ADAT_SYNC;
2613         case HDSP_SelSyncRef_SPDIF:
2614                 return HDSP_AUTOSYNC_FROM_SPDIF;
2615         case HDSP_SelSyncRefMask:
2616                 return HDSP_AUTOSYNC_FROM_NONE;
2617         case HDSP_SelSyncRef_ADAT1:
2618                 return HDSP_AUTOSYNC_FROM_ADAT1;
2619         case HDSP_SelSyncRef_ADAT2:
2620                 return HDSP_AUTOSYNC_FROM_ADAT2;
2621         case HDSP_SelSyncRef_ADAT3:
2622                 return HDSP_AUTOSYNC_FROM_ADAT3;
2623         default:
2624                 return HDSP_AUTOSYNC_FROM_WORD;
2625         }
2626         return 0;
2627 }
2628
2629 static int snd_hdsp_info_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2630 {
2631         static char *texts[] = {"Word", "ADAT Sync", "IEC958", "None", "ADAT1", "ADAT2", "ADAT3" };
2632
2633         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2634         uinfo->count = 1;
2635         uinfo->value.enumerated.items = 7;
2636         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2637                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2638         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2639         return 0;
2640 }
2641
2642 static int snd_hdsp_get_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2643 {
2644         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2645
2646         ucontrol->value.enumerated.item[0] = hdsp_autosync_ref(hdsp);
2647         return 0;
2648 }
2649
2650 #define HDSP_LINE_OUT(xname, xindex) \
2651 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2652   .name = xname, \
2653   .index = xindex, \
2654   .info = snd_hdsp_info_line_out, \
2655   .get = snd_hdsp_get_line_out, \
2656   .put = snd_hdsp_put_line_out \
2657 }
2658
2659 static int hdsp_line_out(struct hdsp *hdsp)
2660 {
2661         return (hdsp->control_register & HDSP_LineOut) ? 1 : 0;
2662 }
2663
2664 static int hdsp_set_line_output(struct hdsp *hdsp, int out)
2665 {
2666         if (out)
2667                 hdsp->control_register |= HDSP_LineOut;
2668         else
2669                 hdsp->control_register &= ~HDSP_LineOut;
2670         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2671         return 0;
2672 }
2673
2674 static int snd_hdsp_info_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2675 {
2676         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2677         uinfo->count = 1;
2678         uinfo->value.integer.min = 0;
2679         uinfo->value.integer.max = 1;
2680         return 0;
2681 }
2682
2683 static int snd_hdsp_get_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2684 {
2685         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2686
2687         spin_lock_irq(&hdsp->lock);
2688         ucontrol->value.integer.value[0] = hdsp_line_out(hdsp);
2689         spin_unlock_irq(&hdsp->lock);
2690         return 0;
2691 }
2692
2693 static int snd_hdsp_put_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2694 {
2695         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2696         int change;
2697         unsigned int val;
2698
2699         if (!snd_hdsp_use_is_exclusive(hdsp))
2700                 return -EBUSY;
2701         val = ucontrol->value.integer.value[0] & 1;
2702         spin_lock_irq(&hdsp->lock);
2703         change = (int)val != hdsp_line_out(hdsp);
2704         hdsp_set_line_output(hdsp, val);
2705         spin_unlock_irq(&hdsp->lock);
2706         return change;
2707 }
2708
2709 #define HDSP_PRECISE_POINTER(xname, xindex) \
2710 { .iface = SNDRV_CTL_ELEM_IFACE_CARD, \
2711   .name = xname, \
2712   .index = xindex, \
2713   .info = snd_hdsp_info_precise_pointer, \
2714   .get = snd_hdsp_get_precise_pointer, \
2715   .put = snd_hdsp_put_precise_pointer \
2716 }
2717
2718 static int hdsp_set_precise_pointer(struct hdsp *hdsp, int precise)
2719 {
2720         if (precise)
2721                 hdsp->precise_ptr = 1;
2722         else
2723                 hdsp->precise_ptr = 0;
2724         return 0;
2725 }
2726
2727 static int snd_hdsp_info_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2728 {
2729         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2730         uinfo->count = 1;
2731         uinfo->value.integer.min = 0;
2732         uinfo->value.integer.max = 1;
2733         return 0;
2734 }
2735
2736 static int snd_hdsp_get_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2737 {
2738         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2739
2740         spin_lock_irq(&hdsp->lock);
2741         ucontrol->value.integer.value[0] = hdsp->precise_ptr;
2742         spin_unlock_irq(&hdsp->lock);
2743         return 0;
2744 }
2745
2746 static int snd_hdsp_put_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2747 {
2748         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2749         int change;
2750         unsigned int val;
2751
2752         if (!snd_hdsp_use_is_exclusive(hdsp))
2753                 return -EBUSY;
2754         val = ucontrol->value.integer.value[0] & 1;
2755         spin_lock_irq(&hdsp->lock);
2756         change = (int)val != hdsp->precise_ptr;
2757         hdsp_set_precise_pointer(hdsp, val);
2758         spin_unlock_irq(&hdsp->lock);
2759         return change;
2760 }
2761
2762 #define HDSP_USE_MIDI_TASKLET(xname, xindex) \
2763 { .iface = SNDRV_CTL_ELEM_IFACE_CARD, \
2764   .name = xname, \
2765   .index = xindex, \
2766   .info = snd_hdsp_info_use_midi_tasklet, \
2767   .get = snd_hdsp_get_use_midi_tasklet, \
2768   .put = snd_hdsp_put_use_midi_tasklet \
2769 }
2770
2771 static int hdsp_set_use_midi_tasklet(struct hdsp *hdsp, int use_tasklet)
2772 {
2773         if (use_tasklet)
2774                 hdsp->use_midi_tasklet = 1;
2775         else
2776                 hdsp->use_midi_tasklet = 0;
2777         return 0;
2778 }
2779
2780 static int snd_hdsp_info_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2781 {
2782         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2783         uinfo->count = 1;
2784         uinfo->value.integer.min = 0;
2785         uinfo->value.integer.max = 1;
2786         return 0;
2787 }
2788
2789 static int snd_hdsp_get_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2790 {
2791         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2792
2793         spin_lock_irq(&hdsp->lock);
2794         ucontrol->value.integer.value[0] = hdsp->use_midi_tasklet;
2795         spin_unlock_irq(&hdsp->lock);
2796         return 0;
2797 }
2798
2799 static int snd_hdsp_put_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2800 {
2801         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2802         int change;
2803         unsigned int val;
2804
2805         if (!snd_hdsp_use_is_exclusive(hdsp))
2806                 return -EBUSY;
2807         val = ucontrol->value.integer.value[0] & 1;
2808         spin_lock_irq(&hdsp->lock);
2809         change = (int)val != hdsp->use_midi_tasklet;
2810         hdsp_set_use_midi_tasklet(hdsp, val);
2811         spin_unlock_irq(&hdsp->lock);
2812         return change;
2813 }
2814
2815 #define HDSP_MIXER(xname, xindex) \
2816 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2817   .name = xname, \
2818   .index = xindex, \
2819   .device = 0, \
2820   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2821                  SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2822   .info = snd_hdsp_info_mixer, \
2823   .get = snd_hdsp_get_mixer, \
2824   .put = snd_hdsp_put_mixer \
2825 }
2826
2827 static int snd_hdsp_info_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2828 {
2829         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2830         uinfo->count = 3;
2831         uinfo->value.integer.min = 0;
2832         uinfo->value.integer.max = 65536;
2833         uinfo->value.integer.step = 1;
2834         return 0;
2835 }
2836
2837 static int snd_hdsp_get_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2838 {
2839         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2840         int source;
2841         int destination;
2842         int addr;
2843
2844         source = ucontrol->value.integer.value[0];
2845         destination = ucontrol->value.integer.value[1];
2846
2847         if (source >= hdsp->max_channels)
2848                 addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels,destination);
2849         else
2850                 addr = hdsp_input_to_output_key(hdsp,source, destination);
2851
2852         spin_lock_irq(&hdsp->lock);
2853         ucontrol->value.integer.value[2] = hdsp_read_gain (hdsp, addr);
2854         spin_unlock_irq(&hdsp->lock);
2855         return 0;
2856 }
2857
2858 static int snd_hdsp_put_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2859 {
2860         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2861         int change;
2862         int source;
2863         int destination;
2864         int gain;
2865         int addr;
2866
2867         if (!snd_hdsp_use_is_exclusive(hdsp))
2868                 return -EBUSY;
2869
2870         source = ucontrol->value.integer.value[0];
2871         destination = ucontrol->value.integer.value[1];
2872
2873         if (source >= hdsp->max_channels)
2874                 addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels, destination);
2875         else
2876                 addr = hdsp_input_to_output_key(hdsp,source, destination);
2877
2878         gain = ucontrol->value.integer.value[2];
2879
2880         spin_lock_irq(&hdsp->lock);
2881         change = gain != hdsp_read_gain(hdsp, addr);
2882         if (change)
2883                 hdsp_write_gain(hdsp, addr, gain);
2884         spin_unlock_irq(&hdsp->lock);
2885         return change;
2886 }
2887
2888 #define HDSP_WC_SYNC_CHECK(xname, xindex) \
2889 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2890   .name = xname, \
2891   .index = xindex, \
2892   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2893   .info = snd_hdsp_info_sync_check, \
2894   .get = snd_hdsp_get_wc_sync_check \
2895 }
2896
2897 static int snd_hdsp_info_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2898 {
2899         static char *texts[] = {"No Lock", "Lock", "Sync" };
2900         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2901         uinfo->count = 1;
2902         uinfo->value.enumerated.items = 3;
2903         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2904                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2905         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2906         return 0;
2907 }
2908
2909 static int hdsp_wc_sync_check(struct hdsp *hdsp)
2910 {
2911         int status2 = hdsp_read(hdsp, HDSP_status2Register);
2912         if (status2 & HDSP_wc_lock) {
2913                 if (status2 & HDSP_wc_sync)
2914                         return 2;
2915                 else
2916                          return 1;
2917         } else
2918                 return 0;
2919         return 0;
2920 }
2921
2922 static int snd_hdsp_get_wc_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2923 {
2924         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2925
2926         ucontrol->value.enumerated.item[0] = hdsp_wc_sync_check(hdsp);
2927         return 0;
2928 }
2929
2930 #define HDSP_SPDIF_SYNC_CHECK(xname, xindex) \
2931 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2932   .name = xname, \
2933   .index = xindex, \
2934   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2935   .info = snd_hdsp_info_sync_check, \
2936   .get = snd_hdsp_get_spdif_sync_check \
2937 }
2938
2939 static int hdsp_spdif_sync_check(struct hdsp *hdsp)
2940 {
2941         int status = hdsp_read(hdsp, HDSP_statusRegister);
2942         if (status & HDSP_SPDIFErrorFlag)
2943                 return 0;
2944         else {
2945                 if (status & HDSP_SPDIFSync)
2946                         return 2;
2947                 else
2948                         return 1;
2949         }
2950         return 0;
2951 }
2952
2953 static int snd_hdsp_get_spdif_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2954 {
2955         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2956
2957         ucontrol->value.enumerated.item[0] = hdsp_spdif_sync_check(hdsp);
2958         return 0;
2959 }
2960
2961 #define HDSP_ADATSYNC_SYNC_CHECK(xname, xindex) \
2962 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2963   .name = xname, \
2964   .index = xindex, \
2965   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2966   .info = snd_hdsp_info_sync_check, \
2967   .get = snd_hdsp_get_adatsync_sync_check \
2968 }
2969
2970 static int hdsp_adatsync_sync_check(struct hdsp *hdsp)
2971 {
2972         int status = hdsp_read(hdsp, HDSP_statusRegister);
2973         if (status & HDSP_TimecodeLock) {
2974                 if (status & HDSP_TimecodeSync)
2975                         return 2;
2976                 else
2977                         return 1;
2978         } else
2979                 return 0;
2980 }
2981
2982 static int snd_hdsp_get_adatsync_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2983 {
2984         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
2985
2986         ucontrol->value.enumerated.item[0] = hdsp_adatsync_sync_check(hdsp);
2987         return 0;
2988 }
2989
2990 #define HDSP_ADAT_SYNC_CHECK \
2991 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2992   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2993   .info = snd_hdsp_info_sync_check, \
2994   .get = snd_hdsp_get_adat_sync_check \
2995 }
2996
2997 static int hdsp_adat_sync_check(struct hdsp *hdsp, int idx)
2998 {
2999         int status = hdsp_read(hdsp, HDSP_statusRegister);
3000
3001         if (status & (HDSP_Lock0>>idx)) {
3002                 if (status & (HDSP_Sync0>>idx))
3003                         return 2;
3004                 else
3005                         return 1;
3006         } else
3007                 return 0;
3008 }
3009
3010 static int snd_hdsp_get_adat_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
3011 {
3012         int offset;
3013         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
3014
3015         offset = ucontrol->id.index - 1;
3016         snd_assert(offset >= 0);
3017
3018         switch (hdsp->io_type) {
3019         case Digiface:
3020         case H9652:
3021                 if (offset >= 3)
3022                         return -EINVAL;
3023                 break;
3024         case Multiface:
3025         case H9632:
3026                 if (offset >= 1)
3027                         return -EINVAL;
3028                 break;
3029         default:
3030                 return -EIO;
3031         }
3032
3033         ucontrol->value.enumerated.item[0] = hdsp_adat_sync_check(hdsp, offset);
3034         return 0;
3035 }
3036
3037 static struct snd_kcontrol_new snd_hdsp_9632_controls[] = {
3038 HDSP_DA_GAIN("DA Gain", 0),
3039 HDSP_AD_GAIN("AD Gain", 0),
3040 HDSP_PHONE_GAIN("Phones Gain", 0),
3041 HDSP_XLR_BREAKOUT_CABLE("XLR Breakout Cable", 0)
3042 };
3043
3044 static struct snd_kcontrol_new snd_hdsp_controls[] = {
3045 {
3046         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3047         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
3048         .info =         snd_hdsp_control_spdif_info,
3049         .get =          snd_hdsp_control_spdif_get,
3050         .put =          snd_hdsp_control_spdif_put,
3051 },
3052 {
3053         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
3054         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3055         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
3056         .info =         snd_hdsp_control_spdif_stream_info,
3057         .get =          snd_hdsp_control_spdif_stream_get,
3058         .put =          snd_hdsp_control_spdif_stream_put,
3059 },
3060 {
3061         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
3062         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3063         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
3064         .info =         snd_hdsp_control_spdif_mask_info,
3065         .get =          snd_hdsp_control_spdif_mask_get,
3066         .private_value = IEC958_AES0_NONAUDIO |
3067                          IEC958_AES0_PROFESSIONAL |
3068                          IEC958_AES0_CON_EMPHASIS,
3069 },
3070 {
3071         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
3072         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3073         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
3074         .info =         snd_hdsp_control_spdif_mask_info,
3075         .get =          snd_hdsp_control_spdif_mask_get,
3076         .private_value = IEC958_AES0_NONAUDIO |
3077                          IEC958_AES0_PROFESSIONAL |
3078                          IEC958_AES0_PRO_EMPHASIS,
3079 },
3080 HDSP_MIXER("Mixer", 0),
3081 HDSP_SPDIF_IN("IEC958 Input Connector", 0),
3082 HDSP_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
3083 HDSP_SPDIF_PROFESSIONAL("IEC958 Professional Bit", 0),
3084 HDSP_SPDIF_EMPHASIS("IEC958 Emphasis Bit", 0),
3085 HDSP_SPDIF_NON_AUDIO("IEC958 Non-audio Bit", 0),
3086 /* 'Sample Clock Source' complies with the alsa control naming scheme */
3087 HDSP_CLOCK_SOURCE("Sample Clock Source", 0),
3088 {
3089         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3090         .name = "Sample Clock Source Locking",
3091         .info = snd_hdsp_info_clock_source_lock,
3092         .get = snd_hdsp_get_clock_source_lock,
3093         .put = snd_hdsp_put_clock_source_lock,
3094 },
3095 HDSP_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
3096 HDSP_PREF_SYNC_REF("Preferred Sync Reference", 0),
3097 HDSP_AUTOSYNC_REF("AutoSync Reference", 0),
3098 HDSP_SPDIF_SAMPLE_RATE("SPDIF Sample Rate", 0),
3099 HDSP_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
3100 /* 'External Rate' complies with the alsa control naming scheme */
3101 HDSP_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
3102 HDSP_WC_SYNC_CHECK("Word Clock Lock Status", 0),
3103 HDSP_SPDIF_SYNC_CHECK("SPDIF Lock Status", 0),
3104 HDSP_ADATSYNC_SYNC_CHECK("ADAT Sync Lock Status", 0),
3105 HDSP_LINE_OUT("Line Out", 0),
3106 HDSP_PRECISE_POINTER("Precise Pointer", 0),
3107 HDSP_USE_MIDI_TASKLET("Use Midi Tasklet", 0),
3108 };
3109
3110 static struct snd_kcontrol_new snd_hdsp_96xx_aeb = HDSP_AEB("Analog Extension Board", 0);
3111 static struct snd_kcontrol_new snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK;
3112
3113 static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp)
3114 {
3115         unsigned int idx;
3116         int err;
3117         struct snd_kcontrol *kctl;
3118
3119         for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_controls); idx++) {
3120                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_controls[idx], hdsp))) < 0)
3121                         return err;
3122                 if (idx == 1)   /* IEC958 (S/PDIF) Stream */
3123                         hdsp->spdif_ctl = kctl;
3124         }
3125
3126         /* ADAT SyncCheck status */
3127         snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
3128         snd_hdsp_adat_sync_check.index = 1;
3129         if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp))))
3130                 return err;
3131         if (hdsp->io_type == Digiface || hdsp->io_type == H9652) {
3132                 for (idx = 1; idx < 3; ++idx) {
3133                         snd_hdsp_adat_sync_check.index = idx+1;
3134                         if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp))))
3135                                 return err;
3136                 }
3137         }
3138
3139         /* DA, AD and Phone gain and XLR breakout cable controls for H9632 cards */
3140         if (hdsp->io_type == H9632) {
3141                 for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_9632_controls); idx++) {
3142                         if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_9632_controls[idx], hdsp))) < 0)
3143                                 return err;
3144                 }
3145         }
3146
3147         /* AEB control for H96xx card */
3148         if (hdsp->io_type == H9632 || hdsp->io_type == H9652) {
3149                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_96xx_aeb, hdsp))) < 0)
3150                                 return err;
3151         }
3152
3153         return 0;
3154 }
3155
3156 /*------------------------------------------------------------
3157    /proc interface
3158  ------------------------------------------------------------*/
3159
3160 static void
3161 snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3162 {
3163         struct hdsp *hdsp = (struct hdsp *) entry->private_data;
3164         unsigned int status;
3165         unsigned int status2;
3166         char *pref_sync_ref;
3167         char *autosync_ref;
3168         char *system_clock_mode;
3169         char *clock_source;
3170         int x;
3171
3172         if (hdsp_check_for_iobox (hdsp))
3173                 snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
3174                 return;
3175
3176         if (hdsp_check_for_firmware(hdsp, 0)) {
3177                 if (hdsp->state & HDSP_FirmwareCached) {
3178                         if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
3179                                 snd_iprintf(buffer, "Firmware loading from cache failed, please upload manually.\n");
3180                                 return;
3181                         }
3182                 } else {
3183                         snd_iprintf(buffer, "No firmware loaded nor cached, please upload firmware.\n");
3184                         return;
3185                 }
3186         }
3187
3188         status = hdsp_read(hdsp, HDSP_statusRegister);
3189         status2 = hdsp_read(hdsp, HDSP_status2Register);
3190
3191         snd_iprintf(buffer, "%s (Card #%d)\n", hdsp->card_name, hdsp->card->number + 1);
3192         snd_iprintf(buffer, "Buffers: capture %p playback %p\n",
3193                     hdsp->capture_buffer, hdsp->playback_buffer);
3194         snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
3195                     hdsp->irq, hdsp->port, (unsigned long)hdsp->iobase);
3196         snd_iprintf(buffer, "Control register: 0x%x\n", hdsp->control_register);
3197         snd_iprintf(buffer, "Control2 register: 0x%x\n", hdsp->control2_register);
3198         snd_iprintf(buffer, "Status register: 0x%x\n", status);
3199         snd_iprintf(buffer, "Status2 register: 0x%x\n", status2);
3200         snd_iprintf(buffer, "FIFO status: %d\n", hdsp_read(hdsp, HDSP_fifoStatus) & 0xff);
3201         snd_iprintf(buffer, "MIDI1 Output status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusOut0));
3202         snd_iprintf(buffer, "MIDI1 Input status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusIn0));
3203         snd_iprintf(buffer, "MIDI2 Output status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusOut1));
3204         snd_iprintf(buffer, "MIDI2 Input status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusIn1));
3205         snd_iprintf(buffer, "Use Midi Tasklet: %s\n", hdsp->use_midi_tasklet ? "on" : "off");
3206
3207         snd_iprintf(buffer, "\n");
3208
3209         x = 1 << (6 + hdsp_decode_latency(hdsp->control_register & HDSP_LatencyMask));
3210
3211         snd_iprintf(buffer, "Buffer Size (Latency): %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
3212         snd_iprintf(buffer, "Hardware pointer (frames): %ld\n", hdsp_hw_pointer(hdsp));
3213         snd_iprintf(buffer, "Precise pointer: %s\n", hdsp->precise_ptr ? "on" : "off");
3214         snd_iprintf(buffer, "Line out: %s\n", (hdsp->control_register & HDSP_LineOut) ? "on" : "off");
3215
3216         snd_iprintf(buffer, "Firmware version: %d\n", (status2&HDSP_version0)|(status2&HDSP_version1)<<1|(status2&HDSP_version2)<<2);
3217
3218         snd_iprintf(buffer, "\n");
3219
3220
3221         switch (hdsp_clock_source(hdsp)) {
3222         case HDSP_CLOCK_SOURCE_AUTOSYNC:
3223                 clock_source = "AutoSync";
3224                 break;
3225         case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
3226                 clock_source = "Internal 32 kHz";
3227                 break;
3228         case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
3229                 clock_source = "Internal 44.1 kHz";
3230                 break;
3231         case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
3232                 clock_source = "Internal 48 kHz";
3233                 break;
3234         case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
3235                 clock_source = "Internal 64 kHz";
3236                 break;
3237         case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
3238                 clock_source = "Internal 88.2 kHz";
3239                 break;
3240         case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
3241                 clock_source = "Internal 96 kHz";
3242                 break;
3243         case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
3244                 clock_source = "Internal 128 kHz";
3245                 break;
3246         case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
3247                 clock_source = "Internal 176.4 kHz";
3248                 break;
3249                 case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
3250                 clock_source = "Internal 192 kHz";
3251                 break;
3252         default:
3253                 clock_source = "Error";
3254         }
3255         snd_iprintf (buffer, "Sample Clock Source: %s\n", clock_source);
3256
3257         if (hdsp_system_clock_mode(hdsp))
3258                 system_clock_mode = "Slave";
3259         else
3260                 system_clock_mode = "Master";
3261
3262         switch (hdsp_pref_sync_ref (hdsp)) {
3263         case HDSP_SYNC_FROM_WORD:
3264                 pref_sync_ref = "Word Clock";
3265                 break;
3266         case HDSP_SYNC_FROM_ADAT_SYNC:
3267                 pref_sync_ref = "ADAT Sync";
3268                 break;
3269         case HDSP_SYNC_FROM_SPDIF:
3270                 pref_sync_ref = "SPDIF";
3271                 break;
3272         case HDSP_SYNC_FROM_ADAT1:
3273                 pref_sync_ref = "ADAT1";
3274                 break;
3275         case HDSP_SYNC_FROM_ADAT2:
3276                 pref_sync_ref = "ADAT2";
3277                 break;
3278         case HDSP_SYNC_FROM_ADAT3:
3279                 pref_sync_ref = "ADAT3";
3280                 break;
3281         default:
3282                 pref_sync_ref = "Word Clock";
3283                 break;
3284         }
3285         snd_iprintf (buffer, "Preferred Sync Reference: %s\n", pref_sync_ref);
3286
3287         switch (hdsp_autosync_ref (hdsp)) {
3288         case HDSP_AUTOSYNC_FROM_WORD:
3289                 autosync_ref = "Word Clock";
3290                 break;
3291         case HDSP_AUTOSYNC_FROM_ADAT_SYNC:
3292                 autosync_ref = "ADAT Sync";
3293                 break;
3294         case HDSP_AUTOSYNC_FROM_SPDIF:
3295                 autosync_ref = "SPDIF";
3296                 break;
3297         case HDSP_AUTOSYNC_FROM_NONE:
3298                 autosync_ref = "None";
3299                 break;
3300         case HDSP_AUTOSYNC_FROM_ADAT1:
3301                 autosync_ref = "ADAT1";
3302                 break;
3303         case HDSP_AUTOSYNC_FROM_ADAT2:
3304                 autosync_ref = "ADAT2";
3305                 break;
3306         case HDSP_AUTOSYNC_FROM_ADAT3:
3307                 autosync_ref = "ADAT3";
3308                 break;
3309         default:
3310                 autosync_ref = "---";
3311                 break;
3312         }
3313         snd_iprintf (buffer, "AutoSync Reference: %s\n", autosync_ref);
3314
3315         snd_iprintf (buffer, "AutoSync Frequency: %d\n", hdsp_external_sample_rate(hdsp));
3316
3317         snd_iprintf (buffer, "System Clock Mode: %s\n", system_clock_mode);
3318
3319         snd_iprintf (buffer, "System Clock Frequency: %d\n", hdsp->system_sample_rate);
3320         snd_iprintf (buffer, "System Clock Locked: %s\n", hdsp->clock_source_locked ? "Yes" : "No");
3321
3322         snd_iprintf(buffer, "\n");
3323
3324         switch (hdsp_spdif_in(hdsp)) {
3325         case HDSP_SPDIFIN_OPTICAL:
3326                 snd_iprintf(buffer, "IEC958 input: Optical\n");
3327                 break;
3328         case HDSP_SPDIFIN_COAXIAL:
3329                 snd_iprintf(buffer, "IEC958 input: Coaxial\n");
3330                 break;
3331         case HDSP_SPDIFIN_INTERNAL:
3332                 snd_iprintf(buffer, "IEC958 input: Internal\n");
3333                 break;
3334         case HDSP_SPDIFIN_AES:
3335                 snd_iprintf(buffer, "IEC958 input: AES\n");
3336                 break;
3337         default:
3338                 snd_iprintf(buffer, "IEC958 input: ???\n");
3339                 break;
3340         }
3341
3342         if (hdsp->control_register & HDSP_SPDIFOpticalOut)
3343                 snd_iprintf(buffer, "IEC958 output: Coaxial & ADAT1\n");
3344         else
3345                 snd_iprintf(buffer, "IEC958 output: Coaxial only\n");
3346
3347         if (hdsp->control_register & HDSP_SPDIFProfessional)
3348                 snd_iprintf(buffer, "IEC958 quality: Professional\n");
3349         else
3350                 snd_iprintf(buffer, "IEC958 quality: Consumer\n");
3351
3352         if (hdsp->control_register & HDSP_SPDIFEmphasis)
3353                 snd_iprintf(buffer, "IEC958 emphasis: on\n");
3354         else
3355                 snd_iprintf(buffer, "IEC958 emphasis: off\n");
3356
3357         if (hdsp->control_register & HDSP_SPDIFNonAudio)
3358                 snd_iprintf(buffer, "IEC958 NonAudio: on\n");
3359         else
3360                 snd_iprintf(buffer, "IEC958 NonAudio: off\n");
3361         if ((x = hdsp_spdif_sample_rate (hdsp)) != 0)
3362                 snd_iprintf (buffer, "IEC958 sample rate: %d\n", x);
3363         else
3364                 snd_iprintf (buffer, "IEC958 sample rate: Error flag set\n");
3365
3366         snd_iprintf(buffer, "\n");
3367
3368         /* Sync Check */
3369         x = status & HDSP_Sync0;
3370         if (status & HDSP_Lock0)
3371                 snd_iprintf(buffer, "ADAT1: %s\n", x ? "Sync" : "Lock");
3372         else
3373                 snd_iprintf(buffer, "ADAT1: No Lock\n");
3374
3375         switch (hdsp->io_type) {
3376         case Digiface:
3377         case H9652:
3378                 x = status & HDSP_Sync1;
3379                 if (status & HDSP_Lock1)
3380                         snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
3381                 else
3382                         snd_iprintf(buffer, "ADAT2: No Lock\n");
3383                 x = status & HDSP_Sync2;
3384                 if (status & HDSP_Lock2)
3385                         snd_iprintf(buffer, "ADAT3: %s\n", x ? "Sync" : "Lock");
3386                 else
3387                         snd_iprintf(buffer, "ADAT3: No Lock\n");
3388                 break;
3389         default:
3390                 /* relax */
3391                 break;
3392         }
3393
3394         x = status & HDSP_SPDIFSync;
3395         if (status & HDSP_SPDIFErrorFlag)
3396                 snd_iprintf (buffer, "SPDIF: No Lock\n");
3397         else
3398                 snd_iprintf (buffer, "SPDIF: %s\n", x ? "Sync" : "Lock");
3399
3400         x = status2 & HDSP_wc_sync;
3401         if (status2 & HDSP_wc_lock)
3402                 snd_iprintf (buffer, "Word Clock: %s\n", x ? "Sync" : "Lock");
3403         else
3404                 snd_iprintf (buffer, "Word Clock: No Lock\n");
3405
3406         x = status & HDSP_TimecodeSync;
3407         if (status & HDSP_TimecodeLock)
3408                 snd_iprintf(buffer, "ADAT Sync: %s\n", x ? "Sync" : "Lock");
3409         else
3410                 snd_iprintf(buffer, "ADAT Sync: No Lock\n");
3411
3412         snd_iprintf(buffer, "\n");
3413
3414         /* Informations about H9632 specific controls */
3415         if (hdsp->io_type == H9632) {
3416                 char *tmp;
3417
3418                 switch (hdsp_ad_gain(hdsp)) {
3419                 case 0:
3420                         tmp = "-10 dBV";
3421                         break;
3422                 case 1:
3423                         tmp = "+4 dBu";
3424                         break;
3425                 default:
3426                         tmp = "Lo Gain";
3427                         break;
3428                 }
3429                 snd_iprintf(buffer, "AD Gain : %s\n", tmp);
3430
3431                 switch (hdsp_da_gain(hdsp)) {
3432                 case 0:
3433                         tmp = "Hi Gain";
3434                         break;
3435                 case 1:
3436                         tmp = "+4 dBu";
3437                         break;
3438                 default:
3439                         tmp = "-10 dBV";
3440                         break;
3441                 }
3442                 snd_iprintf(buffer, "DA Gain : %s\n", tmp);
3443
3444                 switch (hdsp_phone_gain(hdsp)) {
3445                 case 0:
3446                         tmp = "0 dB";
3447                         break;
3448                 case 1:
3449                         tmp = "-6 dB";
3450                         break;
3451                 default:
3452                         tmp = "-12 dB";
3453                         break;
3454                 }
3455                 snd_iprintf(buffer, "Phones Gain : %s\n", tmp);
3456
3457                 snd_iprintf(buffer, "XLR Breakout Cable : %s\n", hdsp_xlr_breakout_cable(hdsp) ? "yes" : "no");
3458
3459                 if (hdsp->control_register & HDSP_AnalogExtensionBoard)
3460                         snd_iprintf(buffer, "AEB : on (ADAT1 internal)\n");
3461                 else
3462                         snd_iprintf(buffer, "AEB : off (ADAT1 external)\n");
3463                 snd_iprintf(buffer, "\n");
3464         }
3465
3466 }
3467
3468 static void __devinit snd_hdsp_proc_init(struct hdsp *hdsp)
3469 {
3470         struct snd_info_entry *entry;
3471
3472         if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
3473                 snd_info_set_text_ops(entry, hdsp, 1024, snd_hdsp_proc_read);
3474 }
3475
3476 static void snd_hdsp_free_buffers(struct hdsp *hdsp)
3477 {
3478         snd_hammerfall_free_buffer(&hdsp->capture_dma_buf, hdsp->pci);
3479         snd_hammerfall_free_buffer(&hdsp->playback_dma_buf, hdsp->pci);
3480 }
3481
3482 static int __devinit snd_hdsp_initialize_memory(struct hdsp *hdsp)
3483 {
3484         unsigned long pb_bus, cb_bus;
3485
3486         if (snd_hammerfall_get_buffer(hdsp->pci, &hdsp->capture_dma_buf, HDSP_DMA_AREA_BYTES) < 0 ||
3487             snd_hammerfall_get_buffer(hdsp->pci, &hdsp->playback_dma_buf, HDSP_DMA_AREA_BYTES) < 0) {
3488                 if (hdsp->capture_dma_buf.area)
3489                         snd_dma_free_pages(&hdsp->capture_dma_buf);
3490                 printk(KERN_ERR "%s: no buffers available\n", hdsp->card_name);
3491                 return -ENOMEM;
3492         }
3493
3494         /* Align to bus-space 64K boundary */
3495
3496         cb_bus = (hdsp->capture_dma_buf.addr + 0xFFFF) & ~0xFFFFl;
3497         pb_bus = (hdsp->playback_dma_buf.addr + 0xFFFF) & ~0xFFFFl;
3498
3499         /* Tell the card where it is */
3500
3501         hdsp_write(hdsp, HDSP_inputBufferAddress, cb_bus);
3502         hdsp_write(hdsp, HDSP_outputBufferAddress, pb_bus);
3503
3504         hdsp->capture_buffer = hdsp->capture_dma_buf.area + (cb_bus - hdsp->capture_dma_buf.addr);
3505         hdsp->playback_buffer = hdsp->playback_dma_buf.area + (pb_bus - hdsp->playback_dma_buf.addr);
3506
3507         return 0;
3508 }
3509
3510 static int snd_hdsp_set_defaults(struct hdsp *hdsp)
3511 {
3512         unsigned int i;
3513
3514         /* ASSUMPTION: hdsp->lock is either held, or
3515            there is no need to hold it (e.g. during module
3516            initalization).
3517          */
3518
3519         /* set defaults:
3520
3521            SPDIF Input via Coax
3522            Master clock mode
3523            maximum latency (7 => 2^7 = 8192 samples, 64Kbyte buffer,
3524                             which implies 2 4096 sample, 32Kbyte periods).
3525            Enable line out.
3526          */
3527
3528         hdsp->control_register = HDSP_ClockModeMaster |
3529                                  HDSP_SPDIFInputCoaxial |
3530                                  hdsp_encode_latency(7) |
3531                                  HDSP_LineOut;
3532
3533
3534         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
3535
3536 #ifdef SNDRV_BIG_ENDIAN
3537         hdsp->control2_register = HDSP_BIGENDIAN_MODE;
3538 #else
3539         hdsp->control2_register = 0;
3540 #endif
3541         if (hdsp->io_type == H9652)
3542                 snd_hdsp_9652_enable_mixer (hdsp);
3543         else
3544                 hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
3545
3546         hdsp_reset_hw_pointer(hdsp);
3547         hdsp_compute_period_size(hdsp);
3548
3549         /* silence everything */
3550
3551         for (i = 0; i < HDSP_MATRIX_MIXER_SIZE; ++i)
3552                 hdsp->mixer_matrix[i] = MINUS_INFINITY_GAIN;
3553
3554         for (i = 0; i < ((hdsp->io_type == H9652 || hdsp->io_type == H9632) ? 1352 : HDSP_MATRIX_MIXER_SIZE); ++i) {
3555                 if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN))
3556                         return -EIO;
3557         }
3558
3559         /* H9632 specific defaults */
3560         if (hdsp->io_type == H9632) {
3561                 hdsp->control_register |= (HDSP_DAGainPlus4dBu | HDSP_ADGainPlus4dBu | HDSP_PhoneGain0dB);
3562                 hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
3563         }
3564
3565         /* set a default rate so that the channel map is set up.
3566          */
3567
3568         hdsp_set_rate(hdsp, 48000, 1);
3569
3570         return 0;
3571 }
3572
3573 static void hdsp_midi_tasklet(unsigned long arg)
3574 {
3575         struct hdsp *hdsp = (struct hdsp *)arg;
3576
3577         if (hdsp->midi[0].pending)
3578                 snd_hdsp_midi_input_read (&hdsp->midi[0]);
3579         if (hdsp->midi[1].pending)
3580                 snd_hdsp_midi_input_read (&hdsp->midi[1]);
3581 }
3582
3583 static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
3584 {
3585         struct hdsp *hdsp = (struct hdsp *) dev_id;
3586         unsigned int status;
3587         int audio;
3588         int midi0;
3589         int midi1;
3590         unsigned int midi0status;
3591         unsigned int midi1status;
3592         int schedule = 0;
3593
3594         status = hdsp_read(hdsp, HDSP_statusRegister);
3595
3596         audio = status & HDSP_audioIRQPending;
3597         midi0 = status & HDSP_midi0IRQPending;
3598         midi1 = status & HDSP_midi1IRQPending;
3599
3600         if (!audio && !midi0 && !midi1)
3601                 return IRQ_NONE;
3602
3603         hdsp_write(hdsp, HDSP_interruptConfirmation, 0);
3604
3605         midi0status = hdsp_read (hdsp, HDSP_midiStatusIn0) & 0xff;
3606         midi1status = hdsp_read (hdsp, HDSP_midiStatusIn1) & 0xff;
3607
3608         if (audio) {
3609                 if (hdsp->capture_substream)
3610                         snd_pcm_period_elapsed(hdsp->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
3611
3612                 if (hdsp->playback_substream)
3613                         snd_pcm_period_elapsed(hdsp->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
3614         }
3615
3616         if (midi0 && midi0status) {
3617                 if (hdsp->use_midi_tasklet) {
3618                         /* we disable interrupts for this input until processing is done */
3619                         hdsp->control_register &= ~HDSP_Midi0InterruptEnable;
3620                         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
3621                         hdsp->midi[0].pending = 1;
3622                         schedule = 1;
3623                 } else {
3624                         snd_hdsp_midi_input_read (&hdsp->midi[0]);
3625                 }
3626         }
3627         if (hdsp->io_type != Multiface && hdsp->io_type != H9632 && midi1 && midi1status) {
3628                 if (hdsp->use_midi_tasklet) {
3629                         /* we disable interrupts for this input until processing is done */
3630                         hdsp->control_register &= ~HDSP_Midi1InterruptEnable;
3631                         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
3632                         hdsp->midi[1].pending = 1;
3633                         schedule = 1;
3634                 } else {
3635                         snd_hdsp_midi_input_read (&hdsp->midi[1]);
3636                 }
3637         }
3638         if (hdsp->use_midi_tasklet && schedule)
3639                 tasklet_hi_schedule(&hdsp->midi_tasklet);
3640         return IRQ_HANDLED;
3641 }
3642
3643 static snd_pcm_uframes_t snd_hdsp_hw_pointer(struct snd_pcm_substream *substream)
3644 {
3645         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3646         return hdsp_hw_pointer(hdsp);
3647 }
3648
3649 static char *hdsp_channel_buffer_location(struct hdsp *hdsp,
3650                                              int stream,
3651                                              int channel)
3652
3653 {
3654         int mapped_channel;
3655
3656         snd_assert(channel >= 0 && channel < hdsp->max_channels, return NULL);
3657
3658         if ((mapped_channel = hdsp->channel_map[channel]) < 0)
3659                 return NULL;
3660
3661         if (stream == SNDRV_PCM_STREAM_CAPTURE)
3662                 return hdsp->capture_buffer + (mapped_channel * HDSP_CHANNEL_BUFFER_BYTES);
3663         else
3664                 return hdsp->playback_buffer + (mapped_channel * HDSP_CHANNEL_BUFFER_BYTES);
3665 }
3666
3667 static int snd_hdsp_playback_copy(struct snd_pcm_substream *substream, int channel,
3668                                   snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count)
3669 {
3670         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3671         char *channel_buf;
3672
3673         snd_assert(pos + count <= HDSP_CHANNEL_BUFFER_BYTES / 4, return -EINVAL);
3674
3675         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
3676         snd_assert(channel_buf != NULL, return -EIO);
3677         if (copy_from_user(channel_buf + pos * 4, src, count * 4))
3678                 return -EFAULT;
3679         return count;
3680 }
3681
3682 static int snd_hdsp_capture_copy(struct snd_pcm_substream *substream, int channel,
3683                                  snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count)
3684 {
3685         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3686         char *channel_buf;
3687
3688         snd_assert(pos + count <= HDSP_CHANNEL_BUFFER_BYTES / 4, return -EINVAL);
3689
3690         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
3691         snd_assert(channel_buf != NULL, return -EIO);
3692         if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
3693                 return -EFAULT;
3694         return count;
3695 }
3696
3697 static int snd_hdsp_hw_silence(struct snd_pcm_substream *substream, int channel,
3698                                   snd_pcm_uframes_t pos, snd_pcm_uframes_t count)
3699 {
3700         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3701         char *channel_buf;
3702
3703         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
3704         snd_assert(channel_buf != NULL, return -EIO);
3705         memset(channel_buf + pos * 4, 0, count * 4);
3706         return count;
3707 }
3708
3709 static int snd_hdsp_reset(struct snd_pcm_substream *substream)
3710 {
3711         struct snd_pcm_runtime *runtime = substream->runtime;
3712         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3713         struct snd_pcm_substream *other;
3714         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3715                 other = hdsp->capture_substream;
3716         else
3717                 other = hdsp->playback_substream;
3718         if (hdsp->running)
3719                 runtime->status->hw_ptr = hdsp_hw_pointer(hdsp);
3720         else
3721                 runtime->status->hw_ptr = 0;
3722         if (other) {
3723                 struct list_head *pos;
3724                 struct snd_pcm_substream *s;
3725                 struct snd_pcm_runtime *oruntime = other->runtime;
3726                 snd_pcm_group_for_each(pos, substream) {
3727                         s = snd_pcm_group_substream_entry(pos);
3728                         if (s == other) {
3729                                 oruntime->status->hw_ptr = runtime->status->hw_ptr;
3730                                 break;
3731                         }
3732                 }
3733         }
3734         return 0;
3735 }
3736
3737 static int snd_hdsp_hw_params(struct snd_pcm_substream *substream,
3738                                  struct snd_pcm_hw_params *params)
3739 {
3740         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3741         int err;
3742         pid_t this_pid;
3743         pid_t other_pid;
3744
3745         if (hdsp_check_for_iobox (hdsp))
3746                 return -EIO;
3747
3748         if (hdsp_check_for_firmware(hdsp, 1))
3749                 return -EIO;
3750
3751         spin_lock_irq(&hdsp->lock);
3752
3753         if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
3754                 hdsp->control_register &= ~(HDSP_SPDIFProfessional | HDSP_SPDIFNonAudio | HDSP_SPDIFEmphasis);
3755                 hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register |= hdsp->creg_spdif_stream);
3756                 this_pid = hdsp->playback_pid;
3757                 other_pid = hdsp->capture_pid;
3758         } else {
3759                 this_pid = hdsp->capture_pid;
3760                 other_pid = hdsp->playback_pid;
3761         }
3762
3763         if ((other_pid > 0) && (this_pid != other_pid)) {
3764
3765                 /* The other stream is open, and not by the same
3766                    task as this one. Make sure that the parameters
3767                    that matter are the same.
3768                  */
3769
3770                 if (params_rate(params) != hdsp->system_sample_rate) {
3771                         spin_unlock_irq(&hdsp->lock);
3772                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
3773                         return -EBUSY;
3774                 }
3775
3776                 if (params_period_size(params) != hdsp->period_bytes / 4) {
3777                         spin_unlock_irq(&hdsp->lock);
3778                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
3779                         return -EBUSY;
3780                 }
3781
3782                 /* We're fine. */
3783
3784                 spin_unlock_irq(&hdsp->lock);
3785                 return 0;
3786
3787         } else {
3788                 spin_unlock_irq(&hdsp->lock);
3789         }
3790
3791         /* how to make sure that the rate matches an externally-set one ?
3792          */
3793
3794         spin_lock_irq(&hdsp->lock);
3795         if (! hdsp->clock_source_locked) {
3796                 if ((err = hdsp_set_rate(hdsp, params_rate(params), 0)) < 0) {
3797                         spin_unlock_irq(&hdsp->lock);
3798                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
3799                         return err;
3800                 }
3801         }
3802         spin_unlock_irq(&hdsp->lock);
3803
3804         if ((err = hdsp_set_interrupt_interval(hdsp, params_period_size(params))) < 0) {
3805                 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
3806                 return err;
3807         }
3808
3809         return 0;
3810 }
3811
3812 static int snd_hdsp_channel_info(struct snd_pcm_substream *substream,
3813                                     struct snd_pcm_channel_info *info)
3814 {
3815         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3816         int mapped_channel;
3817
3818         snd_assert(info->channel < hdsp->max_channels, return -EINVAL);
3819
3820         if ((mapped_channel = hdsp->channel_map[info->channel]) < 0)
3821                 return -EINVAL;
3822
3823         info->offset = mapped_channel * HDSP_CHANNEL_BUFFER_BYTES;
3824         info->first = 0;
3825         info->step = 32;
3826         return 0;
3827 }
3828
3829 static int snd_hdsp_ioctl(struct snd_pcm_substream *substream,
3830                              unsigned int cmd, void *arg)
3831 {
3832         switch (cmd) {
3833         case SNDRV_PCM_IOCTL1_RESET:
3834                 return snd_hdsp_reset(substream);
3835         case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
3836                 return snd_hdsp_channel_info(substream, arg);
3837         default:
3838                 break;
3839         }
3840
3841         return snd_pcm_lib_ioctl(substream, cmd, arg);
3842 }
3843
3844 static int snd_hdsp_trigger(struct snd_pcm_substream *substream, int cmd)
3845 {
3846         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3847         struct snd_pcm_substream *other;
3848         int running;
3849
3850         if (hdsp_check_for_iobox (hdsp))
3851                 return -EIO;
3852
3853         if (hdsp_check_for_firmware(hdsp, 1))
3854                 return -EIO;
3855
3856         spin_lock(&hdsp->lock);
3857         running = hdsp->running;
3858         switch (cmd) {
3859         case SNDRV_PCM_TRIGGER_START:
3860                 running |= 1 << substream->stream;
3861                 break;
3862         case SNDRV_PCM_TRIGGER_STOP:
3863                 running &= ~(1 << substream->stream);
3864                 break;
3865         default:
3866                 snd_BUG();
3867                 spin_unlock(&hdsp->lock);
3868                 return -EINVAL;
3869         }
3870         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3871                 other = hdsp->capture_substream;
3872         else
3873                 other = hdsp->playback_substream;
3874
3875         if (other) {
3876                 struct list_head *pos;
3877                 struct snd_pcm_substream *s;
3878                 snd_pcm_group_for_each(pos, substream) {
3879                         s = snd_pcm_group_substream_entry(pos);
3880                         if (s == other) {
3881                                 snd_pcm_trigger_done(s, substream);
3882                                 if (cmd == SNDRV_PCM_TRIGGER_START)
3883                                         running |= 1 << s->stream;
3884                                 else
3885                                         running &= ~(1 << s->stream);
3886                                 goto _ok;
3887                         }
3888                 }
3889                 if (cmd == SNDRV_PCM_TRIGGER_START) {
3890                         if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
3891                             substream->stream == SNDRV_PCM_STREAM_CAPTURE)
3892                                 hdsp_silence_playback(hdsp);
3893                 } else {
3894                         if (running &&
3895                             substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3896                                 hdsp_silence_playback(hdsp);
3897                 }
3898         } else {
3899                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
3900                                 hdsp_silence_playback(hdsp);
3901         }
3902  _ok:
3903         snd_pcm_trigger_done(substream, substream);
3904         if (!hdsp->running && running)
3905                 hdsp_start_audio(hdsp);
3906         else if (hdsp->running && !running)
3907                 hdsp_stop_audio(hdsp);
3908         hdsp->running = running;
3909         spin_unlock(&hdsp->lock);
3910
3911         return 0;
3912 }
3913
3914 static int snd_hdsp_prepare(struct snd_pcm_substream *substream)
3915 {
3916         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
3917         int result = 0;
3918
3919         if (hdsp_check_for_iobox (hdsp))
3920                 return -EIO;
3921
3922         if (hdsp_check_for_firmware(hdsp, 1))
3923                 return -EIO;
3924
3925         spin_lock_irq(&hdsp->lock);
3926         if (!hdsp->running)
3927                 hdsp_reset_hw_pointer(hdsp);
3928         spin_unlock_irq(&hdsp->lock);
3929         return result;
3930 }
3931
3932 static struct snd_pcm_hardware snd_hdsp_playback_subinfo =
3933 {
3934         .info =                 (SNDRV_PCM_INFO_MMAP |
3935                                  SNDRV_PCM_INFO_MMAP_VALID |
3936                                  SNDRV_PCM_INFO_NONINTERLEAVED |
3937                                  SNDRV_PCM_INFO_SYNC_START |
3938                                  SNDRV_PCM_INFO_DOUBLE),
3939 #ifdef SNDRV_BIG_ENDIAN
3940         .formats =              SNDRV_PCM_FMTBIT_S32_BE,
3941 #else
3942         .formats =              SNDRV_PCM_FMTBIT_S32_LE,
3943 #endif
3944         .rates =                (SNDRV_PCM_RATE_32000 |
3945                                  SNDRV_PCM_RATE_44100 |
3946                                  SNDRV_PCM_RATE_48000 |
3947                                  SNDRV_PCM_RATE_64000 |
3948                                  SNDRV_PCM_RATE_88200 |
3949                                  SNDRV_PCM_RATE_96000),
3950         .rate_min =             32000,
3951         .rate_max =             96000,
3952         .channels_min =         14,
3953         .channels_max =         HDSP_MAX_CHANNELS,
3954         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
3955         .period_bytes_min =     (64 * 4) * 10,
3956         .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
3957         .periods_min =          2,
3958         .periods_max =          2,
3959         .fifo_size =            0
3960 };
3961
3962 static struct snd_pcm_hardware snd_hdsp_capture_subinfo =
3963 {
3964         .info =                 (SNDRV_PCM_INFO_MMAP |
3965                                  SNDRV_PCM_INFO_MMAP_VALID |
3966                                  SNDRV_PCM_INFO_NONINTERLEAVED |
3967                                  SNDRV_PCM_INFO_SYNC_START),
3968 #ifdef SNDRV_BIG_ENDIAN
3969         .formats =              SNDRV_PCM_FMTBIT_S32_BE,
3970 #else
3971         .formats =              SNDRV_PCM_FMTBIT_S32_LE,
3972 #endif
3973         .rates =                (SNDRV_PCM_RATE_32000 |
3974                                  SNDRV_PCM_RATE_44100 |
3975                                  SNDRV_PCM_RATE_48000 |
3976                                  SNDRV_PCM_RATE_64000 |
3977                                  SNDRV_PCM_RATE_88200 |
3978                                  SNDRV_PCM_RATE_96000),
3979         .rate_min =             32000,
3980         .rate_max =             96000,
3981         .channels_min =         14,
3982         .channels_max =         HDSP_MAX_CHANNELS,
3983         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
3984         .period_bytes_min =     (64 * 4) * 10,
3985         .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
3986         .periods_min =          2,
3987         .periods_max =          2,
3988         .fifo_size =            0
3989 };
3990
3991 static unsigned int hdsp_period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 };
3992
3993 static struct snd_pcm_hw_constraint_list hdsp_hw_constraints_period_sizes = {
3994         .count = ARRAY_SIZE(hdsp_period_sizes),
3995         .list = hdsp_period_sizes,
3996         .mask = 0
3997 };
3998
3999 static unsigned int hdsp_9632_sample_rates[] = { 32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000 };
4000
4001 static struct snd_pcm_hw_constraint_list hdsp_hw_constraints_9632_sample_rates = {
4002         .count = ARRAY_SIZE(hdsp_9632_sample_rates),
4003         .list = hdsp_9632_sample_rates,
4004         .mask = 0
4005 };
4006
4007 static int snd_hdsp_hw_rule_in_channels(struct snd_pcm_hw_params *params,
4008                                         struct snd_pcm_hw_rule *rule)
4009 {
4010         struct hdsp *hdsp = rule->private;
4011         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4012         if (hdsp->io_type == H9632) {
4013                 unsigned int list[3];
4014                 list[0] = hdsp->qs_in_channels;
4015                 list[1] = hdsp->ds_in_channels;
4016                 list[2] = hdsp->ss_in_channels;
4017                 return snd_interval_list(c, 3, list, 0);
4018         } else {
4019                 unsigned int list[2];
4020                 list[0] = hdsp->ds_in_channels;
4021                 list[1] = hdsp->ss_in_channels;
4022                 return snd_interval_list(c, 2, list, 0);
4023         }
4024 }
4025
4026 static int snd_hdsp_hw_rule_out_channels(struct snd_pcm_hw_params *params,
4027                                         struct snd_pcm_hw_rule *rule)
4028 {
4029         unsigned int list[3];
4030         struct hdsp *hdsp = rule->private;
4031         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4032         if (hdsp->io_type == H9632) {
4033                 list[0] = hdsp->qs_out_channels;
4034                 list[1] = hdsp->ds_out_channels;
4035                 list[2] = hdsp->ss_out_channels;
4036                 return snd_interval_list(c, 3, list, 0);
4037         } else {
4038                 list[0] = hdsp->ds_out_channels;
4039                 list[1] = hdsp->ss_out_channels;
4040         }
4041         return snd_interval_list(c, 2, list, 0);
4042 }
4043
4044 static int snd_hdsp_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params,
4045                                              struct snd_pcm_hw_rule *rule)
4046 {
4047         struct hdsp *hdsp = rule->private;
4048         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4049         struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
4050         if (r->min > 96000 && hdsp->io_type == H9632) {
4051                 struct snd_interval t = {
4052                         .min = hdsp->qs_in_channels,
4053                         .max = hdsp->qs_in_channels,
4054                         .integer = 1,
4055                 };
4056                 return snd_interval_refine(c, &t);
4057         } else if (r->min > 48000 && r->max <= 96000) {
4058                 struct snd_interval t = {
4059                         .min = hdsp->ds_in_channels,
4060                         .max = hdsp->ds_in_channels,
4061                         .integer = 1,
4062                 };
4063                 return snd_interval_refine(c, &t);
4064         } else if (r->max < 64000) {
4065                 struct snd_interval t = {
4066                         .min = hdsp->ss_in_channels,
4067                         .max = hdsp->ss_in_channels,
4068                         .integer = 1,
4069                 };
4070                 return snd_interval_refine(c, &t);
4071         }
4072         return 0;
4073 }
4074
4075 static int snd_hdsp_hw_rule_out_channels_rate(struct snd_pcm_hw_params *params,
4076                                              struct snd_pcm_hw_rule *rule)
4077 {
4078         struct hdsp *hdsp = rule->private;
4079         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4080         struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
4081         if (r->min > 96000 && hdsp->io_type == H9632) {
4082                 struct snd_interval t = {
4083                         .min = hdsp->qs_out_channels,
4084                         .max = hdsp->qs_out_channels,
4085                         .integer = 1,
4086                 };
4087                 return snd_interval_refine(c, &t);
4088         } else if (r->min > 48000 && r->max <= 96000) {
4089                 struct snd_interval t = {
4090                         .min = hdsp->ds_out_channels,
4091                         .max = hdsp->ds_out_channels,
4092                         .integer = 1,
4093                 };
4094                 return snd_interval_refine(c, &t);
4095         } else if (r->max < 64000) {
4096                 struct snd_interval t = {
4097                         .min = hdsp->ss_out_channels,
4098                         .max = hdsp->ss_out_channels,
4099                         .integer = 1,
4100                 };
4101                 return snd_interval_refine(c, &t);
4102         }
4103         return 0;
4104 }
4105
4106 static int snd_hdsp_hw_rule_rate_out_channels(struct snd_pcm_hw_params *params,
4107                                              struct snd_pcm_hw_rule *rule)
4108 {
4109         struct hdsp *hdsp = rule->private;
4110         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4111         struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
4112         if (c->min >= hdsp->ss_out_channels) {
4113                 struct snd_interval t = {
4114                         .min = 32000,
4115                         .max = 48000,
4116                         .integer = 1,
4117                 };
4118                 return snd_interval_refine(r, &t);
4119         } else if (c->max <= hdsp->qs_out_channels && hdsp->io_type == H9632) {
4120                 struct snd_interval t = {
4121                         .min = 128000,
4122                         .max = 192000,
4123                         .integer = 1,
4124                 };
4125                 return snd_interval_refine(r, &t);
4126         } else if (c->max <= hdsp->ds_out_channels) {
4127                 struct snd_interval t = {
4128                         .min = 64000,
4129                         .max = 96000,
4130                         .integer = 1,
4131                 };
4132                 return snd_interval_refine(r, &t);
4133         }
4134         return 0;
4135 }
4136
4137 static int snd_hdsp_hw_rule_rate_in_channels(struct snd_pcm_hw_params *params,
4138                                              struct snd_pcm_hw_rule *rule)
4139 {
4140         struct hdsp *hdsp = rule->private;
4141         struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
4142         struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
4143         if (c->min >= hdsp->ss_in_channels) {
4144                 struct snd_interval t = {
4145                         .min = 32000,
4146                         .max = 48000,
4147                         .integer = 1,
4148                 };
4149                 return snd_interval_refine(r, &t);
4150         } else if (c->max <= hdsp->qs_in_channels && hdsp->io_type == H9632) {
4151                 struct snd_interval t = {
4152                         .min = 128000,
4153                         .max = 192000,
4154                         .integer = 1,
4155                 };
4156                 return snd_interval_refine(r, &t);
4157         } else if (c->max <= hdsp->ds_in_channels) {
4158                 struct snd_interval t = {
4159                         .min = 64000,
4160                         .max = 96000,
4161                         .integer = 1,
4162                 };
4163                 return snd_interval_refine(r, &t);
4164         }
4165         return 0;
4166 }
4167
4168 static int snd_hdsp_playback_open(struct snd_pcm_substream *substream)
4169 {
4170         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
4171         struct snd_pcm_runtime *runtime = substream->runtime;
4172
4173         if (hdsp_check_for_iobox (hdsp))
4174                 return -EIO;
4175
4176         if (hdsp_check_for_firmware(hdsp, 1))
4177                 return -EIO;
4178
4179         spin_lock_irq(&hdsp->lock);
4180
4181         snd_pcm_set_sync(substream);
4182
4183         runtime->hw = snd_hdsp_playback_subinfo;
4184         runtime->dma_area = hdsp->playback_buffer;
4185         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
4186
4187         hdsp->playback_pid = current->pid;
4188         hdsp->playback_substream = substream;
4189
4190         spin_unlock_irq(&hdsp->lock);
4191
4192         snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
4193         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hdsp_hw_constraints_period_sizes);
4194         if (hdsp->clock_source_locked) {
4195                 runtime->hw.rate_min = runtime->hw.rate_max = hdsp->system_sample_rate;
4196         } else if (hdsp->io_type == H9632) {
4197                 runtime->hw.rate_max = 192000;
4198                 runtime->hw.rates = SNDRV_PCM_RATE_KNOT;
4199                 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hdsp_hw_constraints_9632_sample_rates);
4200         }
4201         if (hdsp->io_type == H9632) {
4202                 runtime->hw.channels_min = hdsp->qs_out_channels;
4203                 runtime->hw.channels_max = hdsp->ss_out_channels;
4204         }
4205
4206         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
4207                              snd_hdsp_hw_rule_out_channels, hdsp,
4208                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
4209         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
4210                              snd_hdsp_hw_rule_out_channels_rate, hdsp,
4211                              SNDRV_PCM_HW_PARAM_RATE, -1);
4212         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
4213                              snd_hdsp_hw_rule_rate_out_channels, hdsp,
4214                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
4215
4216         hdsp->creg_spdif_stream = hdsp->creg_spdif;
4217         hdsp->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
4218         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
4219                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
4220         return 0;
4221 }
4222
4223 static int snd_hdsp_playback_release(struct snd_pcm_substream *substream)
4224 {
4225         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
4226
4227         spin_lock_irq(&hdsp->lock);
4228
4229         hdsp->playback_pid = -1;
4230         hdsp->playback_substream = NULL;
4231
4232         spin_unlock_irq(&hdsp->lock);
4233
4234         hdsp->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
4235         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
4236                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
4237         return 0;
4238 }
4239
4240
4241 static int snd_hdsp_capture_open(struct snd_pcm_substream *substream)
4242 {
4243         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
4244         struct snd_pcm_runtime *runtime = substream->runtime;
4245
4246         if (hdsp_check_for_iobox (hdsp))
4247                 return -EIO;
4248
4249         if (hdsp_check_for_firmware(hdsp, 1))
4250                 return -EIO;
4251
4252         spin_lock_irq(&hdsp->lock);
4253
4254         snd_pcm_set_sync(substream);
4255
4256         runtime->hw = snd_hdsp_capture_subinfo;
4257         runtime->dma_area = hdsp->capture_buffer;
4258         runtime->dma_bytes = HDSP_DMA_AREA_BYTES;
4259
4260         hdsp->capture_pid = current->pid;
4261         hdsp->capture_substream = substream;
4262
4263         spin_unlock_irq(&hdsp->lock);
4264
4265         snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
4266         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hdsp_hw_constraints_period_sizes);
4267         if (hdsp->io_type == H9632) {
4268                 runtime->hw.channels_min = hdsp->qs_in_channels;
4269                 runtime->hw.channels_max = hdsp->ss_in_channels;
4270                 runtime->hw.rate_max = 192000;
4271                 runtime->hw.rates = SNDRV_PCM_RATE_KNOT;
4272                 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hdsp_hw_constraints_9632_sample_rates);
4273         }
4274         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
4275                              snd_hdsp_hw_rule_in_channels, hdsp,
4276                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
4277         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
4278                              snd_hdsp_hw_rule_in_channels_rate, hdsp,
4279                              SNDRV_PCM_HW_PARAM_RATE, -1);
4280         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
4281                              snd_hdsp_hw_rule_rate_in_channels, hdsp,
4282                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
4283         return 0;
4284 }
4285
4286 static int snd_hdsp_capture_release(struct snd_pcm_substream *substream)
4287 {
4288         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
4289
4290         spin_lock_irq(&hdsp->lock);
4291
4292         hdsp->capture_pid = -1;
4293         hdsp->capture_substream = NULL;
4294
4295         spin_unlock_irq(&hdsp->lock);
4296         return 0;
4297 }
4298
4299 static int snd_hdsp_hwdep_dummy_op(struct snd_hwdep *hw, struct file *file)
4300 {
4301         /* we have nothing to initialize but the call is required */
4302         return 0;
4303 }
4304
4305
4306 /* helper functions for copying meter values */
4307 static inline int copy_u32_le(void __user *dest, void __iomem *src)
4308 {
4309         u32 val = readl(src);
4310         return copy_to_user(dest, &val, 4);
4311 }
4312
4313 static inline int copy_u64_le(void __user *dest, void __iomem *src_low, void __iomem *src_high)
4314 {
4315         u32 rms_low, rms_high;
4316         u64 rms;
4317         rms_low = readl(src_low);
4318         rms_high = readl(src_high);
4319         rms = ((u64)rms_high << 32) | rms_low;
4320         return copy_to_user(dest, &rms, 8);
4321 }
4322
4323 static inline int copy_u48_le(void __user *dest, void __iomem *src_low, void __iomem *src_high)
4324 {
4325         u32 rms_low, rms_high;
4326         u64 rms;
4327         rms_low = readl(src_low) & 0xffffff00;
4328         rms_high = readl(src_high) & 0xffffff00;
4329         rms = ((u64)rms_high << 32) | rms_low;
4330         return copy_to_user(dest, &rms, 8);
4331 }
4332
4333 static int hdsp_9652_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms)
4334 {
4335         int doublespeed = 0;
4336         int i, j, channels, ofs;
4337
4338         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DoubleSpeedStatus)
4339                 doublespeed = 1;
4340         channels = doublespeed ? 14 : 26;
4341         for (i = 0, j = 0; i < 26; ++i) {
4342                 if (doublespeed && (i & 4))
4343                         continue;
4344                 ofs = HDSP_9652_peakBase - j * 4;
4345                 if (copy_u32_le(&peak_rms->input_peaks[i], hdsp->iobase + ofs))
4346                         return -EFAULT;
4347                 ofs -= channels * 4;
4348                 if (copy_u32_le(&peak_rms->playback_peaks[i], hdsp->iobase + ofs))
4349                         return -EFAULT;
4350                 ofs -= channels * 4;
4351                 if (copy_u32_le(&peak_rms->output_peaks[i], hdsp->iobase + ofs))
4352                         return -EFAULT;
4353                 ofs = HDSP_9652_rmsBase + j * 8;
4354                 if (copy_u48_le(&peak_rms->input_rms[i], hdsp->iobase + ofs,
4355                                 hdsp->iobase + ofs + 4))
4356                         return -EFAULT;
4357                 ofs += channels * 8;
4358                 if (copy_u48_le(&peak_rms->playback_rms[i], hdsp->iobase + ofs,
4359                                 hdsp->iobase + ofs + 4))
4360                         return -EFAULT;
4361                 ofs += channels * 8;
4362                 if (copy_u48_le(&peak_rms->output_rms[i], hdsp->iobase + ofs,
4363                                 hdsp->iobase + ofs + 4))
4364                         return -EFAULT;
4365                 j++;
4366         }
4367         return 0;
4368 }
4369
4370 static int hdsp_9632_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms)
4371 {
4372         int i, j;
4373         struct hdsp_9632_meters __iomem *m;
4374         int doublespeed = 0;
4375
4376         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DoubleSpeedStatus)
4377                 doublespeed = 1;
4378         m = (struct hdsp_9632_meters __iomem *)(hdsp->iobase+HDSP_9632_metersBase);
4379         for (i = 0, j = 0; i < 16; ++i, ++j) {
4380                 if (copy_u32_le(&peak_rms->input_peaks[i], &m->input_peak[j]))
4381                         return -EFAULT;
4382                 if (copy_u32_le(&peak_rms->playback_peaks[i], &m->playback_peak[j]))
4383                         return -EFAULT;
4384                 if (copy_u32_le(&peak_rms->output_peaks[i], &m->output_peak[j]))
4385                         return -EFAULT;
4386                 if (copy_u64_le(&peak_rms->input_rms[i], &m->input_rms_low[j],
4387                                 &m->input_rms_high[j]))
4388                         return -EFAULT;
4389                 if (copy_u64_le(&peak_rms->playback_rms[i], &m->playback_rms_low[j],
4390                                 &m->playback_rms_high[j]))
4391                         return -EFAULT;
4392                 if (copy_u64_le(&peak_rms->output_rms[i], &m->output_rms_low[j],
4393                                 &m->output_rms_high[j]))
4394                         return -EFAULT;
4395                 if (doublespeed && i == 3) i += 4;
4396         }
4397         return 0;
4398 }
4399
4400 static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms)
4401 {
4402         int i;
4403
4404         for (i = 0; i < 26; i++) {
4405                 if (copy_u32_le(&peak_rms->playback_peaks[i],
4406                                 hdsp->iobase + HDSP_playbackPeakLevel + i * 4))
4407                         return -EFAULT;
4408                 if (copy_u32_le(&peak_rms->input_peaks[i],
4409                                 hdsp->iobase + HDSP_inputPeakLevel + i * 4))
4410                         return -EFAULT;
4411         }
4412         for (i = 0; i < 28; i++) {
4413                 if (copy_u32_le(&peak_rms->output_peaks[i],
4414                                 hdsp->iobase + HDSP_outputPeakLevel + i * 4))
4415                         return -EFAULT;
4416         }
4417         for (i = 0; i < 26; ++i) {
4418                 if (copy_u64_le(&peak_rms->playback_rms[i],
4419                                 hdsp->iobase + HDSP_playbackRmsLevel + i * 8 + 4,
4420                                 hdsp->iobase + HDSP_playbackRmsLevel + i * 8))
4421                         return -EFAULT;
4422                 if (copy_u64_le(&peak_rms->input_rms[i],
4423                                 hdsp->iobase + HDSP_inputRmsLevel + i * 8 + 4,
4424                                 hdsp->iobase + HDSP_inputRmsLevel + i * 8))
4425                         return -EFAULT;
4426         }
4427         return 0;
4428 }
4429
4430 static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg)
4431 {
4432         struct hdsp *hdsp = (struct hdsp *)hw->private_data;
4433         void __user *argp = (void __user *)arg;
4434
4435         switch (cmd) {
4436         case SNDRV_HDSP_IOCTL_GET_PEAK_RMS: {
4437                 struct hdsp_peak_rms __user *peak_rms = (struct hdsp_peak_rms __user *)arg;
4438
4439                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
4440                         snd_printk(KERN_ERR "Hammerfall-DSP: firmware needs to be uploaded to the card.\n");
4441                         return -EINVAL;
4442                 }
4443
4444                 switch (hdsp->io_type) {
4445                 case H9652:
4446                         return hdsp_9652_get_peak(hdsp, peak_rms);
4447                 case H9632:
4448                         return hdsp_9632_get_peak(hdsp, peak_rms);
4449                 default:
4450                         return hdsp_get_peak(hdsp, peak_rms);
4451                 }
4452         }
4453         case SNDRV_HDSP_IOCTL_GET_CONFIG_INFO: {
4454                 struct hdsp_config_info info;
4455                 unsigned long flags;
4456                 int i;
4457
4458                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
4459                         snd_printk(KERN_ERR "Hammerfall-DSP: Firmware needs to be uploaded to the card.\n");
4460                         return -EINVAL;
4461                 }
4462                 spin_lock_irqsave(&hdsp->lock, flags);
4463                 info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp);
4464                 info.wordclock_sync_check = (unsigned char)hdsp_wc_sync_check(hdsp);
4465                 if (hdsp->io_type != H9632)
4466                     info.adatsync_sync_check = (unsigned char)hdsp_adatsync_sync_check(hdsp);
4467                 info.spdif_sync_check = (unsigned char)hdsp_spdif_sync_check(hdsp);
4468                 for (i = 0; i < ((hdsp->io_type != Multiface && hdsp->io_type != H9632) ? 3 : 1); ++i)
4469                         info.adat_sync_check[i] = (unsigned char)hdsp_adat_sync_check(hdsp, i);
4470                 info.spdif_in = (unsigned char)hdsp_spdif_in(hdsp);
4471                 info.spdif_out = (unsigned char)hdsp_spdif_out(hdsp);
4472                 info.spdif_professional = (unsigned char)hdsp_spdif_professional(hdsp);
4473                 info.spdif_emphasis = (unsigned char)hdsp_spdif_emphasis(hdsp);
4474                 info.spdif_nonaudio = (unsigned char)hdsp_spdif_nonaudio(hdsp);
4475                 info.spdif_sample_rate = hdsp_spdif_sample_rate(hdsp);
4476                 info.system_sample_rate = hdsp->system_sample_rate;
4477                 info.autosync_sample_rate = hdsp_external_sample_rate(hdsp);
4478                 info.system_clock_mode = (unsigned char)hdsp_system_clock_mode(hdsp);
4479                 info.clock_source = (unsigned char)hdsp_clock_source(hdsp);
4480                 info.autosync_ref = (unsigned char)hdsp_autosync_ref(hdsp);
4481                 info.line_out = (unsigned char)hdsp_line_out(hdsp);
4482                 if (hdsp->io_type == H9632) {
4483                         info.da_gain = (unsigned char)hdsp_da_gain(hdsp);
4484                         info.ad_gain = (unsigned char)hdsp_ad_gain(hdsp);
4485                         info.phone_gain = (unsigned char)hdsp_phone_gain(hdsp);
4486                         info.xlr_breakout_cable = (unsigned char)hdsp_xlr_breakout_cable(hdsp);
4487
4488                 }
4489                 if (hdsp->io_type == H9632 || hdsp->io_type == H9652)
4490                         info.analog_extension_board = (unsigned char)hdsp_aeb(hdsp);
4491                 spin_unlock_irqrestore(&hdsp->lock, flags);
4492                 if (copy_to_user(argp, &info, sizeof(info)))
4493                         return -EFAULT;
4494                 break;
4495         }
4496         case SNDRV_HDSP_IOCTL_GET_9632_AEB: {
4497                 struct hdsp_9632_aeb h9632_aeb;
4498
4499                 if (hdsp->io_type != H9632) return -EINVAL;
4500                 h9632_aeb.aebi = hdsp->ss_in_channels - H9632_SS_CHANNELS;
4501                 h9632_aeb.aebo = hdsp->ss_out_channels - H9632_SS_CHANNELS;
4502                 if (copy_to_user(argp, &h9632_aeb, sizeof(h9632_aeb)))
4503                         return -EFAULT;
4504                 break;
4505         }
4506         case SNDRV_HDSP_IOCTL_GET_VERSION: {
4507                 struct hdsp_version hdsp_version;
4508                 int err;
4509
4510                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
4511                 if (hdsp->io_type == Undefined) {
4512                         if ((err = hdsp_get_iobox_version(hdsp)) < 0)
4513                                 return err;
4514                 }
4515                 hdsp_version.io_type = hdsp->io_type;
4516                 hdsp_version.firmware_rev = hdsp->firmware_rev;
4517                 if ((err = copy_to_user(argp, &hdsp_version, sizeof(hdsp_version))))
4518                         return -EFAULT;
4519                 break;
4520         }
4521         case SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE: {
4522                 struct hdsp_firmware __user *firmware;
4523                 u32 __user *firmware_data;
4524                 int err;
4525
4526                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
4527                 /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
4528                 if (hdsp->io_type == Undefined) return -EINVAL;
4529
4530                 if (hdsp->state & (HDSP_FirmwareCached | HDSP_FirmwareLoaded))
4531                         return -EBUSY;
4532
4533                 snd_printk(KERN_INFO "Hammerfall-DSP: initializing firmware upload\n");
4534                 firmware = (struct hdsp_firmware __user *)argp;
4535
4536                 if (get_user(firmware_data, &firmware->firmware_data))
4537                         return -EFAULT;
4538
4539                 if (hdsp_check_for_iobox (hdsp))
4540                         return -EIO;
4541
4542                 if (copy_from_user(hdsp->firmware_cache, firmware_data, sizeof(hdsp->firmware_cache)) != 0)
4543                         return -EFAULT;
4544
4545                 hdsp->state |= HDSP_FirmwareCached;
4546
4547                 if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0)
4548                         return err;
4549
4550                 if (!(hdsp->state & HDSP_InitializationComplete)) {
4551                         if ((err = snd_hdsp_enable_io(hdsp)) < 0)
4552                                 return err;
4553
4554                         snd_hdsp_initialize_channels(hdsp);
4555                         snd_hdsp_initialize_midi_flush(hdsp);
4556
4557                         if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
4558                                 snd_printk(KERN_ERR "Hammerfall-DSP: error creating alsa devices\n");
4559                                 return err;
4560                         }
4561                 }
4562                 break;
4563         }
4564         case SNDRV_HDSP_IOCTL_GET_MIXER: {
4565                 struct hdsp_mixer __user *mixer = (struct hdsp_mixer __user *)argp;
4566                 if (copy_to_user(mixer->matrix, hdsp->mixer_matrix, sizeof(unsigned short)*HDSP_MATRIX_MIXER_SIZE))
4567                         return -EFAULT;
4568                 break;
4569         }
4570         default:
4571                 return -EINVAL;
4572         }
4573         return 0;
4574 }
4575
4576 static struct snd_pcm_ops snd_hdsp_playback_ops = {
4577         .open =         snd_hdsp_playback_open,
4578         .close =        snd_hdsp_playback_release,
4579         .ioctl =        snd_hdsp_ioctl,
4580         .hw_params =    snd_hdsp_hw_params,
4581         .prepare =      snd_hdsp_prepare,
4582         .trigger =      snd_hdsp_trigger,
4583         .pointer =      snd_hdsp_hw_pointer,
4584         .copy =         snd_hdsp_playback_copy,
4585         .silence =      snd_hdsp_hw_silence,
4586 };
4587
4588 static struct snd_pcm_ops snd_hdsp_capture_ops = {
4589         .open =         snd_hdsp_capture_open,
4590         .close =        snd_hdsp_capture_release,
4591         .ioctl =        snd_hdsp_ioctl,
4592         .hw_params =    snd_hdsp_hw_params,
4593         .prepare =      snd_hdsp_prepare,
4594         .trigger =      snd_hdsp_trigger,
4595         .pointer =      snd_hdsp_hw_pointer,
4596         .copy =         snd_hdsp_capture_copy,
4597 };
4598
4599 static int __devinit snd_hdsp_create_hwdep(struct snd_card *card,
4600                                            struct hdsp *hdsp)
4601 {
4602         struct snd_hwdep *hw;
4603         int err;
4604
4605         if ((err = snd_hwdep_new(card, "HDSP hwdep", 0, &hw)) < 0)
4606                 return err;
4607
4608         hdsp->hwdep = hw;
4609         hw->private_data = hdsp;
4610         strcpy(hw->name, "HDSP hwdep interface");
4611
4612         hw->ops.open = snd_hdsp_hwdep_dummy_op;
4613         hw->ops.ioctl = snd_hdsp_hwdep_ioctl;
4614         hw->ops.release = snd_hdsp_hwdep_dummy_op;
4615
4616         return 0;
4617 }
4618
4619 static int snd_hdsp_create_pcm(struct snd_card *card, struct hdsp *hdsp)
4620 {
4621         struct snd_pcm *pcm;
4622         int err;
4623
4624         if ((err = snd_pcm_new(card, hdsp->card_name, 0, 1, 1, &pcm)) < 0)
4625                 return err;
4626
4627         hdsp->pcm = pcm;
4628         pcm->private_data = hdsp;
4629         strcpy(pcm->name, hdsp->card_name);
4630
4631         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_hdsp_playback_ops);
4632         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_hdsp_capture_ops);
4633
4634         pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
4635
4636         return 0;
4637 }
4638
4639 static void snd_hdsp_9652_enable_mixer (struct hdsp *hdsp)
4640 {
4641         hdsp->control2_register |= HDSP_9652_ENABLE_MIXER;
4642         hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
4643 }
4644
4645 static int snd_hdsp_enable_io (struct hdsp *hdsp)
4646 {
4647         int i;
4648
4649         if (hdsp_fifo_wait (hdsp, 0, 100)) {
4650                 snd_printk(KERN_ERR "Hammerfall-DSP: enable_io fifo_wait failed\n");
4651                 return -EIO;
4652         }
4653
4654         for (i = 0; i < hdsp->max_channels; ++i) {
4655                 hdsp_write (hdsp, HDSP_inputEnable + (4 * i), 1);
4656                 hdsp_write (hdsp, HDSP_outputEnable + (4 * i), 1);
4657         }
4658
4659         return 0;
4660 }
4661
4662 static void snd_hdsp_initialize_channels(struct hdsp *hdsp)
4663 {
4664         int status, aebi_channels, aebo_channels;
4665
4666         switch (hdsp->io_type) {
4667         case Digiface:
4668                 hdsp->card_name = "RME Hammerfall DSP + Digiface";
4669                 hdsp->ss_in_channels = hdsp->ss_out_channels = DIGIFACE_SS_CHANNELS;
4670                 hdsp->ds_in_channels = hdsp->ds_out_channels = DIGIFACE_DS_CHANNELS;
4671                 break;
4672
4673         case H9652:
4674                 hdsp->card_name = "RME Hammerfall HDSP 9652";
4675                 hdsp->ss_in_channels = hdsp->ss_out_channels = H9652_SS_CHANNELS;
4676                 hdsp->ds_in_channels = hdsp->ds_out_channels = H9652_DS_CHANNELS;
4677                 break;
4678
4679         case H9632:
4680                 status = hdsp_read(hdsp, HDSP_statusRegister);
4681                 /* HDSP_AEBx bits are low when AEB are connected */
4682                 aebi_channels = (status & HDSP_AEBI) ? 0 : 4;
4683                 aebo_channels = (status & HDSP_AEBO) ? 0 : 4;
4684                 hdsp->card_name = "RME Hammerfall HDSP 9632";
4685                 hdsp->ss_in_channels = H9632_SS_CHANNELS+aebi_channels;
4686                 hdsp->ds_in_channels = H9632_DS_CHANNELS+aebi_channels;
4687                 hdsp->qs_in_channels = H9632_QS_CHANNELS+aebi_channels;
4688                 hdsp->ss_out_channels = H9632_SS_CHANNELS+aebo_channels;
4689                 hdsp->ds_out_channels = H9632_DS_CHANNELS+aebo_channels;
4690                 hdsp->qs_out_channels = H9632_QS_CHANNELS+aebo_channels;
4691                 break;
4692
4693         case Multiface:
4694                 hdsp->card_name = "RME Hammerfall DSP + Multiface";
4695                 hdsp->ss_in_channels = hdsp->ss_out_channels = MULTIFACE_SS_CHANNELS;
4696                 hdsp->ds_in_channels = hdsp->ds_out_channels = MULTIFACE_DS_CHANNELS;
4697                 break;
4698
4699         default:
4700                 /* should never get here */
4701                 break;
4702         }
4703 }
4704
4705 static void snd_hdsp_initialize_midi_flush (struct hdsp *hdsp)
4706 {
4707         snd_hdsp_flush_midi_input (hdsp, 0);
4708         snd_hdsp_flush_midi_input (hdsp, 1);
4709 }
4710
4711 static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp)
4712 {
4713         int err;
4714
4715         if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
4716                 snd_printk(KERN_ERR "Hammerfall-DSP: Error creating pcm interface\n");
4717                 return err;
4718         }
4719
4720
4721         if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
4722                 snd_printk(KERN_ERR "Hammerfall-DSP: Error creating first midi interface\n");
4723                 return err;
4724         }
4725
4726         if (hdsp->io_type == Digiface || hdsp->io_type == H9652) {
4727                 if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
4728                         snd_printk(KERN_ERR "Hammerfall-DSP: Error creating second midi interface\n");
4729                         return err;
4730                 }
4731         }
4732
4733         if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
4734                 snd_printk(KERN_ERR "Hammerfall-DSP: Error creating ctl interface\n");
4735                 return err;
4736         }
4737
4738         snd_hdsp_proc_init(hdsp);
4739
4740         hdsp->system_sample_rate = -1;
4741         hdsp->playback_pid = -1;
4742         hdsp->capture_pid = -1;
4743         hdsp->capture_substream = NULL;
4744         hdsp->playback_substream = NULL;
4745
4746         if ((err = snd_hdsp_set_defaults(hdsp)) < 0) {
4747                 snd_printk(KERN_ERR "Hammerfall-DSP: Error setting default values\n");
4748                 return err;
4749         }
4750
4751         if (!(hdsp->state & HDSP_InitializationComplete)) {
4752                 strcpy(card->shortname, "Hammerfall DSP");
4753                 sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name,
4754                         hdsp->port, hdsp->irq);
4755
4756                 if ((err = snd_card_register(card)) < 0) {
4757                         snd_printk(KERN_ERR "Hammerfall-DSP: error registering card\n");
4758                         return err;
4759                 }
4760                 hdsp->state |= HDSP_InitializationComplete;
4761         }
4762
4763         return 0;
4764 }
4765
4766 #ifdef HDSP_FW_LOADER
4767 /* load firmware via hotplug fw loader */
4768 static int __devinit hdsp_request_fw_loader(struct hdsp *hdsp)
4769 {
4770         const char *fwfile;
4771         const struct firmware *fw;
4772         int err;
4773
4774         if (hdsp->io_type == H9652 || hdsp->io_type == H9632)
4775                 return 0;
4776         if (hdsp->io_type == Undefined) {
4777                 if ((err = hdsp_get_iobox_version(hdsp)) < 0)
4778                         return err;
4779                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632)
4780                         return 0;
4781         }
4782
4783         /* caution: max length of firmware filename is 30! */
4784         switch (hdsp->io_type) {
4785         case Multiface:
4786                 if (hdsp->firmware_rev == 0xa)
4787                         fwfile = "multiface_firmware.bin";
4788                 else
4789                         fwfile = "multiface_firmware_rev11.bin";
4790                 break;
4791         case Digiface:
4792                 if (hdsp->firmware_rev == 0xa)
4793                         fwfile = "digiface_firmware.bin";
4794                 else
4795                         fwfile = "digiface_firmware_rev11.bin";
4796                 break;
4797         default:
4798                 snd_printk(KERN_ERR "Hammerfall-DSP: invalid io_type %d\n", hdsp->io_type);
4799                 return -EINVAL;
4800         }
4801
4802         if (request_firmware(&fw, fwfile, &hdsp->pci->dev)) {
4803                 snd_printk(KERN_ERR "Hammerfall-DSP: cannot load firmware %s\n", fwfile);
4804                 return -ENOENT;
4805         }
4806         if (fw->size < sizeof(hdsp->firmware_cache)) {
4807                 snd_printk(KERN_ERR "Hammerfall-DSP: too short firmware size %d (expected %d)\n",
4808                            (int)fw->size, (int)sizeof(hdsp->firmware_cache));
4809                 release_firmware(fw);
4810                 return -EINVAL;
4811         }
4812
4813         memcpy(hdsp->firmware_cache, fw->data, sizeof(hdsp->firmware_cache));
4814
4815         release_firmware(fw);
4816
4817         hdsp->state |= HDSP_FirmwareCached;
4818
4819         if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0)
4820                 return err;
4821
4822         if (!(hdsp->state & HDSP_InitializationComplete)) {
4823                 if ((err = snd_hdsp_enable_io(hdsp)) < 0)
4824                         return err;
4825
4826                 if ((err = snd_hdsp_create_hwdep(hdsp->card, hdsp)) < 0) {
4827                         snd_printk(KERN_ERR "Hammerfall-DSP: error creating hwdep device\n");
4828                         return err;
4829                 }
4830                 snd_hdsp_initialize_channels(hdsp);
4831                 snd_hdsp_initialize_midi_flush(hdsp);
4832                 if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
4833                         snd_printk(KERN_ERR "Hammerfall-DSP: error creating alsa devices\n");
4834                         return err;
4835                 }
4836         }
4837         return 0;
4838 }
4839 #endif
4840
4841 static int __devinit snd_hdsp_create(struct snd_card *card,
4842                                      struct hdsp *hdsp)
4843 {
4844         struct pci_dev *pci = hdsp->pci;
4845         int err;
4846         int is_9652 = 0;
4847         int is_9632 = 0;
4848
4849         hdsp->irq = -1;
4850         hdsp->state = 0;
4851         hdsp->midi[0].rmidi = NULL;
4852         hdsp->midi[1].rmidi = NULL;
4853         hdsp->midi[0].input = NULL;
4854         hdsp->midi[1].input = NULL;
4855         hdsp->midi[0].output = NULL;
4856         hdsp->midi[1].output = NULL;
4857         hdsp->midi[0].pending = 0;
4858         hdsp->midi[1].pending = 0;
4859         spin_lock_init(&hdsp->midi[0].lock);
4860         spin_lock_init(&hdsp->midi[1].lock);
4861         hdsp->iobase = NULL;
4862         hdsp->control_register = 0;
4863         hdsp->control2_register = 0;
4864         hdsp->io_type = Undefined;
4865         hdsp->max_channels = 26;
4866
4867         hdsp->card = card;
4868
4869         spin_lock_init(&hdsp->lock);
4870
4871         tasklet_init(&hdsp->midi_tasklet, hdsp_midi_tasklet, (unsigned long)hdsp);
4872
4873         pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &hdsp->firmware_rev);
4874         hdsp->firmware_rev &= 0xff;
4875
4876         /* From Martin Bjoernsen :
4877             "It is important that the card's latency timer register in
4878             the PCI configuration space is set to a value much larger
4879             than 0 by the computer's BIOS or the driver.
4880             The windows driver always sets this 8 bit register [...]
4881             to its maximum 255 to avoid problems with some computers."
4882         */
4883         pci_write_config_byte(hdsp->pci, PCI_LATENCY_TIMER, 0xFF);
4884
4885         strcpy(card->driver, "H-DSP");
4886         strcpy(card->mixername, "Xilinx FPGA");
4887
4888         if (hdsp->firmware_rev < 0xa)
4889                 return -ENODEV;
4890         else if (hdsp->firmware_rev < 0x64)
4891                 hdsp->card_name = "RME Hammerfall DSP";
4892         else if (hdsp->firmware_rev < 0x96) {
4893                 hdsp->card_name = "RME HDSP 9652";
4894                 is_9652 = 1;
4895         } else {
4896                 hdsp->card_name = "RME HDSP 9632";
4897                 hdsp->max_channels = 16;
4898                 is_9632 = 1;
4899         }
4900
4901         if ((err = pci_enable_device(pci)) < 0)
4902                 return err;
4903
4904         pci_set_master(hdsp->pci);
4905
4906         if ((err = pci_request_regions(pci, "hdsp")) < 0)
4907                 return err;
4908         hdsp->port = pci_resource_start(pci, 0);
4909         if ((hdsp->iobase = ioremap_nocache(hdsp->port, HDSP_IO_EXTENT)) == NULL) {
4910                 snd_printk(KERN_ERR "Hammerfall-DSP: unable to remap region 0x%lx-0x%lx\n", hdsp->port, hdsp->port + HDSP_IO_EXTENT - 1);
4911                 return -EBUSY;
4912         }
4913
4914         if (request_irq(pci->irq, snd_hdsp_interrupt, SA_INTERRUPT|SA_SHIRQ, "hdsp", (void *)hdsp)) {
4915                 snd_printk(KERN_ERR "Hammerfall-DSP: unable to use IRQ %d\n", pci->irq);
4916                 return -EBUSY;
4917         }
4918
4919         hdsp->irq = pci->irq;
4920         hdsp->precise_ptr = 1;
4921         hdsp->use_midi_tasklet = 1;
4922
4923         if ((err = snd_hdsp_initialize_memory(hdsp)) < 0)
4924                 return err;
4925
4926         if (!is_9652 && !is_9632) {
4927                 /* we wait 2 seconds to let freshly inserted cardbus cards do their hardware init */
4928                 ssleep(2);
4929
4930                 if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
4931 #ifdef HDSP_FW_LOADER
4932                         if ((err = hdsp_request_fw_loader(hdsp)) < 0)
4933                                 /* we don't fail as this can happen
4934                                    if userspace is not ready for
4935                                    firmware upload
4936                                 */
4937                                 snd_printk(KERN_ERR "Hammerfall-DSP: couldn't get firmware from userspace. try using hdsploader\n");
4938                         else
4939                                 /* init is complete, we return */
4940                                 return 0;
4941 #endif
4942                         /* no iobox connected, we defer initialization */
4943                         snd_printk(KERN_INFO "Hammerfall-DSP: card initialization pending : waiting for firmware\n");
4944                         if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0)
4945                                 return err;
4946                         return 0;
4947                 } else {
4948                         snd_printk(KERN_INFO "Hammerfall-DSP: Firmware already present, initializing card.\n");
4949                         if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1)
4950                                 hdsp->io_type = Multiface;
4951                         else
4952                                 hdsp->io_type = Digiface;
4953                 }
4954         }
4955
4956         if ((err = snd_hdsp_enable_io(hdsp)) != 0)
4957                 return err;
4958
4959         if (is_9652)
4960                 hdsp->io_type = H9652;
4961
4962         if (is_9632)
4963                 hdsp->io_type = H9632;
4964
4965         if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0)
4966                 return err;
4967
4968         snd_hdsp_initialize_channels(hdsp);
4969         snd_hdsp_initialize_midi_flush(hdsp);
4970
4971         hdsp->state |= HDSP_FirmwareLoaded;
4972
4973         if ((err = snd_hdsp_create_alsa_devices(card, hdsp)) < 0)
4974                 return err;
4975
4976         return 0;
4977 }
4978
4979 static int snd_hdsp_free(struct hdsp *hdsp)
4980 {
4981         if (hdsp->port) {
4982                 /* stop the audio, and cancel all interrupts */
4983                 tasklet_kill(&hdsp->midi_tasklet);
4984                 hdsp->control_register &= ~(HDSP_Start|HDSP_AudioInterruptEnable|HDSP_Midi0InterruptEnable|HDSP_Midi1InterruptEnable);
4985                 hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register);
4986         }
4987
4988         if (hdsp->irq >= 0)
4989                 free_irq(hdsp->irq, (void *)hdsp);
4990
4991         snd_hdsp_free_buffers(hdsp);
4992
4993         if (hdsp->iobase)
4994                 iounmap(hdsp->iobase);
4995
4996         if (hdsp->port)
4997                 pci_release_regions(hdsp->pci);
4998
4999         pci_disable_device(hdsp->pci);
5000         return 0;
5001 }
5002
5003 static void snd_hdsp_card_free(struct snd_card *card)
5004 {
5005         struct hdsp *hdsp = (struct hdsp *) card->private_data;
5006
5007         if (hdsp)
5008                 snd_hdsp_free(hdsp);
5009 }
5010
5011 static int __devinit snd_hdsp_probe(struct pci_dev *pci,
5012                                     const struct pci_device_id *pci_id)
5013 {
5014         static int dev;
5015         struct hdsp *hdsp;
5016         struct snd_card *card;
5017         int err;
5018
5019         if (dev >= SNDRV_CARDS)
5020                 return -ENODEV;
5021         if (!enable[dev]) {
5022                 dev++;
5023                 return -ENOENT;
5024         }
5025
5026         if (!(card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct hdsp))))
5027                 return -ENOMEM;
5028
5029         hdsp = (struct hdsp *) card->private_data;
5030         card->private_free = snd_hdsp_card_free;
5031         hdsp->dev = dev;
5032         hdsp->pci = pci;
5033         snd_card_set_dev(card, &pci->dev);
5034
5035         if ((err = snd_hdsp_create(card, hdsp)) < 0) {
5036                 snd_card_free(card);
5037                 return err;
5038         }
5039
5040         strcpy(card->shortname, "Hammerfall DSP");
5041         sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name,
5042                 hdsp->port, hdsp->irq);
5043
5044         if ((err = snd_card_register(card)) < 0) {
5045                 snd_card_free(card);
5046                 return err;
5047         }
5048         pci_set_drvdata(pci, card);
5049         dev++;
5050         return 0;
5051 }
5052
5053 static void __devexit snd_hdsp_remove(struct pci_dev *pci)
5054 {
5055         snd_card_free(pci_get_drvdata(pci));
5056         pci_set_drvdata(pci, NULL);
5057 }
5058
5059 static struct pci_driver driver = {
5060         .name =     "RME Hammerfall DSP",
5061         .id_table = snd_hdsp_ids,
5062         .probe =    snd_hdsp_probe,
5063         .remove = __devexit_p(snd_hdsp_remove),
5064 };
5065
5066 static int __init alsa_card_hdsp_init(void)
5067 {
5068         return pci_register_driver(&driver);
5069 }
5070
5071 static void __exit alsa_card_hdsp_exit(void)
5072 {
5073         pci_unregister_driver(&driver);
5074 }
5075
5076 module_init(alsa_card_hdsp_init)
5077 module_exit(alsa_card_hdsp_exit)