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