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