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 #ifndef PCI_VENDOR_ID_XILINX
 374 #define PCI_VENDOR_ID_XILINX            0x10ee
 375 #endif
 376 #ifndef PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP
 377 #define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP 0x3fc5
 378 #endif
 379
 380 /* the size of a substream (1 mono data stream) */
 381
 382 #define HDSP_CHANNEL_BUFFER_SAMPLES  (16*1024)
 383 #define HDSP_CHANNEL_BUFFER_BYTES    (4*HDSP_CHANNEL_BUFFER_SAMPLES)
 384
 385 /* the size of the area we need to allocate for DMA transfers. the
 386    size is the same regardless of the number of channels - the
 387    Multiface still uses the same memory area.
 388
 389    Note that we allocate 1 more channel than is apparently needed
 390    because the h/w seems to write 1 byte beyond the end of the last
 391    page. Sigh.
 392 */
 393
 394 #define HDSP_DMA_AREA_BYTES ((HDSP_MAX_CHANNELS+1) * HDSP_CHANNEL_BUFFER_BYTES)
 395 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 396
 397 /* use hotplug firmeare loader? */
 398 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
 399 #ifndef HDSP_USE_HWDEP_LOADER
 400 #define HDSP_FW_LOADER
 401 #endif
 402 #endif
 403
 404 typedef struct _hdsp             hdsp_t;
 405 typedef struct _hdsp_midi        hdsp_midi_t;
 406 typedef struct _hdsp_9632_meters hdsp_9632_meters_t;
 407
 408 struct _hdsp_9632_meters {
 409     u32 input_peak[16];
 410     u32 playback_peak[16];
 411     u32 output_peak[16];
 412     u32 xxx_peak[16];
 413     u32 padding[64];
 414     u32 input_rms_low[16];
 415     u32 playback_rms_low[16];
 416     u32 output_rms_low[16];
 417     u32 xxx_rms_low[16];
 418     u32 input_rms_high[16];
 419     u32 playback_rms_high[16];
 420     u32 output_rms_high[16];
 421     u32 xxx_rms_high[16];
 422 };
 423
 424 struct _hdsp_midi {
 425     hdsp_t                  *hdsp;
 426     int                      id;
 427     snd_rawmidi_t           *rmidi;
 428     snd_rawmidi_substream_t *input;
 429     snd_rawmidi_substream_t *output;
 430     char                     istimer; /* timer in use */
 431     struct timer_list        timer;
 432     spinlock_t               lock;
 433     int                      pending;
 434 };
 435
 436 struct _hdsp {
 437         spinlock_t            lock;
 438         snd_pcm_substream_t  *capture_substream;
 439         snd_pcm_substream_t  *playback_substream;
 440         hdsp_midi_t           midi[2];
 441         struct tasklet_struct midi_tasklet;
 442         int                   use_midi_tasklet;
 443         int                   precise_ptr;
 444         u32                   control_register;      /* cached value */
 445         u32                   control2_register;     /* cached value */
 446         u32                   creg_spdif;
 447         u32                   creg_spdif_stream;
 448         int                   clock_source_locked;
 449         char                 *card_name;             /* digiface/multiface */
 450         HDSP_IO_Type          io_type;               /* ditto, but for code use */
 451         unsigned short        firmware_rev;
 452         unsigned short        state;                 /* stores state bits */
 453         u32                   firmware_cache[24413]; /* this helps recover from accidental iobox power failure */
 454         size_t                period_bytes;          /* guess what this is */
 455         unsigned char         max_channels;
 456         unsigned char         qs_in_channels;        /* quad speed mode for H9632 */
 457         unsigned char         ds_in_channels;
 458         unsigned char         ss_in_channels;       /* different for multiface/digiface */
 459         unsigned char         qs_out_channels;
 460         unsigned char         ds_out_channels;
 461         unsigned char         ss_out_channels;
 462
 463         struct snd_dma_buffer capture_dma_buf;
 464         struct snd_dma_buffer playback_dma_buf;
 465         unsigned char        *capture_buffer;       /* suitably aligned address */
 466         unsigned char        *playback_buffer;      /* suitably aligned address */
 467
 468         pid_t                 capture_pid;
 469         pid_t                 playback_pid;
 470         int                   running;
 471         int                   system_sample_rate;
 472         char                 *channel_map;
 473         int                   dev;
 474         int                   irq;
 475         unsigned long         port;
 476         void __iomem         *iobase;
 477         snd_card_t           *card;
 478         snd_pcm_t            *pcm;
 479         snd_hwdep_t          *hwdep;
 480         struct pci_dev       *pci;
 481         snd_kcontrol_t       *spdif_ctl;
 482         unsigned short        mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
 483 };
 484
 485 /* These tables map the ALSA channels 1..N to the channels that we
 486    need to use in order to find the relevant channel buffer. RME
 487    refer to this kind of mapping as between "the ADAT channel and
 488    the DMA channel." We index it using the logical audio channel,
 489    and the value is the DMA channel (i.e. channel buffer number)
 490    where the data for that channel can be read/written from/to.
 491 */
 492
 493 static char channel_map_df_ss[HDSP_MAX_CHANNELS] = {
 494         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
 495         18, 19, 20, 21, 22, 23, 24, 25
 496 };
 497
 498 static char channel_map_mf_ss[HDSP_MAX_CHANNELS] = { /* Multiface */
 499         /* Analog */
 500         0, 1, 2, 3, 4, 5, 6, 7,
 501         /* ADAT 2 */
 502         16, 17, 18, 19, 20, 21, 22, 23,
 503         /* SPDIF */
 504         24, 25,
 505         -1, -1, -1, -1, -1, -1, -1, -1
 506 };
 507
 508 static char channel_map_ds[HDSP_MAX_CHANNELS] = {
 509         /* ADAT channels are remapped */
 510         1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
 511         /* channels 12 and 13 are S/PDIF */
 512         24, 25,
 513         /* others don't exist */
 514         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 515 };
 516
 517 static char channel_map_H9632_ss[HDSP_MAX_CHANNELS] = {
 518         /* ADAT channels */
 519         0, 1, 2, 3, 4, 5, 6, 7,
 520         /* SPDIF */
 521         8, 9,
 522         /* Analog */
 523         10, 11,
 524         /* AO4S-192 and AI4S-192 extension boards */
 525         12, 13, 14, 15,
 526         /* others don't exist */
 527         -1, -1, -1, -1, -1, -1, -1, -1,
 528         -1, -1
 529 };
 530
 531 static char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
 532         /* ADAT */
 533         1, 3, 5, 7,
 534         /* SPDIF */
 535         8, 9,
 536         /* Analog */
 537         10, 11,
 538         /* AO4S-192 and AI4S-192 extension boards */
 539         12, 13, 14, 15,
 540         /* others don't exist */
 541         -1, -1, -1, -1, -1, -1, -1, -1,
 542         -1, -1, -1, -1, -1, -1
 543 };
 544
 545 static char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = {
 546         /* ADAT is disabled in this mode */
 547         /* SPDIF */
 548         8, 9,
 549         /* Analog */
 550         10, 11,
 551         /* AO4S-192 and AI4S-192 extension boards */
 552         12, 13, 14, 15,
 553         /* others don't exist */
 554         -1, -1, -1, -1, -1, -1, -1, -1,
 555         -1, -1, -1, -1, -1, -1, -1, -1,
 556         -1, -1
 557 };
 558
 559 static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size)
 560 {
 561         dmab->dev.type = SNDRV_DMA_TYPE_DEV;
 562         dmab->dev.dev = snd_dma_pci_data(pci);
 563         if (snd_dma_get_reserved_buf(dmab, snd_dma_pci_buf_id(pci))) {
 564                 if (dmab->bytes >= size)
 565                         return 0;
 566         }
 567         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
 568                                 size, dmab) < 0)
 569                 return -ENOMEM;
 570         return 0;
 571 }
 572
 573 static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci)
 574 {
 575         if (dmab->area) {
 576                 dmab->dev.dev = NULL; /* make it anonymous */
 577                 snd_dma_reserve_buf(dmab, snd_dma_pci_buf_id(pci));
 578         }
 579 }
 580
 581
 582 static struct pci_device_id snd_hdsp_ids[] = {
 583         {
 584                 .vendor = PCI_VENDOR_ID_XILINX,
 585                 .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP,
 586                 .subvendor = PCI_ANY_ID,
 587                 .subdevice = PCI_ANY_ID,
 588         }, /* RME Hammerfall-DSP */
 589         { 0, },
 590 };
 591
 592 MODULE_DEVICE_TABLE(pci, snd_hdsp_ids);
 593
 594 /* prototypes */
 595 static int snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp);
 596 static int snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp);
 597 static int snd_hdsp_enable_io (hdsp_t *hdsp);
 598 static void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp);
 599 static void snd_hdsp_initialize_channels (hdsp_t *hdsp);
 600 static int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout);
 601 static int hdsp_autosync_ref(hdsp_t *hdsp);
 602 static int snd_hdsp_set_defaults(hdsp_t *hdsp);
 603 static void snd_hdsp_9652_enable_mixer (hdsp_t *hdsp);
 604
 605 static int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out)
 606 {
 607         switch (hdsp->firmware_rev) {
 608         case 0xa:
 609                 return (64 * out) + (32 + (in));
 610         case 0x96:
 611         case 0x97:
 612                 return (32 * out) + (16 + (in));
 613         default:
 614                 return (52 * out) + (26 + (in));
 615         }
 616 }
 617
 618 static int hdsp_input_to_output_key (hdsp_t *hdsp, int in, int out)
 619 {
 620         switch (hdsp->firmware_rev) {
 621         case 0xa:
 622                 return (64 * out) + in;
 623         case 0x96:
 624         case 0x97:
 625                 return (32 * out) + in;
 626         default:
 627                 return (52 * out) + in;
 628         }
 629 }
 630
 631 static void hdsp_write(hdsp_t *hdsp, int reg, int val)
 632 {
 633         writel(val, hdsp->iobase + reg);
 634 }
 635
 636 static unsigned int hdsp_read(hdsp_t *hdsp, int reg)
 637 {
 638         return readl (hdsp->iobase + reg);
 639 }
 640
 641 static int hdsp_check_for_iobox (hdsp_t *hdsp)
 642 {
 643
 644         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
 645         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
 646                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
 647                 hdsp->state &= ~HDSP_FirmwareLoaded;
 648                 return -EIO;
 649         }
 650         return 0;
 651
 652 }
 653
 654 static int snd_hdsp_load_firmware_from_cache(hdsp_t *hdsp) {
 655
 656         int i;
 657         unsigned long flags;
 658
 659         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 660
 661                 snd_printk ("Hammerfall-DSP: loading firmware\n");
 662
 663                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_PROGRAM);
 664                 hdsp_write (hdsp, HDSP_fifoData, 0);
 665
 666                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
 667                         snd_printk ("Hammerfall-DSP: timeout waiting for download preparation\n");
 668                         return -EIO;
 669                 }
 670
 671                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 672
 673                 for (i = 0; i < 24413; ++i) {
 674                         hdsp_write(hdsp, HDSP_fifoData, hdsp->firmware_cache[i]);
 675                         if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
 676                                 snd_printk ("Hammerfall-DSP: timeout during firmware loading\n");
 677                                 return -EIO;
 678                         }
 679                 }
 680
 681                 if ((1000 / HZ) < 3000) {
 682                         ssleep(3);
 683                 } else {
 684                         mdelay(3000);
 685                 }
 686
 687                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
 688                         snd_printk ("Hammerfall-DSP: timeout at end of firmware loading\n");
 689                         return -EIO;
 690                 }
 691
 692 #ifdef SNDRV_BIG_ENDIAN
 693                 hdsp->control2_register = HDSP_BIGENDIAN_MODE;
 694 #else
 695                 hdsp->control2_register = 0;
 696 #endif
 697                 hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
 698                 snd_printk ("Hammerfall-DSP: finished firmware loading\n");
 699
 700         }
 701         if (hdsp->state & HDSP_InitializationComplete) {
 702                 snd_printk("Hammerfall-DSP: firmware loaded from cache, restoring defaults\n");
 703                 spin_lock_irqsave(&hdsp->lock, flags);
 704                 snd_hdsp_set_defaults(hdsp);
 705                 spin_unlock_irqrestore(&hdsp->lock, flags);
 706         }
 707
 708         hdsp->state |= HDSP_FirmwareLoaded;
 709
 710         return 0;
 711 }
 712
 713 static int hdsp_get_iobox_version (hdsp_t *hdsp)
 714 {
 715         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 716
 717                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_PROGRAM);
 718                 hdsp_write (hdsp, HDSP_fifoData, 0);
 719                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
 720                         return -EIO;
 721                 }
 722
 723                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 724                 hdsp_write (hdsp, HDSP_fifoData, 0);
 725
 726                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
 727                         hdsp->io_type = Multiface;
 728                         hdsp_write (hdsp, HDSP_control2Reg, HDSP_VERSION_BIT);
 729                         hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
 730                         hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
 731                 } else {
 732                         hdsp->io_type = Digiface;
 733                 }
 734         } else {
 735                 /* firmware was already loaded, get iobox type */
 736                 if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
 737                         hdsp->io_type = Multiface;
 738                 } else {
 739                         hdsp->io_type = Digiface;
 740                 }
 741         }
 742         return 0;
 743 }
 744
 745
 746 static int hdsp_check_for_firmware (hdsp_t *hdsp)
 747 {
 748         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
 749         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
 750                 snd_printk("Hammerfall-DSP: firmware not present.\n");
 751                 hdsp->state &= ~HDSP_FirmwareLoaded;
 752                 return -EIO;
 753         }
 754         return 0;
 755 }
 756
 757
 758 static int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout)
 759 {
 760         int i;
 761
 762         /* the fifoStatus registers reports on how many words
 763            are available in the command FIFO.
 764         */
 765
 766         for (i = 0; i < timeout; i++) {
 767
 768                 if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
 769                         return 0;
 770
 771                 /* not very friendly, but we only do this during a firmware
 772                    load and changing the mixer, so we just put up with it.
 773                 */
 774
 775                 udelay (100);
 776         }
 777
 778         snd_printk ("Hammerfall-DSP: wait for FIFO status <= %d failed after %d iterations\n",
 779                     count, timeout);
 780         return -1;
 781 }
 782
 783 static int hdsp_read_gain (hdsp_t *hdsp, unsigned int addr)
 784 {
 785         if (addr >= HDSP_MATRIX_MIXER_SIZE) {
 786                 return 0;
 787         }
 788         return hdsp->mixer_matrix[addr];
 789 }
 790
 791 static int hdsp_write_gain(hdsp_t *hdsp, unsigned int addr, unsigned short data)
 792 {
 793         unsigned int ad;
 794
 795         if (addr >= HDSP_MATRIX_MIXER_SIZE)
 796                 return -1;
 797
 798         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) {
 799
 800                 /* from martin bjornsen:
 801
 802                    "You can only write dwords to the
 803                    mixer memory which contain two
 804                    mixer values in the low and high
 805                    word. So if you want to change
 806                    value 0 you have to read value 1
 807                    from the cache and write both to
 808                    the first dword in the mixer
 809                    memory."
 810                 */
 811
 812                 if (hdsp->io_type == H9632 && addr >= 512) {
 813                         return 0;
 814                 }
 815
 816                 if (hdsp->io_type == H9652 && addr >= 1352) {
 817                         return 0;
 818                 }
 819
 820                 hdsp->mixer_matrix[addr] = data;
 821
 822
 823                 /* `addr' addresses a 16-bit wide address, but
 824                    the address space accessed via hdsp_write
 825                    uses byte offsets. put another way, addr
 826                    varies from 0 to 1351, but to access the
 827                    corresponding memory location, we need
 828                    to access 0 to 2703 ...
 829                 */
 830                 ad = addr/2;
 831
 832                 hdsp_write (hdsp, 4096 + (ad*4),
 833                             (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) +
 834                             hdsp->mixer_matrix[addr&0x7fe]);
 835
 836                 return 0;
 837
 838         } else {
 839
 840                 ad = (addr << 16) + data;
 841
 842                 if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT)) {
 843                         return -1;
 844                 }
 845
 846                 hdsp_write (hdsp, HDSP_fifoData, ad);
 847                 hdsp->mixer_matrix[addr] = data;
 848
 849         }
 850
 851         return 0;
 852 }
 853
 854 static int snd_hdsp_use_is_exclusive(hdsp_t *hdsp)
 855 {
 856         unsigned long flags;
 857         int ret = 1;
 858
 859         spin_lock_irqsave(&hdsp->lock, flags);
 860         if ((hdsp->playback_pid != hdsp->capture_pid) &&
 861             (hdsp->playback_pid >= 0) && (hdsp->capture_pid >= 0)) {
 862                 ret = 0;
 863         }
 864         spin_unlock_irqrestore(&hdsp->lock, flags);
 865         return ret;
 866 }
 867
 868 static int hdsp_external_sample_rate (hdsp_t *hdsp)
 869 {
 870         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
 871         unsigned int rate_bits = status2 & HDSP_systemFrequencyMask;
 872
 873         switch (rate_bits) {
 874         case HDSP_systemFrequency32:   return 32000;
 875         case HDSP_systemFrequency44_1: return 44100;
 876         case HDSP_systemFrequency48:   return 48000;
 877         case HDSP_systemFrequency64:   return 64000;
 878         case HDSP_systemFrequency88_2: return 88200;
 879         case HDSP_systemFrequency96:   return 96000;
 880         default:
 881                 return 0;
 882         }
 883 }
 884
 885 static int hdsp_spdif_sample_rate(hdsp_t *hdsp)
 886 {
 887         unsigned int status = hdsp_read(hdsp, HDSP_statusRegister);
 888         unsigned int rate_bits = (status & HDSP_spdifFrequencyMask);
 889
 890         if (status & HDSP_SPDIFErrorFlag) {
 891                 return 0;
 892         }
 893
 894         switch (rate_bits) {
 895         case HDSP_spdifFrequency32KHz: return 32000;
 896         case HDSP_spdifFrequency44_1KHz: return 44100;
 897         case HDSP_spdifFrequency48KHz: return 48000;
 898         case HDSP_spdifFrequency64KHz: return 64000;
 899         case HDSP_spdifFrequency88_2KHz: return 88200;
 900         case HDSP_spdifFrequency96KHz: return 96000;
 901         case HDSP_spdifFrequency128KHz:
 902                 if (hdsp->io_type == H9632) return 128000;
 903                 break;
 904         case HDSP_spdifFrequency176_4KHz:
 905                 if (hdsp->io_type == H9632) return 176400;
 906                 break;
 907         case HDSP_spdifFrequency192KHz:
 908                 if (hdsp->io_type == H9632) return 192000;
 909                 break;
 910         default:
 911                 break;
 912         }
 913         snd_printk ("Hammerfall-DSP: unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
 914         return 0;
 915 }
 916
 917 static void hdsp_compute_period_size(hdsp_t *hdsp)
 918 {
 919         hdsp->period_bytes = 1 << ((hdsp_decode_latency(hdsp->control_register) + 8));
 920 }
 921
 922 static snd_pcm_uframes_t hdsp_hw_pointer(hdsp_t *hdsp)
 923 {
 924         int position;
 925
 926         position = hdsp_read(hdsp, HDSP_statusRegister);
 927
 928         if (!hdsp->precise_ptr) {
 929                 return (position & HDSP_BufferID) ? (hdsp->period_bytes / 4) : 0;
 930         }
 931
 932         position &= HDSP_BufferPositionMask;
 933         position /= 4;
 934         position &= (hdsp->period_bytes/2) - 1;
 935         return position;
 936 }
 937
 938 static void hdsp_reset_hw_pointer(hdsp_t *hdsp)
 939 {
 940         hdsp_write (hdsp, HDSP_resetPointer, 0);
 941 }
 942
 943 static void hdsp_start_audio(hdsp_t *s)
 944 {
 945         s->control_register |= (HDSP_AudioInterruptEnable | HDSP_Start);
 946         hdsp_write(s, HDSP_controlRegister, s->control_register);
 947 }
 948
 949 static void hdsp_stop_audio(hdsp_t *s)
 950 {
 951         s->control_register &= ~(HDSP_Start | HDSP_AudioInterruptEnable);
 952         hdsp_write(s, HDSP_controlRegister, s->control_register);
 953 }
 954
 955 static void hdsp_silence_playback(hdsp_t *hdsp)
 956 {
 957         memset(hdsp->playback_buffer, 0, HDSP_DMA_AREA_BYTES);
 958 }
 959
 960 static int hdsp_set_interrupt_interval(hdsp_t *s, unsigned int frames)
 961 {
 962         int n;
 963
 964         spin_lock_irq(&s->lock);
 965
 966         frames >>= 7;
 967         n = 0;
 968         while (frames) {
 969                 n++;
 970                 frames >>= 1;
 971         }
 972
 973         s->control_register &= ~HDSP_LatencyMask;
 974         s->control_register |= hdsp_encode_latency(n);
 975
 976         hdsp_write(s, HDSP_controlRegister, s->control_register);
 977
 978         hdsp_compute_period_size(s);
 979
 980         spin_unlock_irq(&s->lock);
 981
 982         return 0;
 983 }
 984
 985 static int hdsp_set_rate(hdsp_t *hdsp, int rate, int called_internally)
 986 {
 987         int reject_if_open = 0;
 988         int current_rate;
 989         int rate_bits;
 990
 991         /* ASSUMPTION: hdsp->lock is either held, or
 992            there is no need for it (e.g. during module
 993            initialization).
 994         */
 995
 996         if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
 997                 if (called_internally) {
 998                         /* request from ctl or card initialization */
 999                         snd_printk("Hammerfall-DSP: device is not running as a clock master: cannot set sample rate.\n");
1000                         return -1;
1001                 } else {
1002                         /* hw_param request while in AutoSync mode */
1003                         int external_freq = hdsp_external_sample_rate(hdsp);
1004                         int spdif_freq = hdsp_spdif_sample_rate(hdsp);
1005
1006                         if ((spdif_freq == external_freq*2) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1)) {
1007                                 snd_printk("Hammerfall-DSP: Detected ADAT in double speed mode\n");
1008                         } else if (hdsp->io_type == H9632 && (spdif_freq == external_freq*4) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1)) {
1009                                 snd_printk("Hammerfall-DSP: Detected ADAT in quad speed mode\n");
1010                         } else if (rate != external_freq) {
1011                                 snd_printk("Hammerfall-DSP: No AutoSync source for requested rate\n");
1012                                 return -1;
1013                         }
1014                 }
1015         }
1016
1017         current_rate = hdsp->system_sample_rate;
1018
1019         /* Changing from a "single speed" to a "double speed" rate is
1020            not allowed if any substreams are open. This is because
1021            such a change causes a shift in the location of
1022            the DMA buffers and a reduction in the number of available
1023            buffers.
1024
1025            Note that a similar but essentially insoluble problem
1026            exists for externally-driven rate changes. All we can do
1027            is to flag rate changes in the read/write routines.  */
1028
1029         if (rate > 96000 && hdsp->io_type != H9632) {
1030                 return -EINVAL;
1031         }
1032
1033         switch (rate) {
1034         case 32000:
1035                 if (current_rate > 48000) {
1036                         reject_if_open = 1;
1037                 }
1038                 rate_bits = HDSP_Frequency32KHz;
1039                 break;
1040         case 44100:
1041                 if (current_rate > 48000) {
1042                         reject_if_open = 1;
1043                 }
1044                 rate_bits = HDSP_Frequency44_1KHz;
1045                 break;
1046         case 48000:
1047                 if (current_rate > 48000) {
1048                         reject_if_open = 1;
1049                 }
1050                 rate_bits = HDSP_Frequency48KHz;
1051                 break;
1052         case 64000:
1053                 if (current_rate <= 48000 || current_rate > 96000) {
1054                         reject_if_open = 1;
1055                 }
1056                 rate_bits = HDSP_Frequency64KHz;
1057                 break;
1058         case 88200:
1059                 if (current_rate <= 48000 || current_rate > 96000) {
1060                         reject_if_open = 1;
1061                 }
1062                 rate_bits = HDSP_Frequency88_2KHz;
1063                 break;
1064         case 96000:
1065                 if (current_rate <= 48000 || current_rate > 96000) {
1066                         reject_if_open = 1;
1067                 }
1068                 rate_bits = HDSP_Frequency96KHz;
1069                 break;
1070         case 128000:
1071                 if (current_rate < 128000) {
1072                         reject_if_open = 1;
1073                 }
1074                 rate_bits = HDSP_Frequency128KHz;
1075                 break;
1076         case 176400:
1077                 if (current_rate < 128000) {
1078                         reject_if_open = 1;
1079                 }
1080                 rate_bits = HDSP_Frequency176_4KHz;
1081                 break;
1082         case 192000:
1083                 if (current_rate < 128000) {
1084                         reject_if_open = 1;
1085                 }
1086                 rate_bits = HDSP_Frequency192KHz;
1087                 break;
1088         default:
1089                 return -EINVAL;
1090         }
1091
1092         if (reject_if_open && (hdsp->capture_pid >= 0 || hdsp->playback_pid >= 0)) {
1093                 snd_printk ("Hammerfall-DSP: cannot change speed mode (capture PID = %d, playback PID = %d)\n",
1094                             hdsp->capture_pid,
1095                             hdsp->playback_pid);
1096                 return -EBUSY;
1097         }
1098
1099         hdsp->control_register &= ~HDSP_FrequencyMask;
1100         hdsp->control_register |= rate_bits;
1101         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1102
1103         if (rate >= 128000) {
1104                 hdsp->channel_map = channel_map_H9632_qs;
1105         } else if (rate > 48000) {
1106                 if (hdsp->io_type == H9632) {
1107                         hdsp->channel_map = channel_map_H9632_ds;
1108                 } else {
1109                         hdsp->channel_map = channel_map_ds;
1110                 }
1111         } else {
1112                 switch (hdsp->io_type) {
1113                 case Multiface:
1114                         hdsp->channel_map = channel_map_mf_ss;
1115                         break;
1116                 case Digiface:
1117                 case H9652:
1118                         hdsp->channel_map = channel_map_df_ss;
1119                         break;
1120                 case H9632:
1121                         hdsp->channel_map = channel_map_H9632_ss;
1122                         break;
1123                 default:
1124                         /* should never happen */
1125                         break;
1126                 }
1127         }
1128
1129         hdsp->system_sample_rate = rate;
1130
1131         return 0;
1132 }
1133
1134 /*----------------------------------------------------------------------------
1135    MIDI
1136   ----------------------------------------------------------------------------*/
1137
1138 static unsigned char snd_hdsp_midi_read_byte (hdsp_t *hdsp, int id)
1139 {
1140         /* the hardware already does the relevant bit-mask with 0xff */
1141         if (id) {
1142                 return hdsp_read(hdsp, HDSP_midiDataIn1);
1143         } else {
1144                 return hdsp_read(hdsp, HDSP_midiDataIn0);
1145         }
1146 }
1147
1148 static void snd_hdsp_midi_write_byte (hdsp_t *hdsp, int id, int val)
1149 {
1150         /* the hardware already does the relevant bit-mask with 0xff */
1151         if (id) {
1152                 hdsp_write(hdsp, HDSP_midiDataOut1, val);
1153         } else {
1154                 hdsp_write(hdsp, HDSP_midiDataOut0, val);
1155         }
1156 }
1157
1158 static int snd_hdsp_midi_input_available (hdsp_t *hdsp, int id)
1159 {
1160         if (id) {
1161                 return (hdsp_read(hdsp, HDSP_midiStatusIn1) & 0xff);
1162         } else {
1163                 return (hdsp_read(hdsp, HDSP_midiStatusIn0) & 0xff);
1164         }
1165 }
1166
1167 static int snd_hdsp_midi_output_possible (hdsp_t *hdsp, int id)
1168 {
1169         int fifo_bytes_used;
1170
1171         if (id) {
1172                 fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff;
1173         } else {
1174                 fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff;
1175         }
1176
1177         if (fifo_bytes_used < 128) {
1178                 return  128 - fifo_bytes_used;
1179         } else {
1180                 return 0;
1181         }
1182 }
1183
1184 static void snd_hdsp_flush_midi_input (hdsp_t *hdsp, int id)
1185 {
1186         while (snd_hdsp_midi_input_available (hdsp, id)) {
1187                 snd_hdsp_midi_read_byte (hdsp, id);
1188         }
1189 }
1190
1191 static int snd_hdsp_midi_output_write (hdsp_midi_t *hmidi)
1192 {
1193         unsigned long flags;
1194         int n_pending;
1195         int to_write;
1196         int i;
1197         unsigned char buf[128];
1198
1199         /* Output is not interrupt driven */
1200
1201         spin_lock_irqsave (&hmidi->lock, flags);
1202         if (hmidi->output) {
1203                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
1204                         if ((n_pending = snd_hdsp_midi_output_possible (hmidi->hdsp, hmidi->id)) > 0) {
1205                                 if (n_pending > (int)sizeof (buf))
1206                                         n_pending = sizeof (buf);
1207
1208                                 if ((to_write = snd_rawmidi_transmit (hmidi->output, buf, n_pending)) > 0) {
1209                                         for (i = 0; i < to_write; ++i)
1210                                                 snd_hdsp_midi_write_byte (hmidi->hdsp, hmidi->id, buf[i]);
1211                                 }
1212                         }
1213                 }
1214         }
1215         spin_unlock_irqrestore (&hmidi->lock, flags);
1216         return 0;
1217 }
1218
1219 static int snd_hdsp_midi_input_read (hdsp_midi_t *hmidi)
1220 {
1221         unsigned char buf[128]; /* this buffer is designed to match the MIDI input FIFO size */
1222         unsigned long flags;
1223         int n_pending;
1224         int i;
1225
1226         spin_lock_irqsave (&hmidi->lock, flags);
1227         if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
1228                 if (hmidi->input) {
1229                         if (n_pending > (int)sizeof (buf)) {
1230                                 n_pending = sizeof (buf);
1231                         }
1232                         for (i = 0; i < n_pending; ++i) {
1233                                 buf[i] = snd_hdsp_midi_read_byte (hmidi->hdsp, hmidi->id);
1234                         }
1235                         if (n_pending) {
1236                                 snd_rawmidi_receive (hmidi->input, buf, n_pending);
1237                         }
1238                 } else {
1239                         /* flush the MIDI input FIFO */
1240                         while (--n_pending) {
1241                                 snd_hdsp_midi_read_byte (hmidi->hdsp, hmidi->id);
1242                         }
1243                 }
1244         }
1245         hmidi->pending = 0;
1246         if (hmidi->id) {
1247                 hmidi->hdsp->control_register |= HDSP_Midi1InterruptEnable;
1248         } else {
1249                 hmidi->hdsp->control_register |= HDSP_Midi0InterruptEnable;
1250         }
1251         hdsp_write(hmidi->hdsp, HDSP_controlRegister, hmidi->hdsp->control_register);
1252         spin_unlock_irqrestore (&hmidi->lock, flags);
1253         return snd_hdsp_midi_output_write (hmidi);
1254 }
1255
1256 static void snd_hdsp_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
1257 {
1258         hdsp_t *hdsp;
1259         hdsp_midi_t *hmidi;
1260         unsigned long flags;
1261         u32 ie;
1262
1263         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1264         hdsp = hmidi->hdsp;
1265         ie = hmidi->id ? HDSP_Midi1InterruptEnable : HDSP_Midi0InterruptEnable;
1266         spin_lock_irqsave (&hdsp->lock, flags);
1267         if (up) {
1268                 if (!(hdsp->control_register & ie)) {
1269                         snd_hdsp_flush_midi_input (hdsp, hmidi->id);
1270                         hdsp->control_register |= ie;
1271                 }
1272         } else {
1273                 hdsp->control_register &= ~ie;
1274                 tasklet_kill(&hdsp->midi_tasklet);
1275         }
1276
1277         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1278         spin_unlock_irqrestore (&hdsp->lock, flags);
1279 }
1280
1281 static void snd_hdsp_midi_output_timer(unsigned long data)
1282 {
1283         hdsp_midi_t *hmidi = (hdsp_midi_t *) data;
1284         unsigned long flags;
1285
1286         snd_hdsp_midi_output_write(hmidi);
1287         spin_lock_irqsave (&hmidi->lock, flags);
1288
1289         /* this does not bump hmidi->istimer, because the
1290            kernel automatically removed the timer when it
1291            expired, and we are now adding it back, thus
1292            leaving istimer wherever it was set before.
1293         */
1294
1295         if (hmidi->istimer) {
1296                 hmidi->timer.expires = 1 + jiffies;
1297                 add_timer(&hmidi->timer);
1298         }
1299
1300         spin_unlock_irqrestore (&hmidi->lock, flags);
1301 }
1302
1303 static void snd_hdsp_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
1304 {
1305         hdsp_midi_t *hmidi;
1306         unsigned long flags;
1307
1308         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1309         spin_lock_irqsave (&hmidi->lock, flags);
1310         if (up) {
1311                 if (!hmidi->istimer) {
1312                         init_timer(&hmidi->timer);
1313                         hmidi->timer.function = snd_hdsp_midi_output_timer;
1314                         hmidi->timer.data = (unsigned long) hmidi;
1315                         hmidi->timer.expires = 1 + jiffies;
1316                         add_timer(&hmidi->timer);
1317                         hmidi->istimer++;
1318                 }
1319         } else {
1320                 if (hmidi->istimer && --hmidi->istimer <= 0) {
1321                         del_timer (&hmidi->timer);
1322                 }
1323         }
1324         spin_unlock_irqrestore (&hmidi->lock, flags);
1325         if (up)
1326                 snd_hdsp_midi_output_write(hmidi);
1327 }
1328
1329 static int snd_hdsp_midi_input_open(snd_rawmidi_substream_t * substream)
1330 {
1331         hdsp_midi_t *hmidi;
1332
1333         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1334         spin_lock_irq (&hmidi->lock);
1335         snd_hdsp_flush_midi_input (hmidi->hdsp, hmidi->id);
1336         hmidi->input = substream;
1337         spin_unlock_irq (&hmidi->lock);
1338
1339         return 0;
1340 }
1341
1342 static int snd_hdsp_midi_output_open(snd_rawmidi_substream_t * substream)
1343 {
1344         hdsp_midi_t *hmidi;
1345
1346         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1347         spin_lock_irq (&hmidi->lock);
1348         hmidi->output = substream;
1349         spin_unlock_irq (&hmidi->lock);
1350
1351         return 0;
1352 }
1353
1354 static int snd_hdsp_midi_input_close(snd_rawmidi_substream_t * substream)
1355 {
1356         hdsp_midi_t *hmidi;
1357
1358         snd_hdsp_midi_input_trigger (substream, 0);
1359
1360         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1361         spin_lock_irq (&hmidi->lock);
1362         hmidi->input = NULL;
1363         spin_unlock_irq (&hmidi->lock);
1364
1365         return 0;
1366 }
1367
1368 static int snd_hdsp_midi_output_close(snd_rawmidi_substream_t * substream)
1369 {
1370         hdsp_midi_t *hmidi;
1371
1372         snd_hdsp_midi_output_trigger (substream, 0);
1373
1374         hmidi = (hdsp_midi_t *) substream->rmidi->private_data;
1375         spin_lock_irq (&hmidi->lock);
1376         hmidi->output = NULL;
1377         spin_unlock_irq (&hmidi->lock);
1378
1379         return 0;
1380 }
1381
1382 static snd_rawmidi_ops_t snd_hdsp_midi_output =
1383 {
1384         .open =         snd_hdsp_midi_output_open,
1385         .close =        snd_hdsp_midi_output_close,
1386         .trigger =      snd_hdsp_midi_output_trigger,
1387 };
1388
1389 static snd_rawmidi_ops_t snd_hdsp_midi_input =
1390 {
1391         .open =         snd_hdsp_midi_input_open,
1392         .close =        snd_hdsp_midi_input_close,
1393         .trigger =      snd_hdsp_midi_input_trigger,
1394 };
1395
1396 static int __devinit snd_hdsp_create_midi (snd_card_t *card, hdsp_t *hdsp, int id)
1397 {
1398         char buf[32];
1399
1400         hdsp->midi[id].id = id;
1401         hdsp->midi[id].rmidi = NULL;
1402         hdsp->midi[id].input = NULL;
1403         hdsp->midi[id].output = NULL;
1404         hdsp->midi[id].hdsp = hdsp;
1405         hdsp->midi[id].istimer = 0;
1406         hdsp->midi[id].pending = 0;
1407         spin_lock_init (&hdsp->midi[id].lock);
1408
1409         sprintf (buf, "%s MIDI %d", card->shortname, id+1);
1410         if (snd_rawmidi_new (card, buf, id, 1, 1, &hdsp->midi[id].rmidi) < 0) {
1411                 return -1;
1412         }
1413
1414         sprintf (hdsp->midi[id].rmidi->name, "%s MIDI %d", card->id, id+1);
1415         hdsp->midi[id].rmidi->private_data = &hdsp->midi[id];
1416
1417         snd_rawmidi_set_ops (hdsp->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_hdsp_midi_output);
1418         snd_rawmidi_set_ops (hdsp->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_hdsp_midi_input);
1419
1420         hdsp->midi[id].rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
1421                 SNDRV_RAWMIDI_INFO_INPUT |
1422                 SNDRV_RAWMIDI_INFO_DUPLEX;
1423
1424         return 0;
1425 }
1426
1427 /*-----------------------------------------------------------------------------
1428   Control Interface
1429   ----------------------------------------------------------------------------*/
1430
1431 static u32 snd_hdsp_convert_from_aes(snd_aes_iec958_t *aes)
1432 {
1433         u32 val = 0;
1434         val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? HDSP_SPDIFProfessional : 0;
1435         val |= (aes->status[0] & IEC958_AES0_NONAUDIO) ? HDSP_SPDIFNonAudio : 0;
1436         if (val & HDSP_SPDIFProfessional)
1437                 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? HDSP_SPDIFEmphasis : 0;
1438         else
1439                 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? HDSP_SPDIFEmphasis : 0;
1440         return val;
1441 }
1442
1443 static void snd_hdsp_convert_to_aes(snd_aes_iec958_t *aes, u32 val)
1444 {
1445         aes->status[0] = ((val & HDSP_SPDIFProfessional) ? IEC958_AES0_PROFESSIONAL : 0) |
1446                          ((val & HDSP_SPDIFNonAudio) ? IEC958_AES0_NONAUDIO : 0);
1447         if (val & HDSP_SPDIFProfessional)
1448                 aes->status[0] |= (val & HDSP_SPDIFEmphasis) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0;
1449         else
1450                 aes->status[0] |= (val & HDSP_SPDIFEmphasis) ? IEC958_AES0_CON_EMPHASIS_5015 : 0;
1451 }
1452
1453 static int snd_hdsp_control_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1454 {
1455         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1456         uinfo->count = 1;
1457         return 0;
1458 }
1459
1460 static int snd_hdsp_control_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1461 {
1462         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1463
1464         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif);
1465         return 0;
1466 }
1467
1468 static int snd_hdsp_control_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1469 {
1470         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1471         int change;
1472         u32 val;
1473
1474         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
1475         spin_lock_irq(&hdsp->lock);
1476         change = val != hdsp->creg_spdif;
1477         hdsp->creg_spdif = val;
1478         spin_unlock_irq(&hdsp->lock);
1479         return change;
1480 }
1481
1482 static int snd_hdsp_control_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1483 {
1484         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1485         uinfo->count = 1;
1486         return 0;
1487 }
1488
1489 static int snd_hdsp_control_spdif_stream_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1490 {
1491         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1492
1493         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif_stream);
1494         return 0;
1495 }
1496
1497 static int snd_hdsp_control_spdif_stream_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1498 {
1499         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1500         int change;
1501         u32 val;
1502
1503         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
1504         spin_lock_irq(&hdsp->lock);
1505         change = val != hdsp->creg_spdif_stream;
1506         hdsp->creg_spdif_stream = val;
1507         hdsp->control_register &= ~(HDSP_SPDIFProfessional | HDSP_SPDIFNonAudio | HDSP_SPDIFEmphasis);
1508         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register |= val);
1509         spin_unlock_irq(&hdsp->lock);
1510         return change;
1511 }
1512
1513 static int snd_hdsp_control_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1514 {
1515         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1516         uinfo->count = 1;
1517         return 0;
1518 }
1519
1520 static int snd_hdsp_control_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1521 {
1522         ucontrol->value.iec958.status[0] = kcontrol->private_value;
1523         return 0;
1524 }
1525
1526 #define HDSP_SPDIF_IN(xname, xindex) \
1527 { .iface = SNDRV_CTL_ELEM_IFACE_PCM,  \
1528   .name = xname, \
1529   .index = xindex, \
1530   .info = snd_hdsp_info_spdif_in, \
1531   .get = snd_hdsp_get_spdif_in, \
1532   .put = snd_hdsp_put_spdif_in }
1533
1534 static unsigned int hdsp_spdif_in(hdsp_t *hdsp)
1535 {
1536         return hdsp_decode_spdif_in(hdsp->control_register & HDSP_SPDIFInputMask);
1537 }
1538
1539 static int hdsp_set_spdif_input(hdsp_t *hdsp, int in)
1540 {
1541         hdsp->control_register &= ~HDSP_SPDIFInputMask;
1542         hdsp->control_register |= hdsp_encode_spdif_in(in);
1543         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1544         return 0;
1545 }
1546
1547 static int snd_hdsp_info_spdif_in(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1548 {
1549         static char *texts[4] = {"Optical", "Coaxial", "Internal", "AES"};
1550         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1551
1552         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1553         uinfo->count = 1;
1554         uinfo->value.enumerated.items = ((hdsp->io_type == H9632) ? 4 : 3);
1555         if (uinfo->value.enumerated.item > ((hdsp->io_type == H9632) ? 3 : 2))
1556                 uinfo->value.enumerated.item = ((hdsp->io_type == H9632) ? 3 : 2);
1557         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1558         return 0;
1559 }
1560
1561 static int snd_hdsp_get_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1562 {
1563         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1564
1565         ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp);
1566         return 0;
1567 }
1568
1569 static int snd_hdsp_put_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1570 {
1571         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1572         int change;
1573         unsigned int val;
1574
1575         if (!snd_hdsp_use_is_exclusive(hdsp))
1576                 return -EBUSY;
1577         val = ucontrol->value.enumerated.item[0] % ((hdsp->io_type == H9632) ? 4 : 3);
1578         spin_lock_irq(&hdsp->lock);
1579         change = val != hdsp_spdif_in(hdsp);
1580         if (change)
1581                 hdsp_set_spdif_input(hdsp, val);
1582         spin_unlock_irq(&hdsp->lock);
1583         return change;
1584 }
1585
1586 #define HDSP_SPDIF_OUT(xname, xindex) \
1587 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
1588   .info = snd_hdsp_info_spdif_bits, \
1589   .get = snd_hdsp_get_spdif_out, .put = snd_hdsp_put_spdif_out }
1590
1591 static int hdsp_spdif_out(hdsp_t *hdsp)
1592 {
1593         return (hdsp->control_register & HDSP_SPDIFOpticalOut) ? 1 : 0;
1594 }
1595
1596 static int hdsp_set_spdif_output(hdsp_t *hdsp, int out)
1597 {
1598         if (out) {
1599                 hdsp->control_register |= HDSP_SPDIFOpticalOut;
1600         } else {
1601                 hdsp->control_register &= ~HDSP_SPDIFOpticalOut;
1602         }
1603         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1604         return 0;
1605 }
1606
1607 static int snd_hdsp_info_spdif_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1608 {
1609         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1610         uinfo->count = 1;
1611         uinfo->value.integer.min = 0;
1612         uinfo->value.integer.max = 1;
1613         return 0;
1614 }
1615
1616 static int snd_hdsp_get_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1617 {
1618         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1619
1620         ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp);
1621         return 0;
1622 }
1623
1624 static int snd_hdsp_put_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1625 {
1626         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1627         int change;
1628         unsigned int val;
1629
1630         if (!snd_hdsp_use_is_exclusive(hdsp))
1631                 return -EBUSY;
1632         val = ucontrol->value.integer.value[0] & 1;
1633         spin_lock_irq(&hdsp->lock);
1634         change = (int)val != hdsp_spdif_out(hdsp);
1635         hdsp_set_spdif_output(hdsp, val);
1636         spin_unlock_irq(&hdsp->lock);
1637         return change;
1638 }
1639
1640 #define HDSP_SPDIF_PROFESSIONAL(xname, xindex) \
1641 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
1642   .info = snd_hdsp_info_spdif_bits, \
1643   .get = snd_hdsp_get_spdif_professional, .put = snd_hdsp_put_spdif_professional }
1644
1645 static int hdsp_spdif_professional(hdsp_t *hdsp)
1646 {
1647         return (hdsp->control_register & HDSP_SPDIFProfessional) ? 1 : 0;
1648 }
1649
1650 static int hdsp_set_spdif_professional(hdsp_t *hdsp, int val)
1651 {
1652         if (val) {
1653                 hdsp->control_register |= HDSP_SPDIFProfessional;
1654         } else {
1655                 hdsp->control_register &= ~HDSP_SPDIFProfessional;
1656         }
1657         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1658         return 0;
1659 }
1660
1661 static int snd_hdsp_get_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1662 {
1663         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1664
1665         ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp);
1666         return 0;
1667 }
1668
1669 static int snd_hdsp_put_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1670 {
1671         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1672         int change;
1673         unsigned int val;
1674
1675         if (!snd_hdsp_use_is_exclusive(hdsp))
1676                 return -EBUSY;
1677         val = ucontrol->value.integer.value[0] & 1;
1678         spin_lock_irq(&hdsp->lock);
1679         change = (int)val != hdsp_spdif_professional(hdsp);
1680         hdsp_set_spdif_professional(hdsp, val);
1681         spin_unlock_irq(&hdsp->lock);
1682         return change;
1683 }
1684
1685 #define HDSP_SPDIF_EMPHASIS(xname, xindex) \
1686 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
1687   .info = snd_hdsp_info_spdif_bits, \
1688   .get = snd_hdsp_get_spdif_emphasis, .put = snd_hdsp_put_spdif_emphasis }
1689
1690 static int hdsp_spdif_emphasis(hdsp_t *hdsp)
1691 {
1692         return (hdsp->control_register & HDSP_SPDIFEmphasis) ? 1 : 0;
1693 }
1694
1695 static int hdsp_set_spdif_emphasis(hdsp_t *hdsp, int val)
1696 {
1697         if (val) {
1698                 hdsp->control_register |= HDSP_SPDIFEmphasis;
1699         } else {
1700                 hdsp->control_register &= ~HDSP_SPDIFEmphasis;
1701         }
1702         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1703         return 0;
1704 }
1705
1706 static int snd_hdsp_get_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1707 {
1708         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1709
1710         ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp);
1711         return 0;
1712 }
1713
1714 static int snd_hdsp_put_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1715 {
1716         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1717         int change;
1718         unsigned int val;
1719
1720         if (!snd_hdsp_use_is_exclusive(hdsp))
1721                 return -EBUSY;
1722         val = ucontrol->value.integer.value[0] & 1;
1723         spin_lock_irq(&hdsp->lock);
1724         change = (int)val != hdsp_spdif_emphasis(hdsp);
1725         hdsp_set_spdif_emphasis(hdsp, val);
1726         spin_unlock_irq(&hdsp->lock);
1727         return change;
1728 }
1729
1730 #define HDSP_SPDIF_NON_AUDIO(xname, xindex) \
1731 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
1732   .info = snd_hdsp_info_spdif_bits, \
1733   .get = snd_hdsp_get_spdif_nonaudio, .put = snd_hdsp_put_spdif_nonaudio }
1734
1735 static int hdsp_spdif_nonaudio(hdsp_t *hdsp)
1736 {
1737         return (hdsp->control_register & HDSP_SPDIFNonAudio) ? 1 : 0;
1738 }
1739
1740 static int hdsp_set_spdif_nonaudio(hdsp_t *hdsp, int val)
1741 {
1742         if (val) {
1743                 hdsp->control_register |= HDSP_SPDIFNonAudio;
1744         } else {
1745                 hdsp->control_register &= ~HDSP_SPDIFNonAudio;
1746         }
1747         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
1748         return 0;
1749 }
1750
1751 static int snd_hdsp_get_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1752 {
1753         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1754
1755         ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp);
1756         return 0;
1757 }
1758
1759 static int snd_hdsp_put_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1760 {
1761         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1762         int change;
1763         unsigned int val;
1764
1765         if (!snd_hdsp_use_is_exclusive(hdsp))
1766                 return -EBUSY;
1767         val = ucontrol->value.integer.value[0] & 1;
1768         spin_lock_irq(&hdsp->lock);
1769         change = (int)val != hdsp_spdif_nonaudio(hdsp);
1770         hdsp_set_spdif_nonaudio(hdsp, val);
1771         spin_unlock_irq(&hdsp->lock);
1772         return change;
1773 }
1774
1775 #define HDSP_SPDIF_SAMPLE_RATE(xname, xindex) \
1776 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
1777   .name = xname, \
1778   .index = xindex, \
1779   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1780   .info = snd_hdsp_info_spdif_sample_rate, \
1781   .get = snd_hdsp_get_spdif_sample_rate \
1782 }
1783
1784 static int snd_hdsp_info_spdif_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1785 {
1786         static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
1787         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1788
1789         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1790         uinfo->count = 1;
1791         uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7;
1792         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1793                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1794         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1795         return 0;
1796 }
1797
1798 static int snd_hdsp_get_spdif_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1799 {
1800         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1801
1802         switch (hdsp_spdif_sample_rate(hdsp)) {
1803         case 32000:
1804                 ucontrol->value.enumerated.item[0] = 0;
1805                 break;
1806         case 44100:
1807                 ucontrol->value.enumerated.item[0] = 1;
1808                 break;
1809         case 48000:
1810                 ucontrol->value.enumerated.item[0] = 2;
1811                 break;
1812         case 64000:
1813                 ucontrol->value.enumerated.item[0] = 3;
1814                 break;
1815         case 88200:
1816                 ucontrol->value.enumerated.item[0] = 4;
1817                 break;
1818         case 96000:
1819                 ucontrol->value.enumerated.item[0] = 5;
1820                 break;
1821         case 128000:
1822                 ucontrol->value.enumerated.item[0] = 7;
1823                 break;
1824         case 176400:
1825                 ucontrol->value.enumerated.item[0] = 8;
1826                 break;
1827         case 192000:
1828                 ucontrol->value.enumerated.item[0] = 9;
1829                 break;
1830         default:
1831                 ucontrol->value.enumerated.item[0] = 6;
1832         }
1833         return 0;
1834 }
1835
1836 #define HDSP_SYSTEM_SAMPLE_RATE(xname, xindex) \
1837 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
1838   .name = xname, \
1839   .index = xindex, \
1840   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1841   .info = snd_hdsp_info_system_sample_rate, \
1842   .get = snd_hdsp_get_system_sample_rate \
1843 }
1844
1845 static int snd_hdsp_info_system_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1846 {
1847         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1848         uinfo->count = 1;
1849         return 0;
1850 }
1851
1852 static int snd_hdsp_get_system_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1853 {
1854         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1855
1856         ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate;
1857         return 0;
1858 }
1859
1860 #define HDSP_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
1861 { .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
1862   .name = xname, \
1863   .index = xindex, \
1864   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1865   .info = snd_hdsp_info_autosync_sample_rate, \
1866   .get = snd_hdsp_get_autosync_sample_rate \
1867 }
1868
1869 static int snd_hdsp_info_autosync_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1870 {
1871         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1872         static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
1873         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1874         uinfo->count = 1;
1875         uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7 ;
1876         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1877                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1878         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1879         return 0;
1880 }
1881
1882 static int snd_hdsp_get_autosync_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1883 {
1884         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1885
1886         switch (hdsp_external_sample_rate(hdsp)) {
1887         case 32000:
1888                 ucontrol->value.enumerated.item[0] = 0;
1889                 break;
1890         case 44100:
1891                 ucontrol->value.enumerated.item[0] = 1;
1892                 break;
1893         case 48000:
1894                 ucontrol->value.enumerated.item[0] = 2;
1895                 break;
1896         case 64000:
1897                 ucontrol->value.enumerated.item[0] = 3;
1898                 break;
1899         case 88200:
1900                 ucontrol->value.enumerated.item[0] = 4;
1901                 break;
1902         case 96000:
1903                 ucontrol->value.enumerated.item[0] = 5;
1904                 break;
1905         case 128000:
1906                 ucontrol->value.enumerated.item[0] = 7;
1907                 break;
1908         case 176400:
1909                 ucontrol->value.enumerated.item[0] = 8;
1910                 break;
1911         case 192000:
1912                 ucontrol->value.enumerated.item[0] = 9;
1913                 break;
1914         default:
1915                 ucontrol->value.enumerated.item[0] = 6;
1916         }
1917         return 0;
1918 }
1919
1920 #define HDSP_SYSTEM_CLOCK_MODE(xname, xindex) \
1921 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
1922   .name = xname, \
1923   .index = xindex, \
1924   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
1925   .info = snd_hdsp_info_system_clock_mode, \
1926   .get = snd_hdsp_get_system_clock_mode \
1927 }
1928
1929 static int hdsp_system_clock_mode(hdsp_t *hdsp)
1930 {
1931         if (hdsp->control_register & HDSP_ClockModeMaster) {
1932                 return 0;
1933         } else if (hdsp_external_sample_rate(hdsp) != hdsp->system_sample_rate) {
1934                         return 0;
1935         }
1936         return 1;
1937 }
1938
1939 static int snd_hdsp_info_system_clock_mode(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1940 {
1941         static char *texts[] = {"Master", "Slave" };
1942
1943         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1944         uinfo->count = 1;
1945         uinfo->value.enumerated.items = 2;
1946         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1947                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1948         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1949         return 0;
1950 }
1951
1952 static int snd_hdsp_get_system_clock_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1953 {
1954         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
1955
1956         ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp);
1957         return 0;
1958 }
1959
1960 #define HDSP_CLOCK_SOURCE(xname, xindex) \
1961 { .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
1962   .name = xname, \
1963   .index = xindex, \
1964   .info = snd_hdsp_info_clock_source, \
1965   .get = snd_hdsp_get_clock_source, \
1966   .put = snd_hdsp_put_clock_source \
1967 }
1968
1969 static int hdsp_clock_source(hdsp_t *hdsp)
1970 {
1971         if (hdsp->control_register & HDSP_ClockModeMaster) {
1972                 switch (hdsp->system_sample_rate) {
1973                 case 32000:
1974                         return 1;
1975                 case 44100:
1976                         return 2;
1977                 case 48000:
1978                         return 3;
1979                 case 64000:
1980                         return 4;
1981                 case 88200:
1982                         return 5;
1983                 case 96000:
1984                         return 6;
1985                 case 128000:
1986                         return 7;
1987                 case 176400:
1988                         return 8;
1989                 case 192000:
1990                         return 9;
1991                 default:
1992                         return 3;
1993                 }
1994         } else {
1995                 return 0;
1996         }
1997 }
1998
1999 static int hdsp_set_clock_source(hdsp_t *hdsp, int mode)
2000 {
2001         int rate;
2002         switch (mode) {
2003         case HDSP_CLOCK_SOURCE_AUTOSYNC:
2004                 if (hdsp_external_sample_rate(hdsp) != 0) {
2005                     if (!hdsp_set_rate(hdsp, hdsp_external_sample_rate(hdsp), 1)) {
2006                         hdsp->control_register &= ~HDSP_ClockModeMaster;
2007                         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2008                         return 0;
2009                     }
2010                 }
2011                 return -1;
2012         case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
2013                 rate = 32000;
2014                 break;
2015         case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
2016                 rate = 44100;
2017                 break;
2018         case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
2019                 rate = 48000;
2020                 break;
2021         case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
2022                 rate = 64000;
2023                 break;
2024         case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
2025                 rate = 88200;
2026                 break;
2027         case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
2028                 rate = 96000;
2029                 break;
2030         case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
2031                 rate = 128000;
2032                 break;
2033         case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
2034                 rate = 176400;
2035                 break;
2036         case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
2037                 rate = 192000;
2038                 break;
2039         default:
2040                 rate = 48000;
2041         }
2042         hdsp->control_register |= HDSP_ClockModeMaster;
2043         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2044         hdsp_set_rate(hdsp, rate, 1);
2045         return 0;
2046 }
2047
2048 static int snd_hdsp_info_clock_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2049 {
2050         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" };
2051         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2052
2053         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2054         uinfo->count = 1;
2055         if (hdsp->io_type == H9632)
2056             uinfo->value.enumerated.items = 10;
2057         else
2058             uinfo->value.enumerated.items = 7;
2059         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2060                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2061         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2062         return 0;
2063 }
2064
2065 static int snd_hdsp_get_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2066 {
2067         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2068
2069         ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp);
2070         return 0;
2071 }
2072
2073 static int snd_hdsp_put_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2074 {
2075         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2076         int change;
2077         int val;
2078
2079         if (!snd_hdsp_use_is_exclusive(hdsp))
2080                 return -EBUSY;
2081         val = ucontrol->value.enumerated.item[0];
2082         if (val < 0) val = 0;
2083         if (hdsp->io_type == H9632) {
2084             if (val > 9) val = 9;
2085         } else {
2086             if (val > 6) val = 6;
2087         }
2088         spin_lock_irq(&hdsp->lock);
2089         if (val != hdsp_clock_source(hdsp)) {
2090                 change = (hdsp_set_clock_source(hdsp, val) == 0) ? 1 : 0;
2091         } else {
2092                 change = 0;
2093         }
2094         spin_unlock_irq(&hdsp->lock);
2095         return change;
2096 }
2097
2098 static int snd_hdsp_info_clock_source_lock(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2099 {
2100         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2101         uinfo->count = 1;
2102         uinfo->value.integer.min = 0;
2103         uinfo->value.integer.max = 1;
2104         return 0;
2105 }
2106
2107 static int snd_hdsp_get_clock_source_lock(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2108 {
2109         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2110
2111         ucontrol->value.integer.value[0] = hdsp->clock_source_locked;
2112         return 0;
2113 }
2114
2115 static int snd_hdsp_put_clock_source_lock(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2116 {
2117         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2118         int change;
2119
2120         change = (int)ucontrol->value.integer.value[0] != hdsp->clock_source_locked;
2121         if (change)
2122                 hdsp->clock_source_locked = ucontrol->value.integer.value[0];
2123         return change;
2124 }
2125
2126 #define HDSP_DA_GAIN(xname, xindex) \
2127 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2128   .name = xname, \
2129   .index = xindex, \
2130   .info = snd_hdsp_info_da_gain, \
2131   .get = snd_hdsp_get_da_gain, \
2132   .put = snd_hdsp_put_da_gain \
2133 }
2134
2135 static int hdsp_da_gain(hdsp_t *hdsp)
2136 {
2137         switch (hdsp->control_register & HDSP_DAGainMask) {
2138         case HDSP_DAGainHighGain:
2139                 return 0;
2140         case HDSP_DAGainPlus4dBu:
2141                 return 1;
2142         case HDSP_DAGainMinus10dBV:
2143                 return 2;
2144         default:
2145                 return 1;
2146         }
2147 }
2148
2149 static int hdsp_set_da_gain(hdsp_t *hdsp, int mode)
2150 {
2151         hdsp->control_register &= ~HDSP_DAGainMask;
2152         switch (mode) {
2153         case 0:
2154                 hdsp->control_register |= HDSP_DAGainHighGain;
2155                 break;
2156         case 1:
2157                 hdsp->control_register |= HDSP_DAGainPlus4dBu;
2158                 break;
2159         case 2:
2160                 hdsp->control_register |= HDSP_DAGainMinus10dBV;
2161                 break;
2162         default:
2163                 return -1;
2164
2165         }
2166         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2167         return 0;
2168 }
2169
2170 static int snd_hdsp_info_da_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2171 {
2172         static char *texts[] = {"Hi Gain", "+4 dBu", "-10 dbV"};
2173
2174         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2175         uinfo->count = 1;
2176         uinfo->value.enumerated.items = 3;
2177         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2178                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2179         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2180         return 0;
2181 }
2182
2183 static int snd_hdsp_get_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2184 {
2185         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2186
2187         ucontrol->value.enumerated.item[0] = hdsp_da_gain(hdsp);
2188         return 0;
2189 }
2190
2191 static int snd_hdsp_put_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2192 {
2193         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2194         int change;
2195         int val;
2196
2197         if (!snd_hdsp_use_is_exclusive(hdsp))
2198                 return -EBUSY;
2199         val = ucontrol->value.enumerated.item[0];
2200         if (val < 0) val = 0;
2201         if (val > 2) val = 2;
2202         spin_lock_irq(&hdsp->lock);
2203         if (val != hdsp_da_gain(hdsp)) {
2204                 change = (hdsp_set_da_gain(hdsp, val) == 0) ? 1 : 0;
2205         } else {
2206                 change = 0;
2207         }
2208         spin_unlock_irq(&hdsp->lock);
2209         return change;
2210 }
2211
2212 #define HDSP_AD_GAIN(xname, xindex) \
2213 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2214   .name = xname, \
2215   .index = xindex, \
2216   .info = snd_hdsp_info_ad_gain, \
2217   .get = snd_hdsp_get_ad_gain, \
2218   .put = snd_hdsp_put_ad_gain \
2219 }
2220
2221 static int hdsp_ad_gain(hdsp_t *hdsp)
2222 {
2223         switch (hdsp->control_register & HDSP_ADGainMask) {
2224         case HDSP_ADGainMinus10dBV:
2225                 return 0;
2226         case HDSP_ADGainPlus4dBu:
2227                 return 1;
2228         case HDSP_ADGainLowGain:
2229                 return 2;
2230         default:
2231                 return 1;
2232         }
2233 }
2234
2235 static int hdsp_set_ad_gain(hdsp_t *hdsp, int mode)
2236 {
2237         hdsp->control_register &= ~HDSP_ADGainMask;
2238         switch (mode) {
2239         case 0:
2240                 hdsp->control_register |= HDSP_ADGainMinus10dBV;
2241                 break;
2242         case 1:
2243                 hdsp->control_register |= HDSP_ADGainPlus4dBu;
2244                 break;
2245         case 2:
2246                 hdsp->control_register |= HDSP_ADGainLowGain;
2247                 break;
2248         default:
2249                 return -1;
2250
2251         }
2252         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2253         return 0;
2254 }
2255
2256 static int snd_hdsp_info_ad_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2257 {
2258         static char *texts[] = {"-10 dBV", "+4 dBu", "Lo Gain"};
2259
2260         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2261         uinfo->count = 1;
2262         uinfo->value.enumerated.items = 3;
2263         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2264                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2265         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2266         return 0;
2267 }
2268
2269 static int snd_hdsp_get_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2270 {
2271         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2272
2273         ucontrol->value.enumerated.item[0] = hdsp_ad_gain(hdsp);
2274         return 0;
2275 }
2276
2277 static int snd_hdsp_put_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2278 {
2279         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2280         int change;
2281         int val;
2282
2283         if (!snd_hdsp_use_is_exclusive(hdsp))
2284                 return -EBUSY;
2285         val = ucontrol->value.enumerated.item[0];
2286         if (val < 0) val = 0;
2287         if (val > 2) val = 2;
2288         spin_lock_irq(&hdsp->lock);
2289         if (val != hdsp_ad_gain(hdsp)) {
2290                 change = (hdsp_set_ad_gain(hdsp, val) == 0) ? 1 : 0;
2291         } else {
2292                 change = 0;
2293         }
2294         spin_unlock_irq(&hdsp->lock);
2295         return change;
2296 }
2297
2298 #define HDSP_PHONE_GAIN(xname, xindex) \
2299 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2300   .name = xname, \
2301   .index = xindex, \
2302   .info = snd_hdsp_info_phone_gain, \
2303   .get = snd_hdsp_get_phone_gain, \
2304   .put = snd_hdsp_put_phone_gain \
2305 }
2306
2307 static int hdsp_phone_gain(hdsp_t *hdsp)
2308 {
2309         switch (hdsp->control_register & HDSP_PhoneGainMask) {
2310         case HDSP_PhoneGain0dB:
2311                 return 0;
2312         case HDSP_PhoneGainMinus6dB:
2313                 return 1;
2314         case HDSP_PhoneGainMinus12dB:
2315                 return 2;
2316         default:
2317                 return 0;
2318         }
2319 }
2320
2321 static int hdsp_set_phone_gain(hdsp_t *hdsp, int mode)
2322 {
2323         hdsp->control_register &= ~HDSP_PhoneGainMask;
2324         switch (mode) {
2325         case 0:
2326                 hdsp->control_register |= HDSP_PhoneGain0dB;
2327                 break;
2328         case 1:
2329                 hdsp->control_register |= HDSP_PhoneGainMinus6dB;
2330                 break;
2331         case 2:
2332                 hdsp->control_register |= HDSP_PhoneGainMinus12dB;
2333                 break;
2334         default:
2335                 return -1;
2336
2337         }
2338         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2339         return 0;
2340 }
2341
2342 static int snd_hdsp_info_phone_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2343 {
2344         static char *texts[] = {"0 dB", "-6 dB", "-12 dB"};
2345
2346         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2347         uinfo->count = 1;
2348         uinfo->value.enumerated.items = 3;
2349         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2350                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2351         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2352         return 0;
2353 }
2354
2355 static int snd_hdsp_get_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2356 {
2357         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2358
2359         ucontrol->value.enumerated.item[0] = hdsp_phone_gain(hdsp);
2360         return 0;
2361 }
2362
2363 static int snd_hdsp_put_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2364 {
2365         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2366         int change;
2367         int val;
2368
2369         if (!snd_hdsp_use_is_exclusive(hdsp))
2370                 return -EBUSY;
2371         val = ucontrol->value.enumerated.item[0];
2372         if (val < 0) val = 0;
2373         if (val > 2) val = 2;
2374         spin_lock_irq(&hdsp->lock);
2375         if (val != hdsp_phone_gain(hdsp)) {
2376                 change = (hdsp_set_phone_gain(hdsp, val) == 0) ? 1 : 0;
2377         } else {
2378                 change = 0;
2379         }
2380         spin_unlock_irq(&hdsp->lock);
2381         return change;
2382 }
2383
2384 #define HDSP_XLR_BREAKOUT_CABLE(xname, xindex) \
2385 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2386   .name = xname, \
2387   .index = xindex, \
2388   .info = snd_hdsp_info_xlr_breakout_cable, \
2389   .get = snd_hdsp_get_xlr_breakout_cable, \
2390   .put = snd_hdsp_put_xlr_breakout_cable \
2391 }
2392
2393 static int hdsp_xlr_breakout_cable(hdsp_t *hdsp)
2394 {
2395         if (hdsp->control_register & HDSP_XLRBreakoutCable) {
2396                 return 1;
2397         }
2398         return 0;
2399 }
2400
2401 static int hdsp_set_xlr_breakout_cable(hdsp_t *hdsp, int mode)
2402 {
2403         if (mode) {
2404                 hdsp->control_register |= HDSP_XLRBreakoutCable;
2405         } else {
2406                 hdsp->control_register &= ~HDSP_XLRBreakoutCable;
2407         }
2408         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2409         return 0;
2410 }
2411
2412 static int snd_hdsp_info_xlr_breakout_cable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2413 {
2414         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2415         uinfo->count = 1;
2416         uinfo->value.integer.min = 0;
2417         uinfo->value.integer.max = 1;
2418         return 0;
2419 }
2420
2421 static int snd_hdsp_get_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2422 {
2423         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2424
2425         ucontrol->value.enumerated.item[0] = hdsp_xlr_breakout_cable(hdsp);
2426         return 0;
2427 }
2428
2429 static int snd_hdsp_put_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2430 {
2431         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2432         int change;
2433         int val;
2434
2435         if (!snd_hdsp_use_is_exclusive(hdsp))
2436                 return -EBUSY;
2437         val = ucontrol->value.integer.value[0] & 1;
2438         spin_lock_irq(&hdsp->lock);
2439         change = (int)val != hdsp_xlr_breakout_cable(hdsp);
2440         hdsp_set_xlr_breakout_cable(hdsp, val);
2441         spin_unlock_irq(&hdsp->lock);
2442         return change;
2443 }
2444
2445 /* (De)activates old RME Analog Extension Board
2446    These are connected to the internal ADAT connector
2447    Switching this on desactivates external ADAT
2448 */
2449 #define HDSP_AEB(xname, xindex) \
2450 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2451   .name = xname, \
2452   .index = xindex, \
2453   .info = snd_hdsp_info_aeb, \
2454   .get = snd_hdsp_get_aeb, \
2455   .put = snd_hdsp_put_aeb \
2456 }
2457
2458 static int hdsp_aeb(hdsp_t *hdsp)
2459 {
2460         if (hdsp->control_register & HDSP_AnalogExtensionBoard) {
2461                 return 1;
2462         }
2463         return 0;
2464 }
2465
2466 static int hdsp_set_aeb(hdsp_t *hdsp, int mode)
2467 {
2468         if (mode) {
2469                 hdsp->control_register |= HDSP_AnalogExtensionBoard;
2470         } else {
2471                 hdsp->control_register &= ~HDSP_AnalogExtensionBoard;
2472         }
2473         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2474         return 0;
2475 }
2476
2477 static int snd_hdsp_info_aeb(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2478 {
2479         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2480         uinfo->count = 1;
2481         uinfo->value.integer.min = 0;
2482         uinfo->value.integer.max = 1;
2483         return 0;
2484 }
2485
2486 static int snd_hdsp_get_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2487 {
2488         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2489
2490         ucontrol->value.enumerated.item[0] = hdsp_aeb(hdsp);
2491         return 0;
2492 }
2493
2494 static int snd_hdsp_put_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2495 {
2496         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2497         int change;
2498         int val;
2499
2500         if (!snd_hdsp_use_is_exclusive(hdsp))
2501                 return -EBUSY;
2502         val = ucontrol->value.integer.value[0] & 1;
2503         spin_lock_irq(&hdsp->lock);
2504         change = (int)val != hdsp_aeb(hdsp);
2505         hdsp_set_aeb(hdsp, val);
2506         spin_unlock_irq(&hdsp->lock);
2507         return change;
2508 }
2509
2510 #define HDSP_PREF_SYNC_REF(xname, xindex) \
2511 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2512   .name = xname, \
2513   .index = xindex, \
2514   .info = snd_hdsp_info_pref_sync_ref, \
2515   .get = snd_hdsp_get_pref_sync_ref, \
2516   .put = snd_hdsp_put_pref_sync_ref \
2517 }
2518
2519 static int hdsp_pref_sync_ref(hdsp_t *hdsp)
2520 {
2521         /* Notice that this looks at the requested sync source,
2522            not the one actually in use.
2523         */
2524
2525         switch (hdsp->control_register & HDSP_SyncRefMask) {
2526         case HDSP_SyncRef_ADAT1:
2527                 return HDSP_SYNC_FROM_ADAT1;
2528         case HDSP_SyncRef_ADAT2:
2529                 return HDSP_SYNC_FROM_ADAT2;
2530         case HDSP_SyncRef_ADAT3:
2531                 return HDSP_SYNC_FROM_ADAT3;
2532         case HDSP_SyncRef_SPDIF:
2533                 return HDSP_SYNC_FROM_SPDIF;
2534         case HDSP_SyncRef_WORD:
2535                 return HDSP_SYNC_FROM_WORD;
2536         case HDSP_SyncRef_ADAT_SYNC:
2537                 return HDSP_SYNC_FROM_ADAT_SYNC;
2538         default:
2539                 return HDSP_SYNC_FROM_WORD;
2540         }
2541         return 0;
2542 }
2543
2544 static int hdsp_set_pref_sync_ref(hdsp_t *hdsp, int pref)
2545 {
2546         hdsp->control_register &= ~HDSP_SyncRefMask;
2547         switch (pref) {
2548         case HDSP_SYNC_FROM_ADAT1:
2549                 hdsp->control_register &= ~HDSP_SyncRefMask; /* clear SyncRef bits */
2550                 break;
2551         case HDSP_SYNC_FROM_ADAT2:
2552                 hdsp->control_register |= HDSP_SyncRef_ADAT2;
2553                 break;
2554         case HDSP_SYNC_FROM_ADAT3:
2555                 hdsp->control_register |= HDSP_SyncRef_ADAT3;
2556                 break;
2557         case HDSP_SYNC_FROM_SPDIF:
2558                 hdsp->control_register |= HDSP_SyncRef_SPDIF;
2559                 break;
2560         case HDSP_SYNC_FROM_WORD:
2561                 hdsp->control_register |= HDSP_SyncRef_WORD;
2562                 break;
2563         case HDSP_SYNC_FROM_ADAT_SYNC:
2564                 hdsp->control_register |= HDSP_SyncRef_ADAT_SYNC;
2565                 break;
2566         default:
2567                 return -1;
2568         }
2569         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2570         return 0;
2571 }
2572
2573 static int snd_hdsp_info_pref_sync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2574 {
2575         static char *texts[] = {"Word", "IEC958", "ADAT1", "ADAT Sync", "ADAT2", "ADAT3" };
2576         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2577
2578         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2579         uinfo->count = 1;
2580
2581         switch (hdsp->io_type) {
2582         case Digiface:
2583         case H9652:
2584                 uinfo->value.enumerated.items = 6;
2585                 break;
2586         case Multiface:
2587                 uinfo->value.enumerated.items = 4;
2588                 break;
2589         case H9632:
2590                 uinfo->value.enumerated.items = 3;
2591                 break;
2592         default:
2593                 uinfo->value.enumerated.items = 0;
2594                 break;
2595         }
2596
2597         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2598                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2599         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2600         return 0;
2601 }
2602
2603 static int snd_hdsp_get_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2604 {
2605         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2606
2607         ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
2608         return 0;
2609 }
2610
2611 static int snd_hdsp_put_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2612 {
2613         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2614         int change, max;
2615         unsigned int val;
2616
2617         if (!snd_hdsp_use_is_exclusive(hdsp))
2618                 return -EBUSY;
2619
2620         switch (hdsp->io_type) {
2621         case Digiface:
2622         case H9652:
2623                 max = 6;
2624                 break;
2625         case Multiface:
2626                 max = 4;
2627                 break;
2628         case H9632:
2629                 max = 3;
2630                 break;
2631         default:
2632                 return -EIO;
2633         }
2634
2635         val = ucontrol->value.enumerated.item[0] % max;
2636         spin_lock_irq(&hdsp->lock);
2637         change = (int)val != hdsp_pref_sync_ref(hdsp);
2638         hdsp_set_pref_sync_ref(hdsp, val);
2639         spin_unlock_irq(&hdsp->lock);
2640         return change;
2641 }
2642
2643 #define HDSP_AUTOSYNC_REF(xname, xindex) \
2644 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2645   .name = xname, \
2646   .index = xindex, \
2647   .access = SNDRV_CTL_ELEM_ACCESS_READ, \
2648   .info = snd_hdsp_info_autosync_ref, \
2649   .get = snd_hdsp_get_autosync_ref, \
2650 }
2651
2652 static int hdsp_autosync_ref(hdsp_t *hdsp)
2653 {
2654         /* This looks at the autosync selected sync reference */
2655         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
2656
2657         switch (status2 & HDSP_SelSyncRefMask) {
2658         case HDSP_SelSyncRef_WORD:
2659                 return HDSP_AUTOSYNC_FROM_WORD;
2660         case HDSP_SelSyncRef_ADAT_SYNC:
2661                 return HDSP_AUTOSYNC_FROM_ADAT_SYNC;
2662         case HDSP_SelSyncRef_SPDIF:
2663                 return HDSP_AUTOSYNC_FROM_SPDIF;
2664         case HDSP_SelSyncRefMask:
2665                 return HDSP_AUTOSYNC_FROM_NONE;
2666         case HDSP_SelSyncRef_ADAT1:
2667                 return HDSP_AUTOSYNC_FROM_ADAT1;
2668         case HDSP_SelSyncRef_ADAT2:
2669                 return HDSP_AUTOSYNC_FROM_ADAT2;
2670         case HDSP_SelSyncRef_ADAT3:
2671                 return HDSP_AUTOSYNC_FROM_ADAT3;
2672         default:
2673                 return HDSP_AUTOSYNC_FROM_WORD;
2674         }
2675         return 0;
2676 }
2677
2678 static int snd_hdsp_info_autosync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2679 {
2680         static char *texts[] = {"Word", "ADAT Sync", "IEC958", "None", "ADAT1", "ADAT2", "ADAT3" };
2681
2682         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2683         uinfo->count = 1;
2684         uinfo->value.enumerated.items = 7;
2685         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2686                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2687         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2688         return 0;
2689 }
2690
2691 static int snd_hdsp_get_autosync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2692 {
2693         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2694
2695         ucontrol->value.enumerated.item[0] = hdsp_autosync_ref(hdsp);
2696         return 0;
2697 }
2698
2699 #define HDSP_LINE_OUT(xname, xindex) \
2700 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2701   .name = xname, \
2702   .index = xindex, \
2703   .info = snd_hdsp_info_line_out, \
2704   .get = snd_hdsp_get_line_out, \
2705   .put = snd_hdsp_put_line_out \
2706 }
2707
2708 static int hdsp_line_out(hdsp_t *hdsp)
2709 {
2710         return (hdsp->control_register & HDSP_LineOut) ? 1 : 0;
2711 }
2712
2713 static int hdsp_set_line_output(hdsp_t *hdsp, int out)
2714 {
2715         if (out) {
2716                 hdsp->control_register |= HDSP_LineOut;
2717         } else {
2718                 hdsp->control_register &= ~HDSP_LineOut;
2719         }
2720         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
2721         return 0;
2722 }
2723
2724 static int snd_hdsp_info_line_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2725 {
2726         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2727         uinfo->count = 1;
2728         uinfo->value.integer.min = 0;
2729         uinfo->value.integer.max = 1;
2730         return 0;
2731 }
2732
2733 static int snd_hdsp_get_line_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2734 {
2735         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2736
2737         spin_lock_irq(&hdsp->lock);
2738         ucontrol->value.integer.value[0] = hdsp_line_out(hdsp);
2739         spin_unlock_irq(&hdsp->lock);
2740         return 0;
2741 }
2742
2743 static int snd_hdsp_put_line_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2744 {
2745         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2746         int change;
2747         unsigned int val;
2748
2749         if (!snd_hdsp_use_is_exclusive(hdsp))
2750                 return -EBUSY;
2751         val = ucontrol->value.integer.value[0] & 1;
2752         spin_lock_irq(&hdsp->lock);
2753         change = (int)val != hdsp_line_out(hdsp);
2754         hdsp_set_line_output(hdsp, val);
2755         spin_unlock_irq(&hdsp->lock);
2756         return change;
2757 }
2758
2759 #define HDSP_PRECISE_POINTER(xname, xindex) \
2760 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2761   .name = xname, \
2762   .index = xindex, \
2763   .info = snd_hdsp_info_precise_pointer, \
2764   .get = snd_hdsp_get_precise_pointer, \
2765   .put = snd_hdsp_put_precise_pointer \
2766 }
2767
2768 static int hdsp_set_precise_pointer(hdsp_t *hdsp, int precise)
2769 {
2770         if (precise) {
2771                 hdsp->precise_ptr = 1;
2772         } else {
2773                 hdsp->precise_ptr = 0;
2774         }
2775         return 0;
2776 }
2777
2778 static int snd_hdsp_info_precise_pointer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2779 {
2780         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2781         uinfo->count = 1;
2782         uinfo->value.integer.min = 0;
2783         uinfo->value.integer.max = 1;
2784         return 0;
2785 }
2786
2787 static int snd_hdsp_get_precise_pointer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2788 {
2789         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2790
2791         spin_lock_irq(&hdsp->lock);
2792         ucontrol->value.integer.value[0] = hdsp->precise_ptr;
2793         spin_unlock_irq(&hdsp->lock);
2794         return 0;
2795 }
2796
2797 static int snd_hdsp_put_precise_pointer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2798 {
2799         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2800         int change;
2801         unsigned int val;
2802
2803         if (!snd_hdsp_use_is_exclusive(hdsp))
2804                 return -EBUSY;
2805         val = ucontrol->value.integer.value[0] & 1;
2806         spin_lock_irq(&hdsp->lock);
2807         change = (int)val != hdsp->precise_ptr;
2808         hdsp_set_precise_pointer(hdsp, val);
2809         spin_unlock_irq(&hdsp->lock);
2810         return change;
2811 }
2812
2813 #define HDSP_USE_MIDI_TASKLET(xname, xindex) \
2814 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2815   .name = xname, \
2816   .index = xindex, \
2817   .info = snd_hdsp_info_use_midi_tasklet, \
2818   .get = snd_hdsp_get_use_midi_tasklet, \
2819   .put = snd_hdsp_put_use_midi_tasklet \
2820 }
2821
2822 static int hdsp_set_use_midi_tasklet(hdsp_t *hdsp, int use_tasklet)
2823 {
2824         if (use_tasklet) {
2825                 hdsp->use_midi_tasklet = 1;
2826         } else {
2827                 hdsp->use_midi_tasklet = 0;
2828         }
2829         return 0;
2830 }
2831
2832 static int snd_hdsp_info_use_midi_tasklet(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2833 {
2834         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2835         uinfo->count = 1;
2836         uinfo->value.integer.min = 0;
2837         uinfo->value.integer.max = 1;
2838         return 0;
2839 }
2840
2841 static int snd_hdsp_get_use_midi_tasklet(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2842 {
2843         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2844
2845         spin_lock_irq(&hdsp->lock);
2846         ucontrol->value.integer.value[0] = hdsp->use_midi_tasklet;
2847         spin_unlock_irq(&hdsp->lock);
2848         return 0;
2849 }
2850
2851 static int snd_hdsp_put_use_midi_tasklet(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2852 {
2853         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2854         int change;
2855         unsigned int val;
2856
2857         if (!snd_hdsp_use_is_exclusive(hdsp))
2858                 return -EBUSY;
2859         val = ucontrol->value.integer.value[0] & 1;
2860         spin_lock_irq(&hdsp->lock);
2861         change = (int)val != hdsp->use_midi_tasklet;
2862         hdsp_set_use_midi_tasklet(hdsp, val);
2863         spin_unlock_irq(&hdsp->lock);
2864         return change;
2865 }
2866
2867 #define HDSP_MIXER(xname, xindex) \
2868 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2869   .name = xname, \
2870   .index = xindex, \
2871   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2872                  SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2873   .info = snd_hdsp_info_mixer, \
2874   .get = snd_hdsp_get_mixer, \
2875   .put = snd_hdsp_put_mixer \
2876 }
2877
2878 static int snd_hdsp_info_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2879 {
2880         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2881         uinfo->count = 3;
2882         uinfo->value.integer.min = 0;
2883         uinfo->value.integer.max = 65536;
2884         uinfo->value.integer.step = 1;
2885         return 0;
2886 }
2887
2888 static int snd_hdsp_get_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2889 {
2890         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2891         int source;
2892         int destination;
2893         int addr;
2894
2895         source = ucontrol->value.integer.value[0];
2896         destination = ucontrol->value.integer.value[1];
2897
2898         if (source >= hdsp->max_channels) {
2899                 addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels,destination);
2900         } else {
2901                 addr = hdsp_input_to_output_key(hdsp,source, destination);
2902         }
2903
2904         spin_lock_irq(&hdsp->lock);
2905         ucontrol->value.integer.value[2] = hdsp_read_gain (hdsp, addr);
2906         spin_unlock_irq(&hdsp->lock);
2907         return 0;
2908 }
2909
2910 static int snd_hdsp_put_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2911 {
2912         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2913         int change;
2914         int source;
2915         int destination;
2916         int gain;
2917         int addr;
2918
2919         if (!snd_hdsp_use_is_exclusive(hdsp))
2920                 return -EBUSY;
2921
2922         source = ucontrol->value.integer.value[0];
2923         destination = ucontrol->value.integer.value[1];
2924
2925         if (source >= hdsp->max_channels) {
2926                 addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels, destination);
2927         } else {
2928                 addr = hdsp_input_to_output_key(hdsp,source, destination);
2929         }
2930
2931         gain = ucontrol->value.integer.value[2];
2932
2933         spin_lock_irq(&hdsp->lock);
2934         change = gain != hdsp_read_gain(hdsp, addr);
2935         if (change)
2936                 hdsp_write_gain(hdsp, addr, gain);
2937         spin_unlock_irq(&hdsp->lock);
2938         return change;
2939 }
2940
2941 #define HDSP_WC_SYNC_CHECK(xname, xindex) \
2942 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2943   .name = xname, \
2944   .index = xindex, \
2945   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2946   .info = snd_hdsp_info_sync_check, \
2947   .get = snd_hdsp_get_wc_sync_check \
2948 }
2949
2950 static int snd_hdsp_info_sync_check(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
2951 {
2952         static char *texts[] = {"No Lock", "Lock", "Sync" };
2953         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2954         uinfo->count = 1;
2955         uinfo->value.enumerated.items = 3;
2956         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2957                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2958         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2959         return 0;
2960 }
2961
2962 static int hdsp_wc_sync_check(hdsp_t *hdsp)
2963 {
2964         int status2 = hdsp_read(hdsp, HDSP_status2Register);
2965         if (status2 & HDSP_wc_lock) {
2966                 if (status2 & HDSP_wc_sync) {
2967                         return 2;
2968                 } else {
2969                          return 1;
2970                 }
2971         } else {
2972                 return 0;
2973         }
2974         return 0;
2975 }
2976
2977 static int snd_hdsp_get_wc_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
2978 {
2979         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
2980
2981         ucontrol->value.enumerated.item[0] = hdsp_wc_sync_check(hdsp);
2982         return 0;
2983 }
2984
2985 #define HDSP_SPDIF_SYNC_CHECK(xname, xindex) \
2986 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
2987   .name = xname, \
2988   .index = xindex, \
2989   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2990   .info = snd_hdsp_info_sync_check, \
2991   .get = snd_hdsp_get_spdif_sync_check \
2992 }
2993
2994 static int hdsp_spdif_sync_check(hdsp_t *hdsp)
2995 {
2996         int status = hdsp_read(hdsp, HDSP_statusRegister);
2997         if (status & HDSP_SPDIFErrorFlag) {
2998                 return 0;
2999         } else {
3000                 if (status & HDSP_SPDIFSync) {
3001                         return 2;
3002                 } else {
3003                         return 1;
3004                 }
3005         }
3006         return 0;
3007 }
3008
3009 static int snd_hdsp_get_spdif_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
3010 {
3011         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
3012
3013         ucontrol->value.enumerated.item[0] = hdsp_spdif_sync_check(hdsp);
3014         return 0;
3015 }
3016
3017 #define HDSP_ADATSYNC_SYNC_CHECK(xname, xindex) \
3018 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
3019   .name = xname, \
3020   .index = xindex, \
3021   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3022   .info = snd_hdsp_info_sync_check, \
3023   .get = snd_hdsp_get_adatsync_sync_check \
3024 }
3025
3026 static int hdsp_adatsync_sync_check(hdsp_t *hdsp)
3027 {
3028         int status = hdsp_read(hdsp, HDSP_statusRegister);
3029         if (status & HDSP_TimecodeLock) {
3030                 if (status & HDSP_TimecodeSync) {
3031                         return 2;
3032                 } else {
3033                         return 1;
3034                 }
3035         } else {
3036                 return 0;
3037         }
3038 }
3039
3040 static int snd_hdsp_get_adatsync_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
3041 {
3042         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
3043
3044         ucontrol->value.enumerated.item[0] = hdsp_adatsync_sync_check(hdsp);
3045         return 0;
3046 }
3047
3048 #define HDSP_ADAT_SYNC_CHECK \
3049 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
3050   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3051   .info = snd_hdsp_info_sync_check, \
3052   .get = snd_hdsp_get_adat_sync_check \
3053 }
3054
3055 static int hdsp_adat_sync_check(hdsp_t *hdsp, int idx)
3056 {
3057         int status = hdsp_read(hdsp, HDSP_statusRegister);
3058
3059         if (status & (HDSP_Lock0>>idx)) {
3060                 if (status & (HDSP_Sync0>>idx)) {
3061                         return 2;
3062                 } else {
3063                         return 1;
3064                 }
3065         } else {
3066                 return 0;
3067         }
3068 }
3069
3070 static int snd_hdsp_get_adat_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
3071 {
3072         int offset;
3073         hdsp_t *hdsp = snd_kcontrol_chip(kcontrol);
3074
3075         offset = ucontrol->id.index - 1;
3076         snd_assert(offset >= 0);
3077
3078         switch (hdsp->io_type) {
3079         case Digiface:
3080         case H9652:
3081                 if (offset >= 3)
3082                         return -EINVAL;
3083                 break;
3084         case Multiface:
3085         case H9632:
3086                 if (offset >= 1)
3087                         return -EINVAL;
3088                 break;
3089         default:
3090                 return -EIO;
3091         }
3092
3093         ucontrol->value.enumerated.item[0] = hdsp_adat_sync_check(hdsp, offset);
3094         return 0;
3095 }
3096
3097 static snd_kcontrol_new_t snd_hdsp_9632_controls[] = {
3098 HDSP_DA_GAIN("DA Gain", 0),
3099 HDSP_AD_GAIN("AD Gain", 0),
3100 HDSP_PHONE_GAIN("Phones Gain", 0),
3101 HDSP_XLR_BREAKOUT_CABLE("XLR Breakout Cable", 0)
3102 };
3103
3104 static snd_kcontrol_new_t snd_hdsp_controls[] = {
3105 {
3106         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3107         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
3108         .info =         snd_hdsp_control_spdif_info,
3109         .get =          snd_hdsp_control_spdif_get,
3110         .put =          snd_hdsp_control_spdif_put,
3111 },
3112 {
3113         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
3114         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
3115         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
3116         .info =         snd_hdsp_control_spdif_stream_info,
3117         .get =          snd_hdsp_control_spdif_stream_get,
3118         .put =          snd_hdsp_control_spdif_stream_put,
3119 },
3120 {
3121         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
3122         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
3123         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
3124         .info =         snd_hdsp_control_spdif_mask_info,
3125         .get =          snd_hdsp_control_spdif_mask_get,
3126         .private_value = IEC958_AES0_NONAUDIO |
3127                          IEC958_AES0_PROFESSIONAL |
3128                          IEC958_AES0_CON_EMPHASIS,
3129 },
3130 {
3131         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
3132         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
3133         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
3134         .info =         snd_hdsp_control_spdif_mask_info,
3135         .get =          snd_hdsp_control_spdif_mask_get,
3136         .private_value = IEC958_AES0_NONAUDIO |
3137                          IEC958_AES0_PROFESSIONAL |
3138                          IEC958_AES0_PRO_EMPHASIS,
3139 },
3140 HDSP_MIXER("Mixer", 0),
3141 HDSP_SPDIF_IN("IEC958 Input Connector", 0),
3142 HDSP_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
3143 HDSP_SPDIF_PROFESSIONAL("IEC958 Professional Bit", 0),
3144 HDSP_SPDIF_EMPHASIS("IEC958 Emphasis Bit", 0),
3145 HDSP_SPDIF_NON_AUDIO("IEC958 Non-audio Bit", 0),
3146 /* 'Sample Clock Source' complies with the alsa control naming scheme */
3147 HDSP_CLOCK_SOURCE("Sample Clock Source", 0),
3148 {
3149         /* FIXME: should be PCM or MIXER? */
3150         /* .iface = SNDRV_CTL_ELEM_IFACE_PCM, */
3151         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3152         .name = "Sample Clock Source Locking",
3153         .info = snd_hdsp_info_clock_source_lock,
3154         .get = snd_hdsp_get_clock_source_lock,
3155         .put = snd_hdsp_put_clock_source_lock,
3156 },
3157 HDSP_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
3158 HDSP_PREF_SYNC_REF("Preferred Sync Reference", 0),
3159 HDSP_AUTOSYNC_REF("AutoSync Reference", 0),
3160 HDSP_SPDIF_SAMPLE_RATE("SPDIF Sample Rate", 0),
3161 HDSP_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
3162 /* 'External Rate' complies with the alsa control naming scheme */
3163 HDSP_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
3164 HDSP_WC_SYNC_CHECK("Word Clock Lock Status", 0),
3165 HDSP_SPDIF_SYNC_CHECK("SPDIF Lock Status", 0),
3166 HDSP_ADATSYNC_SYNC_CHECK("ADAT Sync Lock Status", 0),
3167 HDSP_LINE_OUT("Line Out", 0),
3168 HDSP_PRECISE_POINTER("Precise Pointer", 0),
3169 HDSP_USE_MIDI_TASKLET("Use Midi Tasklet", 0),
3170 };
3171
3172 static snd_kcontrol_new_t snd_hdsp_96xx_aeb = HDSP_AEB("Analog Extension Board", 0);
3173 static snd_kcontrol_new_t snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK;
3174
3175 static int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp)
3176 {
3177         unsigned int idx;
3178         int err;
3179         snd_kcontrol_t *kctl;
3180
3181         for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_controls); idx++) {
3182                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_controls[idx], hdsp))) < 0) {
3183                         return err;
3184                 }
3185                 if (idx == 1)   /* IEC958 (S/PDIF) Stream */
3186                         hdsp->spdif_ctl = kctl;
3187         }
3188
3189         /* ADAT SyncCheck status */
3190         snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
3191         snd_hdsp_adat_sync_check.index = 1;
3192         if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
3193                 return err;
3194         }
3195         if (hdsp->io_type == Digiface || hdsp->io_type == H9652) {
3196                 for (idx = 1; idx < 3; ++idx) {
3197                         snd_hdsp_adat_sync_check.index = idx+1;
3198                         if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
3199                                 return err;
3200                         }
3201                 }
3202         }
3203
3204         /* DA, AD and Phone gain and XLR breakout cable controls for H9632 cards */
3205         if (hdsp->io_type == H9632) {
3206                 for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_9632_controls); idx++) {
3207                         if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_9632_controls[idx], hdsp))) < 0) {
3208                                 return err;
3209                         }
3210                 }
3211         }
3212
3213         /* AEB control for H96xx card */
3214         if (hdsp->io_type == H9632 || hdsp->io_type == H9652) {
3215                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_96xx_aeb, hdsp))) < 0) {
3216                                 return err;
3217                 }
3218         }
3219
3220         return 0;
3221 }
3222
3223 /*------------------------------------------------------------
3224    /proc interface
3225  ------------------------------------------------------------*/
3226
3227 static void
3228 snd_hdsp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
3229 {
3230         hdsp_t *hdsp = (hdsp_t *) entry->private_data;
3231         unsigned int status;
3232         unsigned int status2;
3233         char *pref_sync_ref;
3234         char *autosync_ref;
3235         char *system_clock_mode;
3236         char *clock_source;
3237         int x;
3238
3239         if (hdsp_check_for_iobox (hdsp)) {
3240                 snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
3241                 return;
3242         }
3243
3244         if (hdsp_check_for_firmware(hdsp)) {
3245                 if (hdsp->state & HDSP_FirmwareCached) {
3246                         if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
3247                                 snd_iprintf(buffer, "Firmware loading from cache failed, please upload manually.\n");
3248                                 return;
3249                         }
3250                 } else {
3251                         snd_iprintf(buffer, "No firmware loaded nor cached, please upload firmware.\n");
3252                         return;
3253                 }
3254         }
3255
3256         status = hdsp_read(hdsp, HDSP_statusRegister);
3257         status2 = hdsp_read(hdsp, HDSP_status2Register);
3258
3259         snd_iprintf(buffer, "%s (Card #%d)\n", hdsp->card_name, hdsp->card->number + 1);
3260         snd_iprintf(buffer, "Buffers: capture %p playback %p\n",
3261                     hdsp->capture_buffer, hdsp->playback_buffer);
3262         snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
3263                     hdsp->irq, hdsp->port, (unsigned long)hdsp->iobase);
3264         snd_iprintf(buffer, "Control register: 0x%x\n", hdsp->control_register);
3265         snd_iprintf(buffer, "Control2 register: 0x%x\n", hdsp->control2_register);
3266         snd_iprintf(buffer, "Status register: 0x%x\n", status);
3267         snd_iprintf(buffer, "Status2 register: 0x%x\n", status2);
3268         snd_iprintf(buffer, "FIFO status: %d\n", hdsp_read(hdsp, HDSP_fifoStatus) & 0xff);
3269         snd_iprintf(buffer, "MIDI1 Output status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusOut0));
3270         snd_iprintf(buffer, "MIDI1 Input status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusIn0));
3271         snd_iprintf(buffer, "MIDI2 Output status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusOut1));
3272         snd_iprintf(buffer, "MIDI2 Input status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusIn1));
3273         snd_iprintf(buffer, "Use Midi Tasklet: %s\n", hdsp->use_midi_tasklet ? "on" : "off");
3274
3275         snd_iprintf(buffer, "\n");
3276
3277         x = 1 << (6 + hdsp_decode_latency(hdsp->control_register & HDSP_LatencyMask));
3278
3279         snd_iprintf(buffer, "Buffer Size (Latency): %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
3280         snd_iprintf(buffer, "Hardware pointer (frames): %ld\n", hdsp_hw_pointer(hdsp));
3281         snd_iprintf(buffer, "Precise pointer: %s\n", hdsp->precise_ptr ? "on" : "off");
3282         snd_iprintf(buffer, "Line out: %s\n", (hdsp->control_register & HDSP_LineOut) ? "on" : "off");
3283
3284         snd_iprintf(buffer, "Firmware version: %d\n", (status2&HDSP_version0)|(status2&HDSP_version1)<<1|(status2&HDSP_version2)<<2);
3285
3286         snd_iprintf(buffer, "\n");
3287
3288
3289         switch (hdsp_clock_source(hdsp)) {
3290         case HDSP_CLOCK_SOURCE_AUTOSYNC:
3291                 clock_source = "AutoSync";
3292                 break;
3293         case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
3294                 clock_source = "Internal 32 kHz";
3295                 break;
3296         case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
3297                 clock_source = "Internal 44.1 kHz";
3298                 break;
3299         case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
3300                 clock_source = "Internal 48 kHz";
3301                 break;
3302         case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
3303                 clock_source = "Internal 64 kHz";
3304                 break;
3305         case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
3306                 clock_source = "Internal 88.2 kHz";
3307                 break;
3308         case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
3309                 clock_source = "Internal 96 kHz";
3310                 break;
3311         case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
3312                 clock_source = "Internal 128 kHz";
3313                 break;
3314         case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
3315                 clock_source = "Internal 176.4 kHz";
3316                 break;
3317                 case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
3318                 clock_source = "Internal 192 kHz";
3319                 break;
3320         default:
3321                 clock_source = "Error";
3322         }
3323         snd_iprintf (buffer, "Sample Clock Source: %s\n", clock_source);
3324
3325         if (hdsp_system_clock_mode(hdsp)) {
3326                 system_clock_mode = "Slave";
3327         } else {
3328                 system_clock_mode = "Master";
3329         }
3330
3331         switch (hdsp_pref_sync_ref (hdsp)) {
3332         case HDSP_SYNC_FROM_WORD:
3333                 pref_sync_ref = "Word Clock";
3334                 break;
3335         case HDSP_SYNC_FROM_ADAT_SYNC:
3336                 pref_sync_ref = "ADAT Sync";
3337                 break;
3338         case HDSP_SYNC_FROM_SPDIF:
3339                 pref_sync_ref = "SPDIF";
3340                 break;
3341         case HDSP_SYNC_FROM_ADAT1:
3342                 pref_sync_ref = "ADAT1";
3343                 break;
3344         case HDSP_SYNC_FROM_ADAT2:
3345                 pref_sync_ref = "ADAT2";
3346                 break;
3347         case HDSP_SYNC_FROM_ADAT3:
3348                 pref_sync_ref = "ADAT3";
3349                 break;
3350         default:
3351                 pref_sync_ref = "Word Clock";
3352                 break;
3353         }
3354         snd_iprintf (buffer, "Preferred Sync Reference: %s\n", pref_sync_ref);
3355
3356         switch (hdsp_autosync_ref (hdsp)) {
3357         case HDSP_AUTOSYNC_FROM_WORD:
3358                 autosync_ref = "Word Clock";
3359                 break;
3360         case HDSP_AUTOSYNC_FROM_ADAT_SYNC:
3361                 autosync_ref = "ADAT Sync";
3362                 break;
3363         case HDSP_AUTOSYNC_FROM_SPDIF:
3364                 autosync_ref = "SPDIF";
3365                 break;
3366         case HDSP_AUTOSYNC_FROM_NONE:
3367                 autosync_ref = "None";
3368                 break;
3369         case HDSP_AUTOSYNC_FROM_ADAT1:
3370                 autosync_ref = "ADAT1";
3371                 break;
3372         case HDSP_AUTOSYNC_FROM_ADAT2:
3373                 autosync_ref = "ADAT2";
3374                 break;
3375         case HDSP_AUTOSYNC_FROM_ADAT3:
3376                 autosync_ref = "ADAT3";
3377                 break;
3378         default:
3379                 autosync_ref = "---";
3380                 break;
3381         }
3382         snd_iprintf (buffer, "AutoSync Reference: %s\n", autosync_ref);
3383
3384         snd_iprintf (buffer, "AutoSync Frequency: %d\n", hdsp_external_sample_rate(hdsp));
3385
3386         snd_iprintf (buffer, "System Clock Mode: %s\n", system_clock_mode);
3387
3388         snd_iprintf (buffer, "System Clock Frequency: %d\n", hdsp->system_sample_rate);
3389         snd_iprintf (buffer, "System Clock Locked: %s\n", hdsp->clock_source_locked ? "Yes" : "No");
3390
3391         snd_iprintf(buffer, "\n");
3392
3393         switch (hdsp_spdif_in(hdsp)) {
3394         case HDSP_SPDIFIN_OPTICAL:
3395                 snd_iprintf(buffer, "IEC958 input: Optical\n");
3396                 break;
3397         case HDSP_SPDIFIN_COAXIAL:
3398                 snd_iprintf(buffer, "IEC958 input: Coaxial\n");
3399                 break;
3400         case HDSP_SPDIFIN_INTERNAL:
3401                 snd_iprintf(buffer, "IEC958 input: Internal\n");
3402                 break;
3403         case HDSP_SPDIFIN_AES:
3404                 snd_iprintf(buffer, "IEC958 input: AES\n");
3405                 break;
3406         default:
3407                 snd_iprintf(buffer, "IEC958 input: ???\n");
3408                 break;
3409         }
3410
3411         if (hdsp->control_register & HDSP_SPDIFOpticalOut) {
3412                 snd_iprintf(buffer, "IEC958 output: Coaxial & ADAT1\n");
3413         } else {
3414                 snd_iprintf(buffer, "IEC958 output: Coaxial only\n");
3415         }
3416
3417         if (hdsp->control_register & HDSP_SPDIFProfessional) {
3418                 snd_iprintf(buffer, "IEC958 quality: Professional\n");
3419         } else {
3420                 snd_iprintf(buffer, "IEC958 quality: Consumer\n");
3421         }
3422
3423         if (hdsp->control_register & HDSP_SPDIFEmphasis) {
3424                 snd_iprintf(buffer, "IEC958 emphasis: on\n");
3425         } else {
3426                 snd_iprintf(buffer, "IEC958 emphasis: off\n");
3427         }
3428
3429         if (hdsp->control_register & HDSP_SPDIFNonAudio) {
3430                 snd_iprintf(buffer, "IEC958 NonAudio: on\n");
3431         } else {
3432                 snd_iprintf(buffer, "IEC958 NonAudio: off\n");
3433   &nb