?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.8-rc7
[cris-mirror.git] / sound / pci / rme9652 / hdspm.c
blob223c3d9cc69efa1af38e6dee6c45ffc0f3733c55
1 /*
2 * ALSA driver for RME Hammerfall DSP MADI audio interface(s)
3 *
4 * Copyright (c) 2003 Winfried Ritsch (IEM)
5 * code based on hdsp.c Paul Davis
6 * Marcus Andersson
7 * Thomas Charbonnel
8 * Modified 2006-06-01 for AES32 support by Remy Bruno
9 * <remy.bruno@trinnov.com>
10 *
11 * Modified 2009-04-13 for proper metering by Florian Faber
12 * <faber@faberman.de>
13 *
14 * Modified 2009-04-14 for native float support by Florian Faber
15 * <faber@faberman.de>
16 *
17 * Modified 2009-04-26 fixed bug in rms metering by Florian Faber
18 * <faber@faberman.de>
19 *
20 * Modified 2009-04-30 added hw serial number support by Florian Faber
21 *
22 * Modified 2011-01-14 added S/PDIF input on RayDATs by Adrian Knoth
23 *
24 * Modified 2011-01-25 variable period sizes on RayDAT/AIO by Adrian Knoth
25 *
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
30 *
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
35 *
36 * You should have received a copy of the GNU General Public License
37 * along with this program; if not, write to the Free Software
38 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39 *
40 */
41 #include <linux/init.h>
42 #include <linux/delay.h>
43 #include <linux/interrupt.h>
44 #include <linux/module.h>
45 #include <linux/slab.h>
46 #include <linux/pci.h>
47 #include <linux/math64.h>
48 #include <asm/io.h>
49
50 #include <sound/core.h>
51 #include <sound/control.h>
52 #include <sound/pcm.h>
53 #include <sound/pcm_params.h>
54 #include <sound/info.h>
55 #include <sound/asoundef.h>
56 #include <sound/rawmidi.h>
57 #include <sound/hwdep.h>
58 #include <sound/initval.h>
59
60 #include <sound/hdspm.h>
61
62 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
63 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
64 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
65
66 module_param_array(index, int, NULL, 0444);
67 MODULE_PARM_DESC(index, "Index value for RME HDSPM interface.");
68
69 module_param_array(id, charp, NULL, 0444);
70 MODULE_PARM_DESC(id, "ID string for RME HDSPM interface.");
71
72 module_param_array(enable, bool, NULL, 0444);
73 MODULE_PARM_DESC(enable, "Enable/disable specific HDSPM soundcards.");
74
75
76 MODULE_AUTHOR
77 (
78 "Winfried Ritsch <ritsch_AT_iem.at>, "
79 "Paul Davis <paul@linuxaudiosystems.com>, "
80 "Marcus Andersson, Thomas Charbonnel <thomas@undata.org>, "
81 "Remy Bruno <remy.bruno@trinnov.com>, "
82 "Florian Faber <faberman@linuxproaudio.org>, "
83 "Adrian Knoth <adi@drcomp.erfurt.thur.de>"
84 );
85 MODULE_DESCRIPTION("RME HDSPM");
86 MODULE_LICENSE("GPL");
87 MODULE_SUPPORTED_DEVICE("{{RME HDSPM-MADI}}");
88
89 /* --- Write registers. ---
90 These are defined as byte-offsets from the iobase value. */
91
92 #define HDSPM_WR_SETTINGS 0
93 #define HDSPM_outputBufferAddress 32
94 #define HDSPM_inputBufferAddress 36
95 #define HDSPM_controlRegister 64
96 #define HDSPM_interruptConfirmation 96
97 #define HDSPM_control2Reg 256 /* not in specs ???????? */
98 #define HDSPM_freqReg 256 /* for AES32 */
99 #define HDSPM_midiDataOut0 352 /* just believe in old code */
100 #define HDSPM_midiDataOut1 356
101 #define HDSPM_eeprom_wr 384 /* for AES32 */
102
103 /* DMA enable for 64 channels, only Bit 0 is relevant */
104 #define HDSPM_outputEnableBase 512 /* 512-767 input DMA */
105 #define HDSPM_inputEnableBase 768 /* 768-1023 output DMA */
106
107 /* 16 page addresses for each of the 64 channels DMA buffer in and out
108 (each 64k=16*4k) Buffer must be 4k aligned (which is default i386 ????) */
109 #define HDSPM_pageAddressBufferOut 8192
110 #define HDSPM_pageAddressBufferIn (HDSPM_pageAddressBufferOut+64*16*4)
111
112 #define HDSPM_MADI_mixerBase 32768 /* 32768-65535 for 2x64x64 Fader */
113
114 #define HDSPM_MATRIX_MIXER_SIZE 8192 /* = 2*64*64 * 4 Byte => 32kB */
115
116 /* --- Read registers. ---
117 These are defined as byte-offsets from the iobase value */
118 #define HDSPM_statusRegister 0
119 /*#define HDSPM_statusRegister2 96 */
120 /* after RME Windows driver sources, status2 is 4-byte word # 48 = word at
121 * offset 192, for AES32 *and* MADI
122 * => need to check that offset 192 is working on MADI */
123 #define HDSPM_statusRegister2 192
124 #define HDSPM_timecodeRegister 128
125
126 /* AIO, RayDAT */
127 #define HDSPM_RD_STATUS_0 0
128 #define HDSPM_RD_STATUS_1 64
129 #define HDSPM_RD_STATUS_2 128
130 #define HDSPM_RD_STATUS_3 192
131
132 #define HDSPM_RD_TCO 256
133 #define HDSPM_RD_PLL_FREQ 512
134 #define HDSPM_WR_TCO 128
135
136 #define HDSPM_TCO1_TCO_lock 0x00000001
137 #define HDSPM_TCO1_WCK_Input_Range_LSB 0x00000002
138 #define HDSPM_TCO1_WCK_Input_Range_MSB 0x00000004
139 #define HDSPM_TCO1_LTC_Input_valid 0x00000008
140 #define HDSPM_TCO1_WCK_Input_valid 0x00000010
141 #define HDSPM_TCO1_Video_Input_Format_NTSC 0x00000020
142 #define HDSPM_TCO1_Video_Input_Format_PAL 0x00000040
143
144 #define HDSPM_TCO1_set_TC 0x00000100
145 #define HDSPM_TCO1_set_drop_frame_flag 0x00000200
146 #define HDSPM_TCO1_LTC_Format_LSB 0x00000400
147 #define HDSPM_TCO1_LTC_Format_MSB 0x00000800
148
149 #define HDSPM_TCO2_TC_run 0x00010000
150 #define HDSPM_TCO2_WCK_IO_ratio_LSB 0x00020000
151 #define HDSPM_TCO2_WCK_IO_ratio_MSB 0x00040000
152 #define HDSPM_TCO2_set_num_drop_frames_LSB 0x00080000
153 #define HDSPM_TCO2_set_num_drop_frames_MSB 0x00100000
154 #define HDSPM_TCO2_set_jam_sync 0x00200000
155 #define HDSPM_TCO2_set_flywheel 0x00400000
156
157 #define HDSPM_TCO2_set_01_4 0x01000000
158 #define HDSPM_TCO2_set_pull_down 0x02000000
159 #define HDSPM_TCO2_set_pull_up 0x04000000
160 #define HDSPM_TCO2_set_freq 0x08000000
161 #define HDSPM_TCO2_set_term_75R 0x10000000
162 #define HDSPM_TCO2_set_input_LSB 0x20000000
163 #define HDSPM_TCO2_set_input_MSB 0x40000000
164 #define HDSPM_TCO2_set_freq_from_app 0x80000000
165
166
167 #define HDSPM_midiDataOut0 352
168 #define HDSPM_midiDataOut1 356
169 #define HDSPM_midiDataOut2 368
170
171 #define HDSPM_midiDataIn0 360
172 #define HDSPM_midiDataIn1 364
173 #define HDSPM_midiDataIn2 372
174 #define HDSPM_midiDataIn3 376
175
176 /* status is data bytes in MIDI-FIFO (0-128) */
177 #define HDSPM_midiStatusOut0 384
178 #define HDSPM_midiStatusOut1 388
179 #define HDSPM_midiStatusOut2 400
180
181 #define HDSPM_midiStatusIn0 392
182 #define HDSPM_midiStatusIn1 396
183 #define HDSPM_midiStatusIn2 404
184 #define HDSPM_midiStatusIn3 408
185
186
187 /* the meters are regular i/o-mapped registers, but offset
188 considerably from the rest. the peak registers are reset
189 when read; the least-significant 4 bits are full-scale counters;
190 the actual peak value is in the most-significant 24 bits.
191 */
192
193 #define HDSPM_MADI_INPUT_PEAK 4096
194 #define HDSPM_MADI_PLAYBACK_PEAK 4352
195 #define HDSPM_MADI_OUTPUT_PEAK 4608
196
197 #define HDSPM_MADI_INPUT_RMS_L 6144
198 #define HDSPM_MADI_PLAYBACK_RMS_L 6400
199 #define HDSPM_MADI_OUTPUT_RMS_L 6656
200
201 #define HDSPM_MADI_INPUT_RMS_H 7168
202 #define HDSPM_MADI_PLAYBACK_RMS_H 7424
203 #define HDSPM_MADI_OUTPUT_RMS_H 7680
204
205 /* --- Control Register bits --------- */
206 #define HDSPM_Start (1<<0) /* start engine */
207
208 #define HDSPM_Latency0 (1<<1) /* buffer size = 2^n */
209 #define HDSPM_Latency1 (1<<2) /* where n is defined */
210 #define HDSPM_Latency2 (1<<3) /* by Latency{2,1,0} */
211
212 #define HDSPM_ClockModeMaster (1<<4) /* 1=Master, 0=Autosync */
213 #define HDSPM_c0Master 0x1 /* Master clock bit in settings
214 register [RayDAT, AIO] */
215
216 #define HDSPM_AudioInterruptEnable (1<<5) /* what do you think ? */
217
218 #define HDSPM_Frequency0 (1<<6) /* 0=44.1kHz/88.2kHz 1=48kHz/96kHz */
219 #define HDSPM_Frequency1 (1<<7) /* 0=32kHz/64kHz */
220 #define HDSPM_DoubleSpeed (1<<8) /* 0=normal speed, 1=double speed */
221 #define HDSPM_QuadSpeed (1<<31) /* quad speed bit */
222
223 #define HDSPM_Professional (1<<9) /* Professional */ /* AES32 ONLY */
224 #define HDSPM_TX_64ch (1<<10) /* Output 64channel MODE=1,
225 56channelMODE=0 */ /* MADI ONLY*/
226 #define HDSPM_Emphasis (1<<10) /* Emphasis */ /* AES32 ONLY */
227
228 #define HDSPM_AutoInp (1<<11) /* Auto Input (takeover) == Safe Mode,
229 0=off, 1=on */ /* MADI ONLY */
230 #define HDSPM_Dolby (1<<11) /* Dolby = "NonAudio" ?? */ /* AES32 ONLY */
231
232 #define HDSPM_InputSelect0 (1<<14) /* Input select 0= optical, 1=coax
233 * -- MADI ONLY
234 */
235 #define HDSPM_InputSelect1 (1<<15) /* should be 0 */
236
237 #define HDSPM_SyncRef2 (1<<13)
238 #define HDSPM_SyncRef3 (1<<25)
239
240 #define HDSPM_SMUX (1<<18) /* Frame ??? */ /* MADI ONY */
241 #define HDSPM_clr_tms (1<<19) /* clear track marker, do not use
242 AES additional bits in
243 lower 5 Audiodatabits ??? */
244 #define HDSPM_taxi_reset (1<<20) /* ??? */ /* MADI ONLY ? */
245 #define HDSPM_WCK48 (1<<20) /* Frame ??? = HDSPM_SMUX */ /* AES32 ONLY */
246
247 #define HDSPM_Midi0InterruptEnable 0x0400000
248 #define HDSPM_Midi1InterruptEnable 0x0800000
249 #define HDSPM_Midi2InterruptEnable 0x0200000
250 #define HDSPM_Midi3InterruptEnable 0x4000000
251
252 #define HDSPM_LineOut (1<<24) /* Analog Out on channel 63/64 on=1, mute=0 */
253 #define HDSPe_FLOAT_FORMAT 0x2000000
254
255 #define HDSPM_DS_DoubleWire (1<<26) /* AES32 ONLY */
256 #define HDSPM_QS_DoubleWire (1<<27) /* AES32 ONLY */
257 #define HDSPM_QS_QuadWire (1<<28) /* AES32 ONLY */
258
259 #define HDSPM_wclk_sel (1<<30)
260
261 /* --- bit helper defines */
262 #define HDSPM_LatencyMask (HDSPM_Latency0|HDSPM_Latency1|HDSPM_Latency2)
263 #define HDSPM_FrequencyMask (HDSPM_Frequency0|HDSPM_Frequency1|\
264 HDSPM_DoubleSpeed|HDSPM_QuadSpeed)
265 #define HDSPM_InputMask (HDSPM_InputSelect0|HDSPM_InputSelect1)
266 #define HDSPM_InputOptical 0
267 #define HDSPM_InputCoaxial (HDSPM_InputSelect0)
268 #define HDSPM_SyncRefMask (HDSPM_SyncRef0|HDSPM_SyncRef1|\
269 HDSPM_SyncRef2|HDSPM_SyncRef3)
270
271 #define HDSPM_c0_SyncRef0 0x2
272 #define HDSPM_c0_SyncRef1 0x4
273 #define HDSPM_c0_SyncRef2 0x8
274 #define HDSPM_c0_SyncRef3 0x10
275 #define HDSPM_c0_SyncRefMask (HDSPM_c0_SyncRef0 | HDSPM_c0_SyncRef1 |\
276 HDSPM_c0_SyncRef2 | HDSPM_c0_SyncRef3)
277
278 #define HDSPM_SYNC_FROM_WORD 0 /* Preferred sync reference */
279 #define HDSPM_SYNC_FROM_MADI 1 /* choices - used by "pref_sync_ref" */
280 #define HDSPM_SYNC_FROM_TCO 2
281 #define HDSPM_SYNC_FROM_SYNC_IN 3
282
283 #define HDSPM_Frequency32KHz HDSPM_Frequency0
284 #define HDSPM_Frequency44_1KHz HDSPM_Frequency1
285 #define HDSPM_Frequency48KHz (HDSPM_Frequency1|HDSPM_Frequency0)
286 #define HDSPM_Frequency64KHz (HDSPM_DoubleSpeed|HDSPM_Frequency0)
287 #define HDSPM_Frequency88_2KHz (HDSPM_DoubleSpeed|HDSPM_Frequency1)
288 #define HDSPM_Frequency96KHz (HDSPM_DoubleSpeed|HDSPM_Frequency1|\
289 HDSPM_Frequency0)
290 #define HDSPM_Frequency128KHz (HDSPM_QuadSpeed|HDSPM_Frequency0)
291 #define HDSPM_Frequency176_4KHz (HDSPM_QuadSpeed|HDSPM_Frequency1)
292 #define HDSPM_Frequency192KHz (HDSPM_QuadSpeed|HDSPM_Frequency1|\
293 HDSPM_Frequency0)
294
295
296 /* Synccheck Status */
297 #define HDSPM_SYNC_CHECK_NO_LOCK 0
298 #define HDSPM_SYNC_CHECK_LOCK 1
299 #define HDSPM_SYNC_CHECK_SYNC 2
300
301 /* AutoSync References - used by "autosync_ref" control switch */
302 #define HDSPM_AUTOSYNC_FROM_WORD 0
303 #define HDSPM_AUTOSYNC_FROM_MADI 1
304 #define HDSPM_AUTOSYNC_FROM_TCO 2
305 #define HDSPM_AUTOSYNC_FROM_SYNC_IN 3
306 #define HDSPM_AUTOSYNC_FROM_NONE 4
307
308 /* Possible sources of MADI input */
309 #define HDSPM_OPTICAL 0 /* optical */
310 #define HDSPM_COAXIAL 1 /* BNC */
311
312 #define hdspm_encode_latency(x) (((x)<<1) & HDSPM_LatencyMask)
313 #define hdspm_decode_latency(x) ((((x) & HDSPM_LatencyMask)>>1))
314
315 #define hdspm_encode_in(x) (((x)&0x3)<<14)
316 #define hdspm_decode_in(x) (((x)>>14)&0x3)
317
318 /* --- control2 register bits --- */
319 #define HDSPM_TMS (1<<0)
320 #define HDSPM_TCK (1<<1)
321 #define HDSPM_TDI (1<<2)
322 #define HDSPM_JTAG (1<<3)
323 #define HDSPM_PWDN (1<<4)
324 #define HDSPM_PROGRAM (1<<5)
325 #define HDSPM_CONFIG_MODE_0 (1<<6)
326 #define HDSPM_CONFIG_MODE_1 (1<<7)
327 /*#define HDSPM_VERSION_BIT (1<<8) not defined any more*/
328 #define HDSPM_BIGENDIAN_MODE (1<<9)
329 #define HDSPM_RD_MULTIPLE (1<<10)
330
331 /* --- Status Register bits --- */ /* MADI ONLY */ /* Bits defined here and
332 that do not conflict with specific bits for AES32 seem to be valid also
333 for the AES32
334 */
335 #define HDSPM_audioIRQPending (1<<0) /* IRQ is high and pending */
336 #define HDSPM_RX_64ch (1<<1) /* Input 64chan. MODE=1, 56chn MODE=0 */
337 #define HDSPM_AB_int (1<<2) /* InputChannel Opt=0, Coax=1
338 * (like inp0)
339 */
340
341 #define HDSPM_madiLock (1<<3) /* MADI Locked =1, no=0 */
342 #define HDSPM_madiSync (1<<18) /* MADI is in sync */
343
344 #define HDSPM_tcoLock 0x00000020 /* Optional TCO locked status FOR HDSPe MADI! */
345 #define HDSPM_tcoSync 0x10000000 /* Optional TCO sync status */
346
347 #define HDSPM_syncInLock 0x00010000 /* Sync In lock status FOR HDSPe MADI! */
348 #define HDSPM_syncInSync 0x00020000 /* Sync In sync status FOR HDSPe MADI! */
349
350 #define HDSPM_BufferPositionMask 0x000FFC0 /* Bit 6..15 : h/w buffer pointer */
351 /* since 64byte accurate, last 6 bits are not used */
352
353
354
355 #define HDSPM_DoubleSpeedStatus (1<<19) /* (input) card in double speed */
356
357 #define HDSPM_madiFreq0 (1<<22) /* system freq 0=error */
358 #define HDSPM_madiFreq1 (1<<23) /* 1=32, 2=44.1 3=48 */
359 #define HDSPM_madiFreq2 (1<<24) /* 4=64, 5=88.2 6=96 */
360 #define HDSPM_madiFreq3 (1<<25) /* 7=128, 8=176.4 9=192 */
361
362 #define HDSPM_BufferID (1<<26) /* (Double)Buffer ID toggles with
363 * Interrupt
364 */
365 #define HDSPM_tco_detect 0x08000000
366 #define HDSPM_tco_lock 0x20000000
367
368 #define HDSPM_s2_tco_detect 0x00000040
369 #define HDSPM_s2_AEBO_D 0x00000080
370 #define HDSPM_s2_AEBI_D 0x00000100
371
372
373 #define HDSPM_midi0IRQPending 0x40000000
374 #define HDSPM_midi1IRQPending 0x80000000
375 #define HDSPM_midi2IRQPending 0x20000000
376 #define HDSPM_midi2IRQPendingAES 0x00000020
377 #define HDSPM_midi3IRQPending 0x00200000
378
379 /* --- status bit helpers */
380 #define HDSPM_madiFreqMask (HDSPM_madiFreq0|HDSPM_madiFreq1|\
381 HDSPM_madiFreq2|HDSPM_madiFreq3)
382 #define HDSPM_madiFreq32 (HDSPM_madiFreq0)
383 #define HDSPM_madiFreq44_1 (HDSPM_madiFreq1)
384 #define HDSPM_madiFreq48 (HDSPM_madiFreq0|HDSPM_madiFreq1)
385 #define HDSPM_madiFreq64 (HDSPM_madiFreq2)
386 #define HDSPM_madiFreq88_2 (HDSPM_madiFreq0|HDSPM_madiFreq2)
387 #define HDSPM_madiFreq96 (HDSPM_madiFreq1|HDSPM_madiFreq2)
388 #define HDSPM_madiFreq128 (HDSPM_madiFreq0|HDSPM_madiFreq1|HDSPM_madiFreq2)
389 #define HDSPM_madiFreq176_4 (HDSPM_madiFreq3)
390 #define HDSPM_madiFreq192 (HDSPM_madiFreq3|HDSPM_madiFreq0)
391
392 /* Status2 Register bits */ /* MADI ONLY */
393
394 #define HDSPM_version0 (1<<0) /* not really defined but I guess */
395 #define HDSPM_version1 (1<<1) /* in former cards it was ??? */
396 #define HDSPM_version2 (1<<2)
397
398 #define HDSPM_wcLock (1<<3) /* Wordclock is detected and locked */
399 #define HDSPM_wcSync (1<<4) /* Wordclock is in sync with systemclock */
400
401 #define HDSPM_wc_freq0 (1<<5) /* input freq detected via autosync */
402 #define HDSPM_wc_freq1 (1<<6) /* 001=32, 010==44.1, 011=48, */
403 #define HDSPM_wc_freq2 (1<<7) /* 100=64, 101=88.2, 110=96, */
404 /* missing Bit for 111=128, 1000=176.4, 1001=192 */
405
406 #define HDSPM_SyncRef0 0x10000 /* Sync Reference */
407 #define HDSPM_SyncRef1 0x20000
408
409 #define HDSPM_SelSyncRef0 (1<<8) /* AutoSync Source */
410 #define HDSPM_SelSyncRef1 (1<<9) /* 000=word, 001=MADI, */
411 #define HDSPM_SelSyncRef2 (1<<10) /* 111=no valid signal */
412
413 #define HDSPM_wc_valid (HDSPM_wcLock|HDSPM_wcSync)
414
415 #define HDSPM_wcFreqMask (HDSPM_wc_freq0|HDSPM_wc_freq1|HDSPM_wc_freq2)
416 #define HDSPM_wcFreq32 (HDSPM_wc_freq0)
417 #define HDSPM_wcFreq44_1 (HDSPM_wc_freq1)
418 #define HDSPM_wcFreq48 (HDSPM_wc_freq0|HDSPM_wc_freq1)
419 #define HDSPM_wcFreq64 (HDSPM_wc_freq2)
420 #define HDSPM_wcFreq88_2 (HDSPM_wc_freq0|HDSPM_wc_freq2)
421 #define HDSPM_wcFreq96 (HDSPM_wc_freq1|HDSPM_wc_freq2)
422
423 #define HDSPM_status1_F_0 0x0400000
424 #define HDSPM_status1_F_1 0x0800000
425 #define HDSPM_status1_F_2 0x1000000
426 #define HDSPM_status1_F_3 0x2000000
427 #define HDSPM_status1_freqMask (HDSPM_status1_F_0|HDSPM_status1_F_1|HDSPM_status1_F_2|HDSPM_status1_F_3)
428
429
430 #define HDSPM_SelSyncRefMask (HDSPM_SelSyncRef0|HDSPM_SelSyncRef1|\
431 HDSPM_SelSyncRef2)
432 #define HDSPM_SelSyncRef_WORD 0
433 #define HDSPM_SelSyncRef_MADI (HDSPM_SelSyncRef0)
434 #define HDSPM_SelSyncRef_TCO (HDSPM_SelSyncRef1)
435 #define HDSPM_SelSyncRef_SyncIn (HDSPM_SelSyncRef0|HDSPM_SelSyncRef1)
436 #define HDSPM_SelSyncRef_NVALID (HDSPM_SelSyncRef0|HDSPM_SelSyncRef1|\
437 HDSPM_SelSyncRef2)
438
439 /*
440 For AES32, bits for status, status2 and timecode are different
441 */
442 /* status */
443 #define HDSPM_AES32_wcLock 0x0200000
444 #define HDSPM_AES32_wcSync 0x0100000
445 #define HDSPM_AES32_wcFreq_bit 22
446 /* (status >> HDSPM_AES32_wcFreq_bit) & 0xF gives WC frequency (cf function
447 HDSPM_bit2freq */
448 #define HDSPM_AES32_syncref_bit 16
449 /* (status >> HDSPM_AES32_syncref_bit) & 0xF gives sync source */
450
451 #define HDSPM_AES32_AUTOSYNC_FROM_WORD 0
452 #define HDSPM_AES32_AUTOSYNC_FROM_AES1 1
453 #define HDSPM_AES32_AUTOSYNC_FROM_AES2 2
454 #define HDSPM_AES32_AUTOSYNC_FROM_AES3 3
455 #define HDSPM_AES32_AUTOSYNC_FROM_AES4 4
456 #define HDSPM_AES32_AUTOSYNC_FROM_AES5 5
457 #define HDSPM_AES32_AUTOSYNC_FROM_AES6 6
458 #define HDSPM_AES32_AUTOSYNC_FROM_AES7 7
459 #define HDSPM_AES32_AUTOSYNC_FROM_AES8 8
460 #define HDSPM_AES32_AUTOSYNC_FROM_NONE 9
461
462 /* status2 */
463 /* HDSPM_LockAES_bit is given by HDSPM_LockAES >> (AES# - 1) */
464 #define HDSPM_LockAES 0x80
465 #define HDSPM_LockAES1 0x80
466 #define HDSPM_LockAES2 0x40
467 #define HDSPM_LockAES3 0x20
468 #define HDSPM_LockAES4 0x10
469 #define HDSPM_LockAES5 0x8
470 #define HDSPM_LockAES6 0x4
471 #define HDSPM_LockAES7 0x2
472 #define HDSPM_LockAES8 0x1
473 /*
474 Timecode
475 After windows driver sources, bits 4*i to 4*i+3 give the input frequency on
476 AES i+1
477 bits 3210
478 0001 32kHz
479 0010 44.1kHz
480 0011 48kHz
481 0100 64kHz
482 0101 88.2kHz
483 0110 96kHz
484 0111 128kHz
485 1000 176.4kHz
486 1001 192kHz
487 NB: Timecode register doesn't seem to work on AES32 card revision 230
488 */
489
490 /* Mixer Values */
491 #define UNITY_GAIN 32768 /* = 65536/2 */
492 #define MINUS_INFINITY_GAIN 0
493
494 /* Number of channels for different Speed Modes */
495 #define MADI_SS_CHANNELS 64
496 #define MADI_DS_CHANNELS 32
497 #define MADI_QS_CHANNELS 16
498
499 #define RAYDAT_SS_CHANNELS 36
500 #define RAYDAT_DS_CHANNELS 20
501 #define RAYDAT_QS_CHANNELS 12
502
503 #define AIO_IN_SS_CHANNELS 14
504 #define AIO_IN_DS_CHANNELS 10
505 #define AIO_IN_QS_CHANNELS 8
506 #define AIO_OUT_SS_CHANNELS 16
507 #define AIO_OUT_DS_CHANNELS 12
508 #define AIO_OUT_QS_CHANNELS 10
509
510 #define AES32_CHANNELS 16
511
512 /* the size of a substream (1 mono data stream) */
513 #define HDSPM_CHANNEL_BUFFER_SAMPLES (16*1024)
514 #define HDSPM_CHANNEL_BUFFER_BYTES (4*HDSPM_CHANNEL_BUFFER_SAMPLES)
515
516 /* the size of the area we need to allocate for DMA transfers. the
517 size is the same regardless of the number of channels, and
518 also the latency to use.
519 for one direction !!!
520 */
521 #define HDSPM_DMA_AREA_BYTES (HDSPM_MAX_CHANNELS * HDSPM_CHANNEL_BUFFER_BYTES)
522 #define HDSPM_DMA_AREA_KILOBYTES (HDSPM_DMA_AREA_BYTES/1024)
523
524 #define HDSPM_RAYDAT_REV 211
525 #define HDSPM_AIO_REV 212
526 #define HDSPM_MADIFACE_REV 213
527
528 /* speed factor modes */
529 #define HDSPM_SPEED_SINGLE 0
530 #define HDSPM_SPEED_DOUBLE 1
531 #define HDSPM_SPEED_QUAD 2
532
533 /* names for speed modes */
534 static char *hdspm_speed_names[] = { "single", "double", "quad" };
535
536 static char *texts_autosync_aes_tco[] = { "Word Clock",
537 "AES1", "AES2", "AES3", "AES4",
538 "AES5", "AES6", "AES7", "AES8",
539 "TCO" };
540 static char *texts_autosync_aes[] = { "Word Clock",
541 "AES1", "AES2", "AES3", "AES4",
542 "AES5", "AES6", "AES7", "AES8" };
543 static char *texts_autosync_madi_tco[] = { "Word Clock",
544 "MADI", "TCO", "Sync In" };
545 static char *texts_autosync_madi[] = { "Word Clock",
546 "MADI", "Sync In" };
547
548 static char *texts_autosync_raydat_tco[] = {
549 "Word Clock",
550 "ADAT 1", "ADAT 2", "ADAT 3", "ADAT 4",
551 "AES", "SPDIF", "TCO", "Sync In"
552 };
553 static char *texts_autosync_raydat[] = {
554 "Word Clock",
555 "ADAT 1", "ADAT 2", "ADAT 3", "ADAT 4",
556 "AES", "SPDIF", "Sync In"
557 };
558 static char *texts_autosync_aio_tco[] = {
559 "Word Clock",
560 "ADAT", "AES", "SPDIF", "TCO", "Sync In"
561 };
562 static char *texts_autosync_aio[] = { "Word Clock",
563 "ADAT", "AES", "SPDIF", "Sync In" };
564
565 static char *texts_freq[] = {
566 "No Lock",
567 "32 kHz",
568 "44.1 kHz",
569 "48 kHz",
570 "64 kHz",
571 "88.2 kHz",
572 "96 kHz",
573 "128 kHz",
574 "176.4 kHz",
575 "192 kHz"
576 };
577
578 static char *texts_ports_madi[] = {
579 "MADI.1", "MADI.2", "MADI.3", "MADI.4", "MADI.5", "MADI.6",
580 "MADI.7", "MADI.8", "MADI.9", "MADI.10", "MADI.11", "MADI.12",
581 "MADI.13", "MADI.14", "MADI.15", "MADI.16", "MADI.17", "MADI.18",
582 "MADI.19", "MADI.20", "MADI.21", "MADI.22", "MADI.23", "MADI.24",
583 "MADI.25", "MADI.26", "MADI.27", "MADI.28", "MADI.29", "MADI.30",
584 "MADI.31", "MADI.32", "MADI.33", "MADI.34", "MADI.35", "MADI.36",
585 "MADI.37", "MADI.38", "MADI.39", "MADI.40", "MADI.41", "MADI.42",
586 "MADI.43", "MADI.44", "MADI.45", "MADI.46", "MADI.47", "MADI.48",
587 "MADI.49", "MADI.50", "MADI.51", "MADI.52", "MADI.53", "MADI.54",
588 "MADI.55", "MADI.56", "MADI.57", "MADI.58", "MADI.59", "MADI.60",
589 "MADI.61", "MADI.62", "MADI.63", "MADI.64",
590 };
591
592
593 static char *texts_ports_raydat_ss[] = {
594 "ADAT1.1", "ADAT1.2", "ADAT1.3", "ADAT1.4", "ADAT1.5", "ADAT1.6",
595 "ADAT1.7", "ADAT1.8", "ADAT2.1", "ADAT2.2", "ADAT2.3", "ADAT2.4",
596 "ADAT2.5", "ADAT2.6", "ADAT2.7", "ADAT2.8", "ADAT3.1", "ADAT3.2",
597 "ADAT3.3", "ADAT3.4", "ADAT3.5", "ADAT3.6", "ADAT3.7", "ADAT3.8",
598 "ADAT4.1", "ADAT4.2", "ADAT4.3", "ADAT4.4", "ADAT4.5", "ADAT4.6",
599 "ADAT4.7", "ADAT4.8",
600 "AES.L", "AES.R",
601 "SPDIF.L", "SPDIF.R"
602 };
603
604 static char *texts_ports_raydat_ds[] = {
605 "ADAT1.1", "ADAT1.2", "ADAT1.3", "ADAT1.4",
606 "ADAT2.1", "ADAT2.2", "ADAT2.3", "ADAT2.4",
607 "ADAT3.1", "ADAT3.2", "ADAT3.3", "ADAT3.4",
608 "ADAT4.1", "ADAT4.2", "ADAT4.3", "ADAT4.4",
609 "AES.L", "AES.R",
610 "SPDIF.L", "SPDIF.R"
611 };
612
613 static char *texts_ports_raydat_qs[] = {
614 "ADAT1.1", "ADAT1.2",
615 "ADAT2.1", "ADAT2.2",
616 "ADAT3.1", "ADAT3.2",
617 "ADAT4.1", "ADAT4.2",
618 "AES.L", "AES.R",
619 "SPDIF.L", "SPDIF.R"
620 };
621
622
623 static char *texts_ports_aio_in_ss[] = {
624 "Analogue.L", "Analogue.R",
625 "AES.L", "AES.R",
626 "SPDIF.L", "SPDIF.R",
627 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4", "ADAT.5", "ADAT.6",
628 "ADAT.7", "ADAT.8"
629 };
630
631 static char *texts_ports_aio_out_ss[] = {
632 "Analogue.L", "Analogue.R",
633 "AES.L", "AES.R",
634 "SPDIF.L", "SPDIF.R",
635 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4", "ADAT.5", "ADAT.6",
636 "ADAT.7", "ADAT.8",
637 "Phone.L", "Phone.R"
638 };
639
640 static char *texts_ports_aio_in_ds[] = {
641 "Analogue.L", "Analogue.R",
642 "AES.L", "AES.R",
643 "SPDIF.L", "SPDIF.R",
644 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4"
645 };
646
647 static char *texts_ports_aio_out_ds[] = {
648 "Analogue.L", "Analogue.R",
649 "AES.L", "AES.R",
650 "SPDIF.L", "SPDIF.R",
651 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4",
652 "Phone.L", "Phone.R"
653 };
654
655 static char *texts_ports_aio_in_qs[] = {
656 "Analogue.L", "Analogue.R",
657 "AES.L", "AES.R",
658 "SPDIF.L", "SPDIF.R",
659 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4"
660 };
661
662 static char *texts_ports_aio_out_qs[] = {
663 "Analogue.L", "Analogue.R",
664 "AES.L", "AES.R",
665 "SPDIF.L", "SPDIF.R",
666 "ADAT.1", "ADAT.2", "ADAT.3", "ADAT.4",
667 "Phone.L", "Phone.R"
668 };
669
670 static char *texts_ports_aes32[] = {
671 "AES.1", "AES.2", "AES.3", "AES.4", "AES.5", "AES.6", "AES.7",
672 "AES.8", "AES.9.", "AES.10", "AES.11", "AES.12", "AES.13", "AES.14",
673 "AES.15", "AES.16"
674 };
675
676 /* These tables map the ALSA channels 1..N to the channels that we
677 need to use in order to find the relevant channel buffer. RME
678 refers to this kind of mapping as between "the ADAT channel and
679 the DMA channel." We index it using the logical audio channel,
680 and the value is the DMA channel (i.e. channel buffer number)
681 where the data for that channel can be read/written from/to.
682 */
683
684 static char channel_map_unity_ss[HDSPM_MAX_CHANNELS] = {
685 0, 1, 2, 3, 4, 5, 6, 7,
686 8, 9, 10, 11, 12, 13, 14, 15,
687 16, 17, 18, 19, 20, 21, 22, 23,
688 24, 25, 26, 27, 28, 29, 30, 31,
689 32, 33, 34, 35, 36, 37, 38, 39,
690 40, 41, 42, 43, 44, 45, 46, 47,
691 48, 49, 50, 51, 52, 53, 54, 55,
692 56, 57, 58, 59, 60, 61, 62, 63
693 };
694
695 static char channel_map_raydat_ss[HDSPM_MAX_CHANNELS] = {
696 4, 5, 6, 7, 8, 9, 10, 11, /* ADAT 1 */
697 12, 13, 14, 15, 16, 17, 18, 19, /* ADAT 2 */
698 20, 21, 22, 23, 24, 25, 26, 27, /* ADAT 3 */
699 28, 29, 30, 31, 32, 33, 34, 35, /* ADAT 4 */
700 0, 1, /* AES */
701 2, 3, /* SPDIF */
702 -1, -1, -1, -1,
703 -1, -1, -1, -1, -1, -1, -1, -1,
704 -1, -1, -1, -1, -1, -1, -1, -1,
705 -1, -1, -1, -1, -1, -1, -1, -1,
706 };
707
708 static char channel_map_raydat_ds[HDSPM_MAX_CHANNELS] = {
709 4, 5, 6, 7, /* ADAT 1 */
710 8, 9, 10, 11, /* ADAT 2 */
711 12, 13, 14, 15, /* ADAT 3 */
712 16, 17, 18, 19, /* ADAT 4 */
713 0, 1, /* AES */
714 2, 3, /* SPDIF */
715 -1, -1, -1, -1,
716 -1, -1, -1, -1, -1, -1, -1, -1,
717 -1, -1, -1, -1, -1, -1, -1, -1,
718 -1, -1, -1, -1, -1, -1, -1, -1,
719 -1, -1, -1, -1, -1, -1, -1, -1,
720 -1, -1, -1, -1, -1, -1, -1, -1,
721 };
722
723 static char channel_map_raydat_qs[HDSPM_MAX_CHANNELS] = {
724 4, 5, /* ADAT 1 */
725 6, 7, /* ADAT 2 */
726 8, 9, /* ADAT 3 */
727 10, 11, /* ADAT 4 */
728 0, 1, /* AES */
729 2, 3, /* SPDIF */
730 -1, -1, -1, -1,
731 -1, -1, -1, -1, -1, -1, -1, -1,
732 -1, -1, -1, -1, -1, -1, -1, -1,
733 -1, -1, -1, -1, -1, -1, -1, -1,
734 -1, -1, -1, -1, -1, -1, -1, -1,
735 -1, -1, -1, -1, -1, -1, -1, -1,
736 -1, -1, -1, -1, -1, -1, -1, -1,
737 };
738
739 static char channel_map_aio_in_ss[HDSPM_MAX_CHANNELS] = {
740 0, 1, /* line in */
741 8, 9, /* aes in, */
742 10, 11, /* spdif in */
743 12, 13, 14, 15, 16, 17, 18, 19, /* ADAT in */
744 -1, -1,
745 -1, -1, -1, -1, -1, -1, -1, -1,
746 -1, -1, -1, -1, -1, -1, -1, -1,
747 -1, -1, -1, -1, -1, -1, -1, -1,
748 -1, -1, -1, -1, -1, -1, -1, -1,
749 -1, -1, -1, -1, -1, -1, -1, -1,
750 -1, -1, -1, -1, -1, -1, -1, -1,
751 };
752
753 static char channel_map_aio_out_ss[HDSPM_MAX_CHANNELS] = {
754 0, 1, /* line out */
755 8, 9, /* aes out */
756 10, 11, /* spdif out */
757 12, 13, 14, 15, 16, 17, 18, 19, /* ADAT out */
758 6, 7, /* phone out */
759 -1, -1, -1, -1, -1, -1, -1, -1,
760 -1, -1, -1, -1, -1, -1, -1, -1,
761 -1, -1, -1, -1, -1, -1, -1, -1,
762 -1, -1, -1, -1, -1, -1, -1, -1,
763 -1, -1, -1, -1, -1, -1, -1, -1,
764 -1, -1, -1, -1, -1, -1, -1, -1,
765 };
766
767 static char channel_map_aio_in_ds[HDSPM_MAX_CHANNELS] = {
768 0, 1, /* line in */
769 8, 9, /* aes in */
770 10, 11, /* spdif in */
771 12, 14, 16, 18, /* adat in */
772 -1, -1, -1, -1, -1, -1,
773 -1, -1, -1, -1, -1, -1, -1, -1,
774 -1, -1, -1, -1, -1, -1, -1, -1,
775 -1, -1, -1, -1, -1, -1, -1, -1,
776 -1, -1, -1, -1, -1, -1, -1, -1,
777 -1, -1, -1, -1, -1, -1, -1, -1,
778 -1, -1, -1, -1, -1, -1, -1, -1
779 };
780
781 static char channel_map_aio_out_ds[HDSPM_MAX_CHANNELS] = {
782 0, 1, /* line out */
783 8, 9, /* aes out */
784 10, 11, /* spdif out */
785 12, 14, 16, 18, /* adat out */
786 6, 7, /* phone out */
787 -1, -1, -1, -1,
788 -1, -1, -1, -1, -1, -1, -1, -1,
789 -1, -1, -1, -1, -1, -1, -1, -1,
790 -1, -1, -1, -1, -1, -1, -1, -1,
791 -1, -1, -1, -1, -1, -1, -1, -1,
792 -1, -1, -1, -1, -1, -1, -1, -1,
793 -1, -1, -1, -1, -1, -1, -1, -1
794 };
795
796 static char channel_map_aio_in_qs[HDSPM_MAX_CHANNELS] = {
797 0, 1, /* line in */
798 8, 9, /* aes in */
799 10, 11, /* spdif in */
800 12, 16, /* adat in */
801 -1, -1, -1, -1, -1, -1, -1, -1,
802 -1, -1, -1, -1, -1, -1, -1, -1,
803 -1, -1, -1, -1, -1, -1, -1, -1,
804 -1, -1, -1, -1, -1, -1, -1, -1,
805 -1, -1, -1, -1, -1, -1, -1, -1,
806 -1, -1, -1, -1, -1, -1, -1, -1,
807 -1, -1, -1, -1, -1, -1, -1, -1
808 };
809
810 static char channel_map_aio_out_qs[HDSPM_MAX_CHANNELS] = {
811 0, 1, /* line out */
812 8, 9, /* aes out */
813 10, 11, /* spdif out */
814 12, 16, /* adat out */
815 6, 7, /* phone out */
816 -1, -1, -1, -1, -1, -1,
817 -1, -1, -1, -1, -1, -1, -1, -1,
818 -1, -1, -1, -1, -1, -1, -1, -1,
819 -1, -1, -1, -1, -1, -1, -1, -1,
820 -1, -1, -1, -1, -1, -1, -1, -1,
821 -1, -1, -1, -1, -1, -1, -1, -1,
822 -1, -1, -1, -1, -1, -1, -1, -1
823 };
824
825 static char channel_map_aes32[HDSPM_MAX_CHANNELS] = {
826 0, 1, 2, 3, 4, 5, 6, 7,
827 8, 9, 10, 11, 12, 13, 14, 15,
828 -1, -1, -1, -1, -1, -1, -1, -1,
829 -1, -1, -1, -1, -1, -1, -1, -1,
830 -1, -1, -1, -1, -1, -1, -1, -1,
831 -1, -1, -1, -1, -1, -1, -1, -1,
832 -1, -1, -1, -1, -1, -1, -1, -1,
833 -1, -1, -1, -1, -1, -1, -1, -1
834 };
835
836 struct hdspm_midi {
837 struct hdspm *hdspm;
838 int id;
839 struct snd_rawmidi *rmidi;
840 struct snd_rawmidi_substream *input;
841 struct snd_rawmidi_substream *output;
842 char istimer; /* timer in use */
843 struct timer_list timer;
844 spinlock_t lock;
845 int pending;
846 int dataIn;
847 int statusIn;
848 int dataOut;
849 int statusOut;
850 int ie;
851 int irq;
852 };
853
854 struct hdspm_tco {
855 int input;
856 int framerate;
857 int wordclock;
858 int samplerate;
859 int pull;
860 int term; /* 0 = off, 1 = on */
861 };
862
863 struct hdspm {
864 spinlock_t lock;
865 /* only one playback and/or capture stream */
866 struct snd_pcm_substream *capture_substream;
867 struct snd_pcm_substream *playback_substream;
868
869 char *card_name; /* for procinfo */
870 unsigned short firmware_rev; /* dont know if relevant (yes if AES32)*/
871
872 uint8_t io_type;
873
874 int monitor_outs; /* set up monitoring outs init flag */
875
876 u32 control_register; /* cached value */
877 u32 control2_register; /* cached value */
878 u32 settings_register;
879
880 struct hdspm_midi midi[4];
881 struct tasklet_struct midi_tasklet;
882
883 size_t period_bytes;
884 unsigned char ss_in_channels;
885 unsigned char ds_in_channels;
886 unsigned char qs_in_channels;
887 unsigned char ss_out_channels;
888 unsigned char ds_out_channels;
889 unsigned char qs_out_channels;
890
891 unsigned char max_channels_in;
892 unsigned char max_channels_out;
893
894 signed char *channel_map_in;
895 signed char *channel_map_out;
896
897 signed char *channel_map_in_ss, *channel_map_in_ds, *channel_map_in_qs;
898 signed char *channel_map_out_ss, *channel_map_out_ds, *channel_map_out_qs;
899
900 char **port_names_in;
901 char **port_names_out;
902
903 char **port_names_in_ss, **port_names_in_ds, **port_names_in_qs;
904 char **port_names_out_ss, **port_names_out_ds, **port_names_out_qs;
905
906 unsigned char *playback_buffer; /* suitably aligned address */
907 unsigned char *capture_buffer; /* suitably aligned address */
908
909 pid_t capture_pid; /* process id which uses capture */
910 pid_t playback_pid; /* process id which uses capture */
911 int running; /* running status */
912
913 int last_external_sample_rate; /* samplerate mystic ... */
914 int last_internal_sample_rate;
915 int system_sample_rate;
916
917 int dev; /* Hardware vars... */
918 int irq;
919 unsigned long port;
920 void __iomem *iobase;
921
922 int irq_count; /* for debug */
923 int midiPorts;
924
925 struct snd_card *card; /* one card */
926 struct snd_pcm *pcm; /* has one pcm */
927 struct snd_hwdep *hwdep; /* and a hwdep for additional ioctl */
928 struct pci_dev *pci; /* and an pci info */
929
930 /* Mixer vars */
931 /* fast alsa mixer */
932 struct snd_kcontrol *playback_mixer_ctls[HDSPM_MAX_CHANNELS];
933 /* but input to much, so not used */
934 struct snd_kcontrol *input_mixer_ctls[HDSPM_MAX_CHANNELS];
935 /* full mixer accessible over mixer ioctl or hwdep-device */
936 struct hdspm_mixer *mixer;
937
938 struct hdspm_tco *tco; /* NULL if no TCO detected */
939
940 char **texts_autosync;
941 int texts_autosync_items;
942
943 cycles_t last_interrupt;
944
945 unsigned int serial;
946
947 struct hdspm_peak_rms peak_rms;
948 };
949
950
951 static DEFINE_PCI_DEVICE_TABLE(snd_hdspm_ids) = {
952 {
953 .vendor = PCI_VENDOR_ID_XILINX,
954 .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI,
955 .subvendor = PCI_ANY_ID,
956 .subdevice = PCI_ANY_ID,
957 .class = 0,
958 .class_mask = 0,
959 .driver_data = 0},
960 {0,}
961 };
962
963 MODULE_DEVICE_TABLE(pci, snd_hdspm_ids);
964
965 /* prototypes */
966 static int snd_hdspm_create_alsa_devices(struct snd_card *card,
967 struct hdspm *hdspm);
968 static int snd_hdspm_create_pcm(struct snd_card *card,
969 struct hdspm *hdspm);
970
971 static inline void snd_hdspm_initialize_midi_flush(struct hdspm *hdspm);
972 static int hdspm_update_simple_mixer_controls(struct hdspm *hdspm);
973 static int hdspm_autosync_ref(struct hdspm *hdspm);
974 static int snd_hdspm_set_defaults(struct hdspm *hdspm);
975 static int hdspm_system_clock_mode(struct hdspm *hdspm);
976 static void hdspm_set_sgbuf(struct hdspm *hdspm,
977 struct snd_pcm_substream *substream,
978 unsigned int reg, int channels);
979
980 static inline int HDSPM_bit2freq(int n)
981 {
982 static const int bit2freq_tab[] = {
983 0, 32000, 44100, 48000, 64000, 88200,
984 96000, 128000, 176400, 192000 };
985 if (n < 1 || n > 9)
986 return 0;
987 return bit2freq_tab[n];
988 }
989
990 /* Write/read to/from HDSPM with Adresses in Bytes
991 not words but only 32Bit writes are allowed */
992
993 static inline void hdspm_write(struct hdspm * hdspm, unsigned int reg,
994 unsigned int val)
995 {
996 writel(val, hdspm->iobase + reg);
997 }
998
999 static inline unsigned int hdspm_read(struct hdspm * hdspm, unsigned int reg)
1000 {
1001 return readl(hdspm->iobase + reg);
1002 }
1003
1004 /* for each output channel (chan) I have an Input (in) and Playback (pb) Fader
1005 mixer is write only on hardware so we have to cache him for read
1006 each fader is a u32, but uses only the first 16 bit */
1007
1008 static inline int hdspm_read_in_gain(struct hdspm * hdspm, unsigned int chan,
1009 unsigned int in)
1010 {
1011 if (chan >= HDSPM_MIXER_CHANNELS || in >= HDSPM_MIXER_CHANNELS)
1012 return 0;
1013
1014 return hdspm->mixer->ch[chan].in[in];
1015 }
1016
1017 static inline int hdspm_read_pb_gain(struct hdspm * hdspm, unsigned int chan,
1018 unsigned int pb)
1019 {
1020 if (chan >= HDSPM_MIXER_CHANNELS || pb >= HDSPM_MIXER_CHANNELS)
1021 return 0;
1022 return hdspm->mixer->ch[chan].pb[pb];
1023 }
1024
1025 static int hdspm_write_in_gain(struct hdspm *hdspm, unsigned int chan,
1026 unsigned int in, unsigned short data)
1027 {
1028 if (chan >= HDSPM_MIXER_CHANNELS || in >= HDSPM_MIXER_CHANNELS)
1029 return -1;
1030
1031 hdspm_write(hdspm,
1032 HDSPM_MADI_mixerBase +
1033 ((in + 128 * chan) * sizeof(u32)),
1034 (hdspm->mixer->ch[chan].in[in] = data & 0xFFFF));
1035 return 0;
1036 }
1037
1038 static int hdspm_write_pb_gain(struct hdspm *hdspm, unsigned int chan,
1039 unsigned int pb, unsigned short data)
1040 {
1041 if (chan >= HDSPM_MIXER_CHANNELS || pb >= HDSPM_MIXER_CHANNELS)
1042 return -1;
1043
1044 hdspm_write(hdspm,
1045 HDSPM_MADI_mixerBase +
1046 ((64 + pb + 128 * chan) * sizeof(u32)),
1047 (hdspm->mixer->ch[chan].pb[pb] = data & 0xFFFF));
1048 return 0;
1049 }
1050
1051
1052 /* enable DMA for specific channels, now available for DSP-MADI */
1053 static inline void snd_hdspm_enable_in(struct hdspm * hdspm, int i, int v)
1054 {
1055 hdspm_write(hdspm, HDSPM_inputEnableBase + (4 * i), v);
1056 }
1057
1058 static inline void snd_hdspm_enable_out(struct hdspm * hdspm, int i, int v)
1059 {
1060 hdspm_write(hdspm, HDSPM_outputEnableBase + (4 * i), v);
1061 }
1062
1063 /* check if same process is writing and reading */
1064 static int snd_hdspm_use_is_exclusive(struct hdspm *hdspm)
1065 {
1066 unsigned long flags;
1067 int ret = 1;
1068
1069 spin_lock_irqsave(&hdspm->lock, flags);
1070 if ((hdspm->playback_pid != hdspm->capture_pid) &&
1071 (hdspm->playback_pid >= 0) && (hdspm->capture_pid >= 0)) {
1072 ret = 0;
1073 }
1074 spin_unlock_irqrestore(&hdspm->lock, flags);
1075 return ret;
1076 }
1077
1078 /* check for external sample rate */
1079 static int hdspm_external_sample_rate(struct hdspm *hdspm)
1080 {
1081 unsigned int status, status2, timecode;
1082 int syncref, rate = 0, rate_bits;
1083
1084 switch (hdspm->io_type) {
1085 case AES32:
1086 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
1087 status = hdspm_read(hdspm, HDSPM_statusRegister);
1088 timecode = hdspm_read(hdspm, HDSPM_timecodeRegister);
1089
1090 syncref = hdspm_autosync_ref(hdspm);
1091
1092 if (syncref == HDSPM_AES32_AUTOSYNC_FROM_WORD &&
1093 status & HDSPM_AES32_wcLock)
1094 return HDSPM_bit2freq((status >> HDSPM_AES32_wcFreq_bit) & 0xF);
1095
1096 if (syncref >= HDSPM_AES32_AUTOSYNC_FROM_AES1 &&
1097 syncref <= HDSPM_AES32_AUTOSYNC_FROM_AES8 &&
1098 status2 & (HDSPM_LockAES >>
1099 (syncref - HDSPM_AES32_AUTOSYNC_FROM_AES1)))
1100 return HDSPM_bit2freq((timecode >> (4*(syncref-HDSPM_AES32_AUTOSYNC_FROM_AES1))) & 0xF);
1101 return 0;
1102 break;
1103
1104 case MADIface:
1105 status = hdspm_read(hdspm, HDSPM_statusRegister);
1106
1107 if (!(status & HDSPM_madiLock)) {
1108 rate = 0; /* no lock */
1109 } else {
1110 switch (status & (HDSPM_status1_freqMask)) {
1111 case HDSPM_status1_F_0*1:
1112 rate = 32000; break;
1113 case HDSPM_status1_F_0*2:
1114 rate = 44100; break;
1115 case HDSPM_status1_F_0*3:
1116 rate = 48000; break;
1117 case HDSPM_status1_F_0*4:
1118 rate = 64000; break;
1119 case HDSPM_status1_F_0*5:
1120 rate = 88200; break;
1121 case HDSPM_status1_F_0*6:
1122 rate = 96000; break;
1123 case HDSPM_status1_F_0*7:
1124 rate = 128000; break;
1125 case HDSPM_status1_F_0*8:
1126 rate = 176400; break;
1127 case HDSPM_status1_F_0*9:
1128 rate = 192000; break;
1129 default:
1130 rate = 0; break;
1131 }
1132 }
1133
1134 break;
1135
1136 case MADI:
1137 case AIO:
1138 case RayDAT:
1139 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
1140 status = hdspm_read(hdspm, HDSPM_statusRegister);
1141 rate = 0;
1142
1143 /* if wordclock has synced freq and wordclock is valid */
1144 if ((status2 & HDSPM_wcLock) != 0 &&
1145 (status2 & HDSPM_SelSyncRef0) == 0) {
1146
1147 rate_bits = status2 & HDSPM_wcFreqMask;
1148
1149
1150 switch (rate_bits) {
1151 case HDSPM_wcFreq32:
1152 rate = 32000;
1153 break;
1154 case HDSPM_wcFreq44_1:
1155 rate = 44100;
1156 break;
1157 case HDSPM_wcFreq48:
1158 rate = 48000;
1159 break;
1160 case HDSPM_wcFreq64:
1161 rate = 64000;
1162 break;
1163 case HDSPM_wcFreq88_2:
1164 rate = 88200;
1165 break;
1166 case HDSPM_wcFreq96:
1167 rate = 96000;
1168 break;
1169 default:
1170 rate = 0;
1171 break;
1172 }
1173 }
1174
1175 /* if rate detected and Syncref is Word than have it,
1176 * word has priority to MADI
1177 */
1178 if (rate != 0 &&
1179 (status2 & HDSPM_SelSyncRefMask) == HDSPM_SelSyncRef_WORD)
1180 return rate;
1181
1182 /* maybe a madi input (which is taken if sel sync is madi) */
1183 if (status & HDSPM_madiLock) {
1184 rate_bits = status & HDSPM_madiFreqMask;
1185
1186 switch (rate_bits) {
1187 case HDSPM_madiFreq32:
1188 rate = 32000;
1189 break;
1190 case HDSPM_madiFreq44_1:
1191 rate = 44100;
1192 break;
1193 case HDSPM_madiFreq48:
1194 rate = 48000;
1195 break;
1196 case HDSPM_madiFreq64:
1197 rate = 64000;
1198 break;
1199 case HDSPM_madiFreq88_2:
1200 rate = 88200;
1201 break;
1202 case HDSPM_madiFreq96:
1203 rate = 96000;
1204 break;
1205 case HDSPM_madiFreq128:
1206 rate = 128000;
1207 break;
1208 case HDSPM_madiFreq176_4:
1209 rate = 176400;
1210 break;
1211 case HDSPM_madiFreq192:
1212 rate = 192000;
1213 break;
1214 default:
1215 rate = 0;
1216 break;
1217 }
1218
1219 /* QS and DS rates normally can not be detected
1220 * automatically by the card. Only exception is MADI
1221 * in 96k frame mode.
1222 *
1223 * So if we read SS values (32 .. 48k), check for
1224 * user-provided DS/QS bits in the control register
1225 * and multiply the base frequency accordingly.
1226 */
1227 if (rate <= 48000) {
1228 if (hdspm->control_register & HDSPM_QuadSpeed)
1229 rate *= 4;
1230 else if (hdspm->control_register &
1231 HDSPM_DoubleSpeed)
1232 rate *= 2;
1233 }
1234 }
1235 break;
1236 }
1237
1238 return rate;
1239 }
1240
1241 /* return latency in samples per period */
1242 static int hdspm_get_latency(struct hdspm *hdspm)
1243 {
1244 int n;
1245
1246 n = hdspm_decode_latency(hdspm->control_register);
1247
1248 /* Special case for new RME cards with 32 samples period size.
1249 * The three latency bits in the control register
1250 * (HDSP_LatencyMask) encode latency values of 64 samples as
1251 * 0, 128 samples as 1 ... 4096 samples as 6. For old cards, 7
1252 * denotes 8192 samples, but on new cards like RayDAT or AIO,
1253 * it corresponds to 32 samples.
1254 */
1255 if ((7 == n) && (RayDAT == hdspm->io_type || AIO == hdspm->io_type))
1256 n = -1;
1257
1258 return 1 << (n + 6);
1259 }
1260
1261 /* Latency function */
1262 static inline void hdspm_compute_period_size(struct hdspm *hdspm)
1263 {
1264 hdspm->period_bytes = 4 * hdspm_get_latency(hdspm);
1265 }
1266
1267
1268 static snd_pcm_uframes_t hdspm_hw_pointer(struct hdspm *hdspm)
1269 {
1270 int position;
1271
1272 position = hdspm_read(hdspm, HDSPM_statusRegister);
1273
1274 switch (hdspm->io_type) {
1275 case RayDAT:
1276 case AIO:
1277 position &= HDSPM_BufferPositionMask;
1278 position /= 4; /* Bytes per sample */
1279 break;
1280 default:
1281 position = (position & HDSPM_BufferID) ?
1282 (hdspm->period_bytes / 4) : 0;
1283 }
1284
1285 return position;
1286 }
1287
1288
1289 static inline void hdspm_start_audio(struct hdspm * s)
1290 {
1291 s->control_register |= (HDSPM_AudioInterruptEnable | HDSPM_Start);
1292 hdspm_write(s, HDSPM_controlRegister, s->control_register);
1293 }
1294
1295 static inline void hdspm_stop_audio(struct hdspm * s)
1296 {
1297 s->control_register &= ~(HDSPM_Start | HDSPM_AudioInterruptEnable);
1298 hdspm_write(s, HDSPM_controlRegister, s->control_register);
1299 }
1300
1301 /* should I silence all or only opened ones ? doit all for first even is 4MB*/
1302 static void hdspm_silence_playback(struct hdspm *hdspm)
1303 {
1304 int i;
1305 int n = hdspm->period_bytes;
1306 void *buf = hdspm->playback_buffer;
1307
1308 if (buf == NULL)
1309 return;
1310
1311 for (i = 0; i < HDSPM_MAX_CHANNELS; i++) {
1312 memset(buf, 0, n);
1313 buf += HDSPM_CHANNEL_BUFFER_BYTES;
1314 }
1315 }
1316
1317 static int hdspm_set_interrupt_interval(struct hdspm *s, unsigned int frames)
1318 {
1319 int n;
1320
1321 spin_lock_irq(&s->lock);
1322
1323 if (32 == frames) {
1324 /* Special case for new RME cards like RayDAT/AIO which
1325 * support period sizes of 32 samples. Since latency is
1326 * encoded in the three bits of HDSP_LatencyMask, we can only
1327 * have values from 0 .. 7. While 0 still means 64 samples and
1328 * 6 represents 4096 samples on all cards, 7 represents 8192
1329 * on older cards and 32 samples on new cards.
1330 *
1331 * In other words, period size in samples is calculated by
1332 * 2^(n+6) with n ranging from 0 .. 7.
1333 */
1334 n = 7;
1335 } else {
1336 frames >>= 7;
1337 n = 0;
1338 while (frames) {
1339 n++;
1340 frames >>= 1;
1341 }
1342 }
1343
1344 s->control_register &= ~HDSPM_LatencyMask;
1345 s->control_register |= hdspm_encode_latency(n);
1346
1347 hdspm_write(s, HDSPM_controlRegister, s->control_register);
1348
1349 hdspm_compute_period_size(s);
1350
1351 spin_unlock_irq(&s->lock);
1352
1353 return 0;
1354 }
1355
1356 static u64 hdspm_calc_dds_value(struct hdspm *hdspm, u64 period)
1357 {
1358 u64 freq_const;
1359
1360 if (period == 0)
1361 return 0;
1362
1363 switch (hdspm->io_type) {
1364 case MADI:
1365 case AES32:
1366 freq_const = 110069313433624ULL;
1367 break;
1368 case RayDAT:
1369 case AIO:
1370 freq_const = 104857600000000ULL;
1371 break;
1372 case MADIface:
1373 freq_const = 131072000000000ULL;
1374 break;
1375 default:
1376 snd_BUG();
1377 return 0;
1378 }
1379
1380 return div_u64(freq_const, period);
1381 }
1382
1383
1384 static void hdspm_set_dds_value(struct hdspm *hdspm, int rate)
1385 {
1386 u64 n;
1387
1388 if (rate >= 112000)
1389 rate /= 4;
1390 else if (rate >= 56000)
1391 rate /= 2;
1392
1393 switch (hdspm->io_type) {
1394 case MADIface:
1395 n = 131072000000000ULL; /* 125 MHz */
1396 break;
1397 case MADI:
1398 case AES32:
1399 n = 110069313433624ULL; /* 105 MHz */
1400 break;
1401 case RayDAT:
1402 case AIO:
1403 n = 104857600000000ULL; /* 100 MHz */
1404 break;
1405 default:
1406 snd_BUG();
1407 return;
1408 }
1409
1410 n = div_u64(n, rate);
1411 /* n should be less than 2^32 for being written to FREQ register */
1412 snd_BUG_ON(n >> 32);
1413 hdspm_write(hdspm, HDSPM_freqReg, (u32)n);
1414 }
1415
1416 /* dummy set rate lets see what happens */
1417 static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally)
1418 {
1419 int current_rate;
1420 int rate_bits;
1421 int not_set = 0;
1422 int current_speed, target_speed;
1423
1424 /* ASSUMPTION: hdspm->lock is either set, or there is no need for
1425 it (e.g. during module initialization).
1426 */
1427
1428 if (!(hdspm->control_register & HDSPM_ClockModeMaster)) {
1429
1430 /* SLAVE --- */
1431 if (called_internally) {
1432
1433 /* request from ctl or card initialization
1434 just make a warning an remember setting
1435 for future master mode switching */
1436
1437 snd_printk(KERN_WARNING "HDSPM: "
1438 "Warning: device is not running "
1439 "as a clock master.\n");
1440 not_set = 1;
1441 } else {
1442
1443 /* hw_param request while in AutoSync mode */
1444 int external_freq =
1445 hdspm_external_sample_rate(hdspm);
1446
1447 if (hdspm_autosync_ref(hdspm) ==
1448 HDSPM_AUTOSYNC_FROM_NONE) {
1449
1450 snd_printk(KERN_WARNING "HDSPM: "
1451 "Detected no Externel Sync \n");
1452 not_set = 1;
1453
1454 } else if (rate != external_freq) {
1455
1456 snd_printk(KERN_WARNING "HDSPM: "
1457 "Warning: No AutoSync source for "
1458 "requested rate\n");
1459 not_set = 1;
1460 }
1461 }
1462 }
1463
1464 current_rate = hdspm->system_sample_rate;
1465
1466 /* Changing between Singe, Double and Quad speed is not
1467 allowed if any substreams are open. This is because such a change
1468 causes a shift in the location of the DMA buffers and a reduction
1469 in the number of available buffers.
1470
1471 Note that a similar but essentially insoluble problem exists for
1472 externally-driven rate changes. All we can do is to flag rate
1473 changes in the read/write routines.
1474 */
1475
1476 if (current_rate <= 48000)
1477 current_speed = HDSPM_SPEED_SINGLE;
1478 else if (current_rate <= 96000)
1479 current_speed = HDSPM_SPEED_DOUBLE;
1480 else
1481 current_speed = HDSPM_SPEED_QUAD;
1482
1483 if (rate <= 48000)
1484 target_speed = HDSPM_SPEED_SINGLE;
1485 else if (rate <= 96000)
1486 target_speed = HDSPM_SPEED_DOUBLE;
1487 else
1488 target_speed = HDSPM_SPEED_QUAD;
1489
1490 switch (rate) {
1491 case 32000:
1492 rate_bits = HDSPM_Frequency32KHz;
1493 break;
1494 case 44100:
1495 rate_bits = HDSPM_Frequency44_1KHz;
1496 break;
1497 case 48000:
1498 rate_bits = HDSPM_Frequency48KHz;
1499 break;
1500 case 64000:
1501 rate_bits = HDSPM_Frequency64KHz;
1502 break;
1503 case 88200:
1504 rate_bits = HDSPM_Frequency88_2KHz;
1505 break;
1506 case 96000:
1507 rate_bits = HDSPM_Frequency96KHz;
1508 break;
1509 case 128000:
1510 rate_bits = HDSPM_Frequency128KHz;
1511 break;
1512 case 176400:
1513 rate_bits = HDSPM_Frequency176_4KHz;
1514 break;
1515 case 192000:
1516 rate_bits = HDSPM_Frequency192KHz;
1517 break;
1518 default:
1519 return -EINVAL;
1520 }
1521
1522 if (current_speed != target_speed
1523 && (hdspm->capture_pid >= 0 || hdspm->playback_pid >= 0)) {
1524 snd_printk
1525 (KERN_ERR "HDSPM: "
1526 "cannot change from %s speed to %s speed mode "
1527 "(capture PID = %d, playback PID = %d)\n",
1528 hdspm_speed_names[current_speed],
1529 hdspm_speed_names[target_speed],
1530 hdspm->capture_pid, hdspm->playback_pid);
1531 return -EBUSY;
1532 }
1533
1534 hdspm->control_register &= ~HDSPM_FrequencyMask;
1535 hdspm->control_register |= rate_bits;
1536 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1537
1538 /* For AES32, need to set DDS value in FREQ register
1539 For MADI, also apparently */
1540 hdspm_set_dds_value(hdspm, rate);
1541
1542 if (AES32 == hdspm->io_type && rate != current_rate)
1543 hdspm_write(hdspm, HDSPM_eeprom_wr, 0);
1544
1545 hdspm->system_sample_rate = rate;
1546
1547 if (rate <= 48000) {
1548 hdspm->channel_map_in = hdspm->channel_map_in_ss;
1549 hdspm->channel_map_out = hdspm->channel_map_out_ss;
1550 hdspm->max_channels_in = hdspm->ss_in_channels;
1551 hdspm->max_channels_out = hdspm->ss_out_channels;
1552 hdspm->port_names_in = hdspm->port_names_in_ss;
1553 hdspm->port_names_out = hdspm->port_names_out_ss;
1554 } else if (rate <= 96000) {
1555 hdspm->channel_map_in = hdspm->channel_map_in_ds;
1556 hdspm->channel_map_out = hdspm->channel_map_out_ds;
1557 hdspm->max_channels_in = hdspm->ds_in_channels;
1558 hdspm->max_channels_out = hdspm->ds_out_channels;
1559 hdspm->port_names_in = hdspm->port_names_in_ds;
1560 hdspm->port_names_out = hdspm->port_names_out_ds;
1561 } else {
1562 hdspm->channel_map_in = hdspm->channel_map_in_qs;
1563 hdspm->channel_map_out = hdspm->channel_map_out_qs;
1564 hdspm->max_channels_in = hdspm->qs_in_channels;
1565 hdspm->max_channels_out = hdspm->qs_out_channels;
1566 hdspm->port_names_in = hdspm->port_names_in_qs;
1567 hdspm->port_names_out = hdspm->port_names_out_qs;
1568 }
1569
1570 if (not_set != 0)
1571 return -1;
1572
1573 return 0;
1574 }
1575
1576 /* mainly for init to 0 on load */
1577 static void all_in_all_mixer(struct hdspm * hdspm, int sgain)
1578 {
1579 int i, j;
1580 unsigned int gain;
1581
1582 if (sgain > UNITY_GAIN)
1583 gain = UNITY_GAIN;
1584 else if (sgain < 0)
1585 gain = 0;
1586 else
1587 gain = sgain;
1588
1589 for (i = 0; i < HDSPM_MIXER_CHANNELS; i++)
1590 for (j = 0; j < HDSPM_MIXER_CHANNELS; j++) {
1591 hdspm_write_in_gain(hdspm, i, j, gain);
1592 hdspm_write_pb_gain(hdspm, i, j, gain);
1593 }
1594 }
1595
1596 /*----------------------------------------------------------------------------
1597 MIDI
1598 ----------------------------------------------------------------------------*/
1599
1600 static inline unsigned char snd_hdspm_midi_read_byte (struct hdspm *hdspm,
1601 int id)
1602 {
1603 /* the hardware already does the relevant bit-mask with 0xff */
1604 return hdspm_read(hdspm, hdspm->midi[id].dataIn);
1605 }
1606
1607 static inline void snd_hdspm_midi_write_byte (struct hdspm *hdspm, int id,
1608 int val)
1609 {
1610 /* the hardware already does the relevant bit-mask with 0xff */
1611 return hdspm_write(hdspm, hdspm->midi[id].dataOut, val);
1612 }
1613
1614 static inline int snd_hdspm_midi_input_available (struct hdspm *hdspm, int id)
1615 {
1616 return hdspm_read(hdspm, hdspm->midi[id].statusIn) & 0xFF;
1617 }
1618
1619 static inline int snd_hdspm_midi_output_possible (struct hdspm *hdspm, int id)
1620 {
1621 int fifo_bytes_used;
1622
1623 fifo_bytes_used = hdspm_read(hdspm, hdspm->midi[id].statusOut) & 0xFF;
1624
1625 if (fifo_bytes_used < 128)
1626 return 128 - fifo_bytes_used;
1627 else
1628 return 0;
1629 }
1630
1631 static void snd_hdspm_flush_midi_input(struct hdspm *hdspm, int id)
1632 {
1633 while (snd_hdspm_midi_input_available (hdspm, id))
1634 snd_hdspm_midi_read_byte (hdspm, id);
1635 }
1636
1637 static int snd_hdspm_midi_output_write (struct hdspm_midi *hmidi)
1638 {
1639 unsigned long flags;
1640 int n_pending;
1641 int to_write;
1642 int i;
1643 unsigned char buf[128];
1644
1645 /* Output is not interrupt driven */
1646
1647 spin_lock_irqsave (&hmidi->lock, flags);
1648 if (hmidi->output &&
1649 !snd_rawmidi_transmit_empty (hmidi->output)) {
1650 n_pending = snd_hdspm_midi_output_possible (hmidi->hdspm,
1651 hmidi->id);
1652 if (n_pending > 0) {
1653 if (n_pending > (int)sizeof (buf))
1654 n_pending = sizeof (buf);
1655
1656 to_write = snd_rawmidi_transmit (hmidi->output, buf,
1657 n_pending);
1658 if (to_write > 0) {
1659 for (i = 0; i < to_write; ++i)
1660 snd_hdspm_midi_write_byte (hmidi->hdspm,
1661 hmidi->id,
1662 buf[i]);
1663 }
1664 }
1665 }
1666 spin_unlock_irqrestore (&hmidi->lock, flags);
1667 return 0;
1668 }
1669
1670 static int snd_hdspm_midi_input_read (struct hdspm_midi *hmidi)
1671 {
1672 unsigned char buf[128]; /* this buffer is designed to match the MIDI
1673 * input FIFO size
1674 */
1675 unsigned long flags;
1676 int n_pending;
1677 int i;
1678
1679 spin_lock_irqsave (&hmidi->lock, flags);
1680 n_pending = snd_hdspm_midi_input_available (hmidi->hdspm, hmidi->id);
1681 if (n_pending > 0) {
1682 if (hmidi->input) {
1683 if (n_pending > (int)sizeof (buf))
1684 n_pending = sizeof (buf);
1685 for (i = 0; i < n_pending; ++i)
1686 buf[i] = snd_hdspm_midi_read_byte (hmidi->hdspm,
1687 hmidi->id);
1688 if (n_pending)
1689 snd_rawmidi_receive (hmidi->input, buf,
1690 n_pending);
1691 } else {
1692 /* flush the MIDI input FIFO */
1693 while (n_pending--)
1694 snd_hdspm_midi_read_byte (hmidi->hdspm,
1695 hmidi->id);
1696 }
1697 }
1698 hmidi->pending = 0;
1699 spin_unlock_irqrestore(&hmidi->lock, flags);
1700
1701 spin_lock_irqsave(&hmidi->hdspm->lock, flags);
1702 hmidi->hdspm->control_register |= hmidi->ie;
1703 hdspm_write(hmidi->hdspm, HDSPM_controlRegister,
1704 hmidi->hdspm->control_register);
1705 spin_unlock_irqrestore(&hmidi->hdspm->lock, flags);
1706
1707 return snd_hdspm_midi_output_write (hmidi);
1708 }
1709
1710 static void
1711 snd_hdspm_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
1712 {
1713 struct hdspm *hdspm;
1714 struct hdspm_midi *hmidi;
1715 unsigned long flags;
1716
1717 hmidi = substream->rmidi->private_data;
1718 hdspm = hmidi->hdspm;
1719
1720 spin_lock_irqsave (&hdspm->lock, flags);
1721 if (up) {
1722 if (!(hdspm->control_register & hmidi->ie)) {
1723 snd_hdspm_flush_midi_input (hdspm, hmidi->id);
1724 hdspm->control_register |= hmidi->ie;
1725 }
1726 } else {
1727 hdspm->control_register &= ~hmidi->ie;
1728 }
1729
1730 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1731 spin_unlock_irqrestore (&hdspm->lock, flags);
1732 }
1733
1734 static void snd_hdspm_midi_output_timer(unsigned long data)
1735 {
1736 struct hdspm_midi *hmidi = (struct hdspm_midi *) data;
1737 unsigned long flags;
1738
1739 snd_hdspm_midi_output_write(hmidi);
1740 spin_lock_irqsave (&hmidi->lock, flags);
1741
1742 /* this does not bump hmidi->istimer, because the
1743 kernel automatically removed the timer when it
1744 expired, and we are now adding it back, thus
1745 leaving istimer wherever it was set before.
1746 */
1747
1748 if (hmidi->istimer) {
1749 hmidi->timer.expires = 1 + jiffies;
1750 add_timer(&hmidi->timer);
1751 }
1752
1753 spin_unlock_irqrestore (&hmidi->lock, flags);
1754 }
1755
1756 static void
1757 snd_hdspm_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
1758 {
1759 struct hdspm_midi *hmidi;
1760 unsigned long flags;
1761
1762 hmidi = substream->rmidi->private_data;
1763 spin_lock_irqsave (&hmidi->lock, flags);
1764 if (up) {
1765 if (!hmidi->istimer) {
1766 init_timer(&hmidi->timer);
1767 hmidi->timer.function = snd_hdspm_midi_output_timer;
1768 hmidi->timer.data = (unsigned long) hmidi;
1769 hmidi->timer.expires = 1 + jiffies;
1770 add_timer(&hmidi->timer);
1771 hmidi->istimer++;
1772 }
1773 } else {
1774 if (hmidi->istimer && --hmidi->istimer <= 0)
1775 del_timer (&hmidi->timer);
1776 }
1777 spin_unlock_irqrestore (&hmidi->lock, flags);
1778 if (up)
1779 snd_hdspm_midi_output_write(hmidi);
1780 }
1781
1782 static int snd_hdspm_midi_input_open(struct snd_rawmidi_substream *substream)
1783 {
1784 struct hdspm_midi *hmidi;
1785
1786 hmidi = substream->rmidi->private_data;
1787 spin_lock_irq (&hmidi->lock);
1788 snd_hdspm_flush_midi_input (hmidi->hdspm, hmidi->id);
1789 hmidi->input = substream;
1790 spin_unlock_irq (&hmidi->lock);
1791
1792 return 0;
1793 }
1794
1795 static int snd_hdspm_midi_output_open(struct snd_rawmidi_substream *substream)
1796 {
1797 struct hdspm_midi *hmidi;
1798
1799 hmidi = substream->rmidi->private_data;
1800 spin_lock_irq (&hmidi->lock);
1801 hmidi->output = substream;
1802 spin_unlock_irq (&hmidi->lock);
1803
1804 return 0;
1805 }
1806
1807 static int snd_hdspm_midi_input_close(struct snd_rawmidi_substream *substream)
1808 {
1809 struct hdspm_midi *hmidi;
1810
1811 snd_hdspm_midi_input_trigger (substream, 0);
1812
1813 hmidi = substream->rmidi->private_data;
1814 spin_lock_irq (&hmidi->lock);
1815 hmidi->input = NULL;
1816 spin_unlock_irq (&hmidi->lock);
1817
1818 return 0;
1819 }
1820
1821 static int snd_hdspm_midi_output_close(struct snd_rawmidi_substream *substream)
1822 {
1823 struct hdspm_midi *hmidi;
1824
1825 snd_hdspm_midi_output_trigger (substream, 0);
1826
1827 hmidi = substream->rmidi->private_data;
1828 spin_lock_irq (&hmidi->lock);
1829 hmidi->output = NULL;
1830 spin_unlock_irq (&hmidi->lock);
1831
1832 return 0;
1833 }
1834
1835 static struct snd_rawmidi_ops snd_hdspm_midi_output =
1836 {
1837 .open = snd_hdspm_midi_output_open,
1838 .close = snd_hdspm_midi_output_close,
1839 .trigger = snd_hdspm_midi_output_trigger,
1840 };
1841
1842 static struct snd_rawmidi_ops snd_hdspm_midi_input =
1843 {
1844 .open = snd_hdspm_midi_input_open,
1845 .close = snd_hdspm_midi_input_close,
1846 .trigger = snd_hdspm_midi_input_trigger,
1847 };
1848
1849 static int snd_hdspm_create_midi(struct snd_card *card,
1850 struct hdspm *hdspm, int id)
1851 {
1852 int err;
1853 char buf[32];
1854
1855 hdspm->midi[id].id = id;
1856 hdspm->midi[id].hdspm = hdspm;
1857 spin_lock_init (&hdspm->midi[id].lock);
1858
1859 if (0 == id) {
1860 if (MADIface == hdspm->io_type) {
1861 /* MIDI-over-MADI on HDSPe MADIface */
1862 hdspm->midi[0].dataIn = HDSPM_midiDataIn2;
1863 hdspm->midi[0].statusIn = HDSPM_midiStatusIn2;
1864 hdspm->midi[0].dataOut = HDSPM_midiDataOut2;
1865 hdspm->midi[0].statusOut = HDSPM_midiStatusOut2;
1866 hdspm->midi[0].ie = HDSPM_Midi2InterruptEnable;
1867 hdspm->midi[0].irq = HDSPM_midi2IRQPending;
1868 } else {
1869 hdspm->midi[0].dataIn = HDSPM_midiDataIn0;
1870 hdspm->midi[0].statusIn = HDSPM_midiStatusIn0;
1871 hdspm->midi[0].dataOut = HDSPM_midiDataOut0;
1872 hdspm->midi[0].statusOut = HDSPM_midiStatusOut0;
1873 hdspm->midi[0].ie = HDSPM_Midi0InterruptEnable;
1874 hdspm->midi[0].irq = HDSPM_midi0IRQPending;
1875 }
1876 } else if (1 == id) {
1877 hdspm->midi[1].dataIn = HDSPM_midiDataIn1;
1878 hdspm->midi[1].statusIn = HDSPM_midiStatusIn1;
1879 hdspm->midi[1].dataOut = HDSPM_midiDataOut1;
1880 hdspm->midi[1].statusOut = HDSPM_midiStatusOut1;
1881 hdspm->midi[1].ie = HDSPM_Midi1InterruptEnable;
1882 hdspm->midi[1].irq = HDSPM_midi1IRQPending;
1883 } else if ((2 == id) && (MADI == hdspm->io_type)) {
1884 /* MIDI-over-MADI on HDSPe MADI */
1885 hdspm->midi[2].dataIn = HDSPM_midiDataIn2;
1886 hdspm->midi[2].statusIn = HDSPM_midiStatusIn2;
1887 hdspm->midi[2].dataOut = HDSPM_midiDataOut2;
1888 hdspm->midi[2].statusOut = HDSPM_midiStatusOut2;
1889 hdspm->midi[2].ie = HDSPM_Midi2InterruptEnable;
1890 hdspm->midi[2].irq = HDSPM_midi2IRQPending;
1891 } else if (2 == id) {
1892 /* TCO MTC, read only */
1893 hdspm->midi[2].dataIn = HDSPM_midiDataIn2;
1894 hdspm->midi[2].statusIn = HDSPM_midiStatusIn2;
1895 hdspm->midi[2].dataOut = -1;
1896 hdspm->midi[2].statusOut = -1;
1897 hdspm->midi[2].ie = HDSPM_Midi2InterruptEnable;
1898 hdspm->midi[2].irq = HDSPM_midi2IRQPendingAES;
1899 } else if (3 == id) {
1900 /* TCO MTC on HDSPe MADI */
1901 hdspm->midi[3].dataIn = HDSPM_midiDataIn3;
1902 hdspm->midi[3].statusIn = HDSPM_midiStatusIn3;
1903 hdspm->midi[3].dataOut = -1;
1904 hdspm->midi[3].statusOut = -1;
1905 hdspm->midi[3].ie = HDSPM_Midi3InterruptEnable;
1906 hdspm->midi[3].irq = HDSPM_midi3IRQPending;
1907 }
1908
1909 if ((id < 2) || ((2 == id) && ((MADI == hdspm->io_type) ||
1910 (MADIface == hdspm->io_type)))) {
1911 if ((id == 0) && (MADIface == hdspm->io_type)) {
1912 sprintf(buf, "%s MIDIoverMADI", card->shortname);
1913 } else if ((id == 2) && (MADI == hdspm->io_type)) {
1914 sprintf(buf, "%s MIDIoverMADI", card->shortname);
1915 } else {
1916 sprintf(buf, "%s MIDI %d", card->shortname, id+1);
1917 }
1918 err = snd_rawmidi_new(card, buf, id, 1, 1,
1919 &hdspm->midi[id].rmidi);
1920 if (err < 0)
1921 return err;
1922
1923 sprintf(hdspm->midi[id].rmidi->name, "%s MIDI %d",
1924 card->id, id+1);
1925 hdspm->midi[id].rmidi->private_data = &hdspm->midi[id];
1926
1927 snd_rawmidi_set_ops(hdspm->midi[id].rmidi,
1928 SNDRV_RAWMIDI_STREAM_OUTPUT,
1929 &snd_hdspm_midi_output);
1930 snd_rawmidi_set_ops(hdspm->midi[id].rmidi,
1931 SNDRV_RAWMIDI_STREAM_INPUT,
1932 &snd_hdspm_midi_input);
1933
1934 hdspm->midi[id].rmidi->info_flags |=
1935 SNDRV_RAWMIDI_INFO_OUTPUT |
1936 SNDRV_RAWMIDI_INFO_INPUT |
1937 SNDRV_RAWMIDI_INFO_DUPLEX;
1938 } else {
1939 /* TCO MTC, read only */
1940 sprintf(buf, "%s MTC %d", card->shortname, id+1);
1941 err = snd_rawmidi_new(card, buf, id, 1, 1,
1942 &hdspm->midi[id].rmidi);
1943 if (err < 0)
1944 return err;
1945
1946 sprintf(hdspm->midi[id].rmidi->name,
1947 "%s MTC %d", card->id, id+1);
1948 hdspm->midi[id].rmidi->private_data = &hdspm->midi[id];
1949
1950 snd_rawmidi_set_ops(hdspm->midi[id].rmidi,
1951 SNDRV_RAWMIDI_STREAM_INPUT,
1952 &snd_hdspm_midi_input);
1953
1954 hdspm->midi[id].rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
1955 }
1956
1957 return 0;
1958 }
1959
1960
1961 static void hdspm_midi_tasklet(unsigned long arg)
1962 {
1963 struct hdspm *hdspm = (struct hdspm *)arg;
1964 int i = 0;
1965
1966 while (i < hdspm->midiPorts) {
1967 if (hdspm->midi[i].pending)
1968 snd_hdspm_midi_input_read(&hdspm->midi[i]);
1969
1970 i++;
1971 }
1972 }
1973
1974
1975 /*-----------------------------------------------------------------------------
1976 Status Interface
1977 ----------------------------------------------------------------------------*/
1978
1979 /* get the system sample rate which is set */
1980
1981
1982 /**
1983 * Calculate the real sample rate from the
1984 * current DDS value.
1985 **/
1986 static int hdspm_get_system_sample_rate(struct hdspm *hdspm)
1987 {
1988 unsigned int period, rate;
1989
1990 period = hdspm_read(hdspm, HDSPM_RD_PLL_FREQ);
1991 rate = hdspm_calc_dds_value(hdspm, period);
1992
1993 if (rate > 207000) {
1994 /* Unreasonable high sample rate as seen on PCI MADI cards. */
1995 if (0 == hdspm_system_clock_mode(hdspm)) {
1996 /* master mode, return internal sample rate */
1997 rate = hdspm->system_sample_rate;
1998 } else {
1999 /* slave mode, return external sample rate */
2000 rate = hdspm_external_sample_rate(hdspm);
2001 }
2002 }
2003
2004 return rate;
2005 }
2006
2007
2008 #define HDSPM_SYSTEM_SAMPLE_RATE(xname, xindex) \
2009 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2010 .name = xname, \
2011 .index = xindex, \
2012 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
2013 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2014 .info = snd_hdspm_info_system_sample_rate, \
2015 .put = snd_hdspm_put_system_sample_rate, \
2016 .get = snd_hdspm_get_system_sample_rate \
2017 }
2018
2019 static int snd_hdspm_info_system_sample_rate(struct snd_kcontrol *kcontrol,
2020 struct snd_ctl_elem_info *uinfo)
2021 {
2022 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2023 uinfo->count = 1;
2024 uinfo->value.integer.min = 27000;
2025 uinfo->value.integer.max = 207000;
2026 uinfo->value.integer.step = 1;
2027 return 0;
2028 }
2029
2030
2031 static int snd_hdspm_get_system_sample_rate(struct snd_kcontrol *kcontrol,
2032 struct snd_ctl_elem_value *
2033 ucontrol)
2034 {
2035 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2036
2037 ucontrol->value.integer.value[0] = hdspm_get_system_sample_rate(hdspm);
2038 return 0;
2039 }
2040
2041 static int snd_hdspm_put_system_sample_rate(struct snd_kcontrol *kcontrol,
2042 struct snd_ctl_elem_value *
2043 ucontrol)
2044 {
2045 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2046
2047 hdspm_set_dds_value(hdspm, ucontrol->value.enumerated.item[0]);
2048 return 0;
2049 }
2050
2051
2052 /**
2053 * Returns the WordClock sample rate class for the given card.
2054 **/
2055 static int hdspm_get_wc_sample_rate(struct hdspm *hdspm)
2056 {
2057 int status;
2058
2059 switch (hdspm->io_type) {
2060 case RayDAT:
2061 case AIO:
2062 status = hdspm_read(hdspm, HDSPM_RD_STATUS_1);
2063 return (status >> 16) & 0xF;
2064 break;
2065 default:
2066 break;
2067 }
2068
2069
2070 return 0;
2071 }
2072
2073
2074 /**
2075 * Returns the TCO sample rate class for the given card.
2076 **/
2077 static int hdspm_get_tco_sample_rate(struct hdspm *hdspm)
2078 {
2079 int status;
2080
2081 if (hdspm->tco) {
2082 switch (hdspm->io_type) {
2083 case RayDAT:
2084 case AIO:
2085 status = hdspm_read(hdspm, HDSPM_RD_STATUS_1);
2086 return (status >> 20) & 0xF;
2087 break;
2088 default:
2089 break;
2090 }
2091 }
2092
2093 return 0;
2094 }
2095
2096
2097 /**
2098 * Returns the SYNC_IN sample rate class for the given card.
2099 **/
2100 static int hdspm_get_sync_in_sample_rate(struct hdspm *hdspm)
2101 {
2102 int status;
2103
2104 if (hdspm->tco) {
2105 switch (hdspm->io_type) {
2106 case RayDAT:
2107 case AIO:
2108 status = hdspm_read(hdspm, HDSPM_RD_STATUS_2);
2109 return (status >> 12) & 0xF;
2110 break;
2111 default:
2112 break;
2113 }
2114 }
2115
2116 return 0;
2117 }
2118
2119
2120 /**
2121 * Returns the sample rate class for input source <idx> for
2122 * 'new style' cards like the AIO and RayDAT.
2123 **/
2124 static int hdspm_get_s1_sample_rate(struct hdspm *hdspm, unsigned int idx)
2125 {
2126 int status = hdspm_read(hdspm, HDSPM_RD_STATUS_2);
2127
2128 return (status >> (idx*4)) & 0xF;
2129 }
2130
2131
2132
2133 #define HDSPM_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
2134 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2135 .name = xname, \
2136 .private_value = xindex, \
2137 .access = SNDRV_CTL_ELEM_ACCESS_READ, \
2138 .info = snd_hdspm_info_autosync_sample_rate, \
2139 .get = snd_hdspm_get_autosync_sample_rate \
2140 }
2141
2142
2143 static int snd_hdspm_info_autosync_sample_rate(struct snd_kcontrol *kcontrol,
2144 struct snd_ctl_elem_info *uinfo)
2145 {
2146 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2147 uinfo->count = 1;
2148 uinfo->value.enumerated.items = 10;
2149
2150 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2151 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2152 strcpy(uinfo->value.enumerated.name,
2153 texts_freq[uinfo->value.enumerated.item]);
2154 return 0;
2155 }
2156
2157
2158 static int snd_hdspm_get_autosync_sample_rate(struct snd_kcontrol *kcontrol,
2159 struct snd_ctl_elem_value *
2160 ucontrol)
2161 {
2162 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2163
2164 switch (hdspm->io_type) {
2165 case RayDAT:
2166 switch (kcontrol->private_value) {
2167 case 0:
2168 ucontrol->value.enumerated.item[0] =
2169 hdspm_get_wc_sample_rate(hdspm);
2170 break;
2171 case 7:
2172 ucontrol->value.enumerated.item[0] =
2173 hdspm_get_tco_sample_rate(hdspm);
2174 break;
2175 case 8:
2176 ucontrol->value.enumerated.item[0] =
2177 hdspm_get_sync_in_sample_rate(hdspm);
2178 break;
2179 default:
2180 ucontrol->value.enumerated.item[0] =
2181 hdspm_get_s1_sample_rate(hdspm,
2182 kcontrol->private_value-1);
2183 }
2184 break;
2185
2186 case AIO:
2187 switch (kcontrol->private_value) {
2188 case 0: /* WC */
2189 ucontrol->value.enumerated.item[0] =
2190 hdspm_get_wc_sample_rate(hdspm);
2191 break;
2192 case 4: /* TCO */
2193 ucontrol->value.enumerated.item[0] =
2194 hdspm_get_tco_sample_rate(hdspm);
2195 break;
2196 case 5: /* SYNC_IN */
2197 ucontrol->value.enumerated.item[0] =
2198 hdspm_get_sync_in_sample_rate(hdspm);
2199 break;
2200 default:
2201 ucontrol->value.enumerated.item[0] =
2202 hdspm_get_s1_sample_rate(hdspm,
2203 ucontrol->id.index-1);
2204 }
2205 break;
2206
2207 case AES32:
2208
2209 switch (kcontrol->private_value) {
2210 case 0: /* WC */
2211 ucontrol->value.enumerated.item[0] =
2212 hdspm_get_wc_sample_rate(hdspm);
2213 break;
2214 case 9: /* TCO */
2215 ucontrol->value.enumerated.item[0] =
2216 hdspm_get_tco_sample_rate(hdspm);
2217 break;
2218 case 10: /* SYNC_IN */
2219 ucontrol->value.enumerated.item[0] =
2220 hdspm_get_sync_in_sample_rate(hdspm);
2221 break;
2222 default: /* AES1 to AES8 */
2223 ucontrol->value.enumerated.item[0] =
2224 hdspm_get_s1_sample_rate(hdspm,
2225 kcontrol->private_value-1);
2226 break;
2227 }
2228 break;
2229
2230 case MADI:
2231 case MADIface:
2232 {
2233 int rate = hdspm_external_sample_rate(hdspm);
2234 int i, selected_rate = 0;
2235 for (i = 1; i < 10; i++)
2236 if (HDSPM_bit2freq(i) == rate) {
2237 selected_rate = i;
2238 break;
2239 }
2240 ucontrol->value.enumerated.item[0] = selected_rate;
2241 }
2242 break;
2243
2244 default:
2245 break;
2246 }
2247
2248 return 0;
2249 }
2250
2251
2252 #define HDSPM_SYSTEM_CLOCK_MODE(xname, xindex) \
2253 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2254 .name = xname, \
2255 .index = xindex, \
2256 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
2257 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2258 .info = snd_hdspm_info_system_clock_mode, \
2259 .get = snd_hdspm_get_system_clock_mode, \
2260 .put = snd_hdspm_put_system_clock_mode, \
2261 }
2262
2263
2264 /**
2265 * Returns the system clock mode for the given card.
2266 * @returns 0 - master, 1 - slave
2267 **/
2268 static int hdspm_system_clock_mode(struct hdspm *hdspm)
2269 {
2270 switch (hdspm->io_type) {
2271 case AIO:
2272 case RayDAT:
2273 if (hdspm->settings_register & HDSPM_c0Master)
2274 return 0;
2275 break;
2276
2277 default:
2278 if (hdspm->control_register & HDSPM_ClockModeMaster)
2279 return 0;
2280 }
2281
2282 return 1;
2283 }
2284
2285
2286 /**
2287 * Sets the system clock mode.
2288 * @param mode 0 - master, 1 - slave
2289 **/
2290 static void hdspm_set_system_clock_mode(struct hdspm *hdspm, int mode)
2291 {
2292 switch (hdspm->io_type) {
2293 case AIO:
2294 case RayDAT:
2295 if (0 == mode)
2296 hdspm->settings_register |= HDSPM_c0Master;
2297 else
2298 hdspm->settings_register &= ~HDSPM_c0Master;
2299
2300 hdspm_write(hdspm, HDSPM_WR_SETTINGS, hdspm->settings_register);
2301 break;
2302
2303 default:
2304 if (0 == mode)
2305 hdspm->control_register |= HDSPM_ClockModeMaster;
2306 else
2307 hdspm->control_register &= ~HDSPM_ClockModeMaster;
2308
2309 hdspm_write(hdspm, HDSPM_controlRegister,
2310 hdspm->control_register);
2311 }
2312 }
2313
2314
2315 static int snd_hdspm_info_system_clock_mode(struct snd_kcontrol *kcontrol,
2316 struct snd_ctl_elem_info *uinfo)
2317 {
2318 static char *texts[] = { "Master", "AutoSync" };
2319
2320 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2321 uinfo->count = 1;
2322 uinfo->value.enumerated.items = 2;
2323 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2324 uinfo->value.enumerated.item =
2325 uinfo->value.enumerated.items - 1;
2326 strcpy(uinfo->value.enumerated.name,
2327 texts[uinfo->value.enumerated.item]);
2328 return 0;
2329 }
2330
2331 static int snd_hdspm_get_system_clock_mode(struct snd_kcontrol *kcontrol,
2332 struct snd_ctl_elem_value *ucontrol)
2333 {
2334 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2335
2336 ucontrol->value.enumerated.item[0] = hdspm_system_clock_mode(hdspm);
2337 return 0;
2338 }
2339
2340 static int snd_hdspm_put_system_clock_mode(struct snd_kcontrol *kcontrol,
2341 struct snd_ctl_elem_value *ucontrol)
2342 {
2343 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2344 int val;
2345
2346 if (!snd_hdspm_use_is_exclusive(hdspm))
2347 return -EBUSY;
2348
2349 val = ucontrol->value.enumerated.item[0];
2350 if (val < 0)
2351 val = 0;
2352 else if (val > 1)
2353 val = 1;
2354
2355 hdspm_set_system_clock_mode(hdspm, val);
2356
2357 return 0;
2358 }
2359
2360
2361 #define HDSPM_INTERNAL_CLOCK(xname, xindex) \
2362 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2363 .name = xname, \
2364 .index = xindex, \
2365 .info = snd_hdspm_info_clock_source, \
2366 .get = snd_hdspm_get_clock_source, \
2367 .put = snd_hdspm_put_clock_source \
2368 }
2369
2370
2371 static int hdspm_clock_source(struct hdspm * hdspm)
2372 {
2373 switch (hdspm->system_sample_rate) {
2374 case 32000: return 0;
2375 case 44100: return 1;
2376 case 48000: return 2;
2377 case 64000: return 3;
2378 case 88200: return 4;
2379 case 96000: return 5;
2380 case 128000: return 6;
2381 case 176400: return 7;
2382 case 192000: return 8;
2383 }
2384
2385 return -1;
2386 }
2387
2388 static int hdspm_set_clock_source(struct hdspm * hdspm, int mode)
2389 {
2390 int rate;
2391 switch (mode) {
2392 case 0:
2393 rate = 32000; break;
2394 case 1:
2395 rate = 44100; break;
2396 case 2:
2397 rate = 48000; break;
2398 case 3:
2399 rate = 64000; break;
2400 case 4:
2401 rate = 88200; break;
2402 case 5:
2403 rate = 96000; break;
2404 case 6:
2405 rate = 128000; break;
2406 case 7:
2407 rate = 176400; break;
2408 case 8:
2409 rate = 192000; break;
2410 default:
2411 rate = 48000;
2412 }
2413 hdspm_set_rate(hdspm, rate, 1);
2414 return 0;
2415 }
2416
2417 static int snd_hdspm_info_clock_source(struct snd_kcontrol *kcontrol,
2418 struct snd_ctl_elem_info *uinfo)
2419 {
2420 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2421 uinfo->count = 1;
2422 uinfo->value.enumerated.items = 9;
2423
2424 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2425 uinfo->value.enumerated.item =
2426 uinfo->value.enumerated.items - 1;
2427
2428 strcpy(uinfo->value.enumerated.name,
2429 texts_freq[uinfo->value.enumerated.item+1]);
2430
2431 return 0;
2432 }
2433
2434 static int snd_hdspm_get_clock_source(struct snd_kcontrol *kcontrol,
2435 struct snd_ctl_elem_value *ucontrol)
2436 {
2437 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2438
2439 ucontrol->value.enumerated.item[0] = hdspm_clock_source(hdspm);
2440 return 0;
2441 }
2442
2443 static int snd_hdspm_put_clock_source(struct snd_kcontrol *kcontrol,
2444 struct snd_ctl_elem_value *ucontrol)
2445 {
2446 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2447 int change;
2448 int val;
2449
2450 if (!snd_hdspm_use_is_exclusive(hdspm))
2451 return -EBUSY;
2452 val = ucontrol->value.enumerated.item[0];
2453 if (val < 0)
2454 val = 0;
2455 if (val > 9)
2456 val = 9;
2457 spin_lock_irq(&hdspm->lock);
2458 if (val != hdspm_clock_source(hdspm))
2459 change = (hdspm_set_clock_source(hdspm, val) == 0) ? 1 : 0;
2460 else
2461 change = 0;
2462 spin_unlock_irq(&hdspm->lock);
2463 return change;
2464 }
2465
2466
2467 #define HDSPM_PREF_SYNC_REF(xname, xindex) \
2468 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2469 .name = xname, \
2470 .index = xindex, \
2471 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
2472 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
2473 .info = snd_hdspm_info_pref_sync_ref, \
2474 .get = snd_hdspm_get_pref_sync_ref, \
2475 .put = snd_hdspm_put_pref_sync_ref \
2476 }
2477
2478
2479 /**
2480 * Returns the current preferred sync reference setting.
2481 * The semantics of the return value are depending on the
2482 * card, please see the comments for clarification.
2483 **/
2484 static int hdspm_pref_sync_ref(struct hdspm * hdspm)
2485 {
2486 switch (hdspm->io_type) {
2487 case AES32:
2488 switch (hdspm->control_register & HDSPM_SyncRefMask) {
2489 case 0: return 0; /* WC */
2490 case HDSPM_SyncRef0: return 1; /* AES 1 */
2491 case HDSPM_SyncRef1: return 2; /* AES 2 */
2492 case HDSPM_SyncRef1+HDSPM_SyncRef0: return 3; /* AES 3 */
2493 case HDSPM_SyncRef2: return 4; /* AES 4 */
2494 case HDSPM_SyncRef2+HDSPM_SyncRef0: return 5; /* AES 5 */
2495 case HDSPM_SyncRef2+HDSPM_SyncRef1: return 6; /* AES 6 */
2496 case HDSPM_SyncRef2+HDSPM_SyncRef1+HDSPM_SyncRef0:
2497 return 7; /* AES 7 */
2498 case HDSPM_SyncRef3: return 8; /* AES 8 */
2499 case HDSPM_SyncRef3+HDSPM_SyncRef0: return 9; /* TCO */
2500 }
2501 break;
2502
2503 case MADI:
2504 case MADIface:
2505 if (hdspm->tco) {
2506 switch (hdspm->control_register & HDSPM_SyncRefMask) {
2507 case 0: return 0; /* WC */
2508 case HDSPM_SyncRef0: return 1; /* MADI */
2509 case HDSPM_SyncRef1: return 2; /* TCO */
2510 case HDSPM_SyncRef1+HDSPM_SyncRef0:
2511 return 3; /* SYNC_IN */
2512 }
2513 } else {
2514 switch (hdspm->control_register & HDSPM_SyncRefMask) {
2515 case 0: return 0; /* WC */
2516 case HDSPM_SyncRef0: return 1; /* MADI */
2517 case HDSPM_SyncRef1+HDSPM_SyncRef0:
2518 return 2; /* SYNC_IN */
2519 }
2520 }
2521 break;
2522
2523 case RayDAT:
2524 if (hdspm->tco) {
2525 switch ((hdspm->settings_register &
2526 HDSPM_c0_SyncRefMask) / HDSPM_c0_SyncRef0) {
2527 case 0: return 0; /* WC */
2528 case 3: return 1; /* ADAT 1 */
2529 case 4: return 2; /* ADAT 2 */
2530 case 5: return 3; /* ADAT 3 */
2531 case 6: return 4; /* ADAT 4 */
2532 case 1: return 5; /* AES */
2533 case 2: return 6; /* SPDIF */
2534 case 9: return 7; /* TCO */
2535 case 10: return 8; /* SYNC_IN */
2536 }
2537 } else {
2538 switch ((hdspm->settings_register &
2539 HDSPM_c0_SyncRefMask) / HDSPM_c0_SyncRef0) {
2540 case 0: return 0; /* WC */
2541 case 3: return 1; /* ADAT 1 */
2542 case 4: return 2; /* ADAT 2 */
2543 case 5: return 3; /* ADAT 3 */
2544 case 6: return 4; /* ADAT 4 */
2545 case 1: return 5; /* AES */
2546 case 2: return 6; /* SPDIF */
2547 case 10: return 7; /* SYNC_IN */
2548 }
2549 }
2550
2551 break;
2552
2553 case AIO:
2554 if (hdspm->tco) {
2555 switch ((hdspm->settings_register &
2556 HDSPM_c0_SyncRefMask) / HDSPM_c0_SyncRef0) {
2557 case 0: return 0; /* WC */
2558 case 3: return 1; /* ADAT */
2559 case 1: return 2; /* AES */
2560 case 2: return 3; /* SPDIF */
2561 case 9: return 4; /* TCO */
2562 case 10: return 5; /* SYNC_IN */
2563 }
2564 } else {
2565 switch ((hdspm->settings_register &
2566 HDSPM_c0_SyncRefMask) / HDSPM_c0_SyncRef0) {
2567 case 0: return 0; /* WC */
2568 case 3: return 1; /* ADAT */
2569 case 1: return 2; /* AES */
2570 case 2: return 3; /* SPDIF */
2571 case 10: return 4; /* SYNC_IN */
2572 }
2573 }
2574
2575 break;
2576 }
2577
2578 return -1;
2579 }
2580
2581
2582 /**
2583 * Set the preferred sync reference to <pref>. The semantics
2584 * of <pref> are depending on the card type, see the comments
2585 * for clarification.
2586 **/
2587 static int hdspm_set_pref_sync_ref(struct hdspm * hdspm, int pref)
2588 {
2589 int p = 0;
2590
2591 switch (hdspm->io_type) {
2592 case AES32:
2593 hdspm->control_register &= ~HDSPM_SyncRefMask;
2594 switch (pref) {
2595 case 0: /* WC */
2596 break;
2597 case 1: /* AES 1 */
2598 hdspm->control_register |= HDSPM_SyncRef0;
2599 break;
2600 case 2: /* AES 2 */
2601 hdspm->control_register |= HDSPM_SyncRef1;
2602 break;
2603 case 3: /* AES 3 */
2604 hdspm->control_register |=
2605 HDSPM_SyncRef1+HDSPM_SyncRef0;
2606 break;
2607 case 4: /* AES 4 */
2608 hdspm->control_register |= HDSPM_SyncRef2;
2609 break;
2610 case 5: /* AES 5 */
2611 hdspm->control_register |=
2612 HDSPM_SyncRef2+HDSPM_SyncRef0;
2613 break;
2614 case 6: /* AES 6 */
2615 hdspm->control_register |=
2616 HDSPM_SyncRef2+HDSPM_SyncRef1;
2617 break;
2618 case 7: /* AES 7 */
2619 hdspm->control_register |=
2620 HDSPM_SyncRef2+HDSPM_SyncRef1+HDSPM_SyncRef0;
2621 break;
2622 case 8: /* AES 8 */
2623 hdspm->control_register |= HDSPM_SyncRef3;
2624 break;
2625 case 9: /* TCO */
2626 hdspm->control_register |=
2627 HDSPM_SyncRef3+HDSPM_SyncRef0;
2628 break;
2629 default:
2630 return -1;
2631 }
2632
2633 break;
2634
2635 case MADI:
2636 case MADIface:
2637 hdspm->control_register &= ~HDSPM_SyncRefMask;
2638 if (hdspm->tco) {
2639 switch (pref) {
2640 case 0: /* WC */
2641 break;
2642 case 1: /* MADI */
2643 hdspm->control_register |= HDSPM_SyncRef0;
2644 break;
2645 case 2: /* TCO */
2646 hdspm->control_register |= HDSPM_SyncRef1;
2647 break;
2648 case 3: /* SYNC_IN */
2649 hdspm->control_register |=
2650 HDSPM_SyncRef0+HDSPM_SyncRef1;
2651 break;
2652 default:
2653 return -1;
2654 }
2655 } else {
2656 switch (pref) {
2657 case 0: /* WC */
2658 break;
2659 case 1: /* MADI */
2660 hdspm->control_register |= HDSPM_SyncRef0;
2661 break;
2662 case 2: /* SYNC_IN */
2663 hdspm->control_register |=
2664 HDSPM_SyncRef0+HDSPM_SyncRef1;
2665 break;
2666 default:
2667 return -1;
2668 }
2669 }
2670
2671 break;
2672
2673 case RayDAT:
2674 if (hdspm->tco) {
2675 switch (pref) {
2676 case 0: p = 0; break; /* WC */
2677 case 1: p = 3; break; /* ADAT 1 */
2678 case 2: p = 4; break; /* ADAT 2 */
2679 case 3: p = 5; break; /* ADAT 3 */
2680 case 4: p = 6; break; /* ADAT 4 */
2681 case 5: p = 1; break; /* AES */
2682 case 6: p = 2; break; /* SPDIF */
2683 case 7: p = 9; break; /* TCO */
2684 case 8: p = 10; break; /* SYNC_IN */
2685 default: return -1;
2686 }
2687 } else {
2688 switch (pref) {
2689 case 0: p = 0; break; /* WC */
2690 case 1: p = 3; break; /* ADAT 1 */
2691 case 2: p = 4; break; /* ADAT 2 */
2692 case 3: p = 5; break; /* ADAT 3 */
2693 case 4: p = 6; break; /* ADAT 4 */
2694 case 5: p = 1; break; /* AES */
2695 case 6: p = 2; break; /* SPDIF */
2696 case 7: p = 10; break; /* SYNC_IN */
2697 default: return -1;
2698 }
2699 }
2700 break;
2701
2702 case AIO:
2703 if (hdspm->tco) {
2704 switch (pref) {
2705 case 0: p = 0; break; /* WC */
2706 case 1: p = 3; break; /* ADAT */
2707 case 2: p = 1; break; /* AES */
2708 case 3: p = 2; break; /* SPDIF */
2709 case 4: p = 9; break; /* TCO */
2710 case 5: p = 10; break; /* SYNC_IN */
2711 default: return -1;
2712 }
2713 } else {
2714 switch (pref) {
2715 case 0: p = 0; break; /* WC */
2716 case 1: p = 3; break; /* ADAT */
2717 case 2: p = 1; break; /* AES */
2718 case 3: p = 2; break; /* SPDIF */
2719 case 4: p = 10; break; /* SYNC_IN */
2720 default: return -1;
2721 }
2722 }
2723 break;
2724 }
2725
2726 switch (hdspm->io_type) {
2727 case RayDAT:
2728 case AIO:
2729 hdspm->settings_register &= ~HDSPM_c0_SyncRefMask;
2730 hdspm->settings_register |= HDSPM_c0_SyncRef0 * p;
2731 hdspm_write(hdspm, HDSPM_WR_SETTINGS, hdspm->settings_register);
2732 break;
2733
2734 case MADI:
2735 case MADIface:
2736 case AES32:
2737 hdspm_write(hdspm, HDSPM_controlRegister,
2738 hdspm->control_register);
2739 }
2740
2741 return 0;
2742 }
2743
2744
2745 static int snd_hdspm_info_pref_sync_ref(struct snd_kcontrol *kcontrol,
2746 struct snd_ctl_elem_info *uinfo)
2747 {
2748 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2749
2750 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2751 uinfo->count = 1;
2752 uinfo->value.enumerated.items = hdspm->texts_autosync_items;
2753
2754 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2755 uinfo->value.enumerated.item =
2756 uinfo->value.enumerated.items - 1;
2757
2758 strcpy(uinfo->value.enumerated.name,
2759 hdspm->texts_autosync[uinfo->value.enumerated.item]);
2760
2761 return 0;
2762 }
2763
2764 static int snd_hdspm_get_pref_sync_ref(struct snd_kcontrol *kcontrol,
2765 struct snd_ctl_elem_value *ucontrol)
2766 {
2767 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2768 int psf = hdspm_pref_sync_ref(hdspm);
2769
2770 if (psf >= 0) {
2771 ucontrol->value.enumerated.item[0] = psf;
2772 return 0;
2773 }
2774
2775 return -1;
2776 }
2777
2778 static int snd_hdspm_put_pref_sync_ref(struct snd_kcontrol *kcontrol,
2779 struct snd_ctl_elem_value *ucontrol)
2780 {
2781 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2782 int val, change = 0;
2783
2784 if (!snd_hdspm_use_is_exclusive(hdspm))
2785 return -EBUSY;
2786
2787 val = ucontrol->value.enumerated.item[0];
2788
2789 if (val < 0)
2790 val = 0;
2791 else if (val >= hdspm->texts_autosync_items)
2792 val = hdspm->texts_autosync_items-1;
2793
2794 spin_lock_irq(&hdspm->lock);
2795 if (val != hdspm_pref_sync_ref(hdspm))
2796 change = (0 == hdspm_set_pref_sync_ref(hdspm, val)) ? 1 : 0;
2797
2798 spin_unlock_irq(&hdspm->lock);
2799 return change;
2800 }
2801
2802
2803 #define HDSPM_AUTOSYNC_REF(xname, xindex) \
2804 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2805 .name = xname, \
2806 .index = xindex, \
2807 .access = SNDRV_CTL_ELEM_ACCESS_READ, \
2808 .info = snd_hdspm_info_autosync_ref, \
2809 .get = snd_hdspm_get_autosync_ref, \
2810 }
2811
2812 static int hdspm_autosync_ref(struct hdspm *hdspm)
2813 {
2814 if (AES32 == hdspm->io_type) {
2815 unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister);
2816 unsigned int syncref =
2817 (status >> HDSPM_AES32_syncref_bit) & 0xF;
2818 if (syncref == 0)
2819 return HDSPM_AES32_AUTOSYNC_FROM_WORD;
2820 if (syncref <= 8)
2821 return syncref;
2822 return HDSPM_AES32_AUTOSYNC_FROM_NONE;
2823 } else if (MADI == hdspm->io_type) {
2824 /* This looks at the autosync selected sync reference */
2825 unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
2826
2827 switch (status2 & HDSPM_SelSyncRefMask) {
2828 case HDSPM_SelSyncRef_WORD:
2829 return HDSPM_AUTOSYNC_FROM_WORD;
2830 case HDSPM_SelSyncRef_MADI:
2831 return HDSPM_AUTOSYNC_FROM_MADI;
2832 case HDSPM_SelSyncRef_TCO:
2833 return HDSPM_AUTOSYNC_FROM_TCO;
2834 case HDSPM_SelSyncRef_SyncIn:
2835 return HDSPM_AUTOSYNC_FROM_SYNC_IN;
2836 case HDSPM_SelSyncRef_NVALID:
2837 return HDSPM_AUTOSYNC_FROM_NONE;
2838 default:
2839 return 0;
2840 }
2841
2842 }
2843 return 0;
2844 }
2845
2846
2847 static int snd_hdspm_info_autosync_ref(struct snd_kcontrol *kcontrol,
2848 struct snd_ctl_elem_info *uinfo)
2849 {
2850 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2851
2852 if (AES32 == hdspm->io_type) {
2853 static char *texts[] = { "WordClock", "AES1", "AES2", "AES3",
2854 "AES4", "AES5", "AES6", "AES7", "AES8", "None"};
2855
2856 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2857 uinfo->count = 1;
2858 uinfo->value.enumerated.items = 10;
2859 if (uinfo->value.enumerated.item >=
2860 uinfo->value.enumerated.items)
2861 uinfo->value.enumerated.item =
2862 uinfo->value.enumerated.items - 1;
2863 strcpy(uinfo->value.enumerated.name,
2864 texts[uinfo->value.enumerated.item]);
2865 } else if (MADI == hdspm->io_type) {
2866 static char *texts[] = {"Word Clock", "MADI", "TCO",
2867 "Sync In", "None" };
2868
2869 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2870 uinfo->count = 1;
2871 uinfo->value.enumerated.items = 5;
2872 if (uinfo->value.enumerated.item >=
2873 uinfo->value.enumerated.items)
2874 uinfo->value.enumerated.item =
2875 uinfo->value.enumerated.items - 1;
2876 strcpy(uinfo->value.enumerated.name,
2877 texts[uinfo->value.enumerated.item]);
2878 }
2879 return 0;
2880 }
2881
2882 static int snd_hdspm_get_autosync_ref(struct snd_kcontrol *kcontrol,
2883 struct snd_ctl_elem_value *ucontrol)
2884 {
2885 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2886
2887 ucontrol->value.enumerated.item[0] = hdspm_autosync_ref(hdspm);
2888 return 0;
2889 }
2890
2891 #define HDSPM_TOGGLE_SETTING(xname, xindex) \
2892 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2893 .name = xname, \
2894 .private_value = xindex, \
2895 .info = snd_hdspm_info_toggle_setting, \
2896 .get = snd_hdspm_get_toggle_setting, \
2897 .put = snd_hdspm_put_toggle_setting \
2898 }
2899
2900 static int hdspm_toggle_setting(struct hdspm *hdspm, u32 regmask)
2901 {
2902 return (hdspm->control_register & regmask) ? 1 : 0;
2903 }
2904
2905 static int hdspm_set_toggle_setting(struct hdspm *hdspm, u32 regmask, int out)
2906 {
2907 if (out)
2908 hdspm->control_register |= regmask;
2909 else
2910 hdspm->control_register &= ~regmask;
2911 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2912
2913 return 0;
2914 }
2915
2916 #define snd_hdspm_info_toggle_setting snd_ctl_boolean_mono_info
2917
2918 static int snd_hdspm_get_toggle_setting(struct snd_kcontrol *kcontrol,
2919 struct snd_ctl_elem_value *ucontrol)
2920 {
2921 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2922 u32 regmask = kcontrol->private_value;
2923
2924 spin_lock_irq(&hdspm->lock);
2925 ucontrol->value.integer.value[0] = hdspm_toggle_setting(hdspm, regmask);
2926 spin_unlock_irq(&hdspm->lock);
2927 return 0;
2928 }
2929
2930 static int snd_hdspm_put_toggle_setting(struct snd_kcontrol *kcontrol,
2931 struct snd_ctl_elem_value *ucontrol)
2932 {
2933 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2934 u32 regmask = kcontrol->private_value;
2935 int change;
2936 unsigned int val;
2937
2938 if (!snd_hdspm_use_is_exclusive(hdspm))
2939 return -EBUSY;
2940 val = ucontrol->value.integer.value[0] & 1;
2941 spin_lock_irq(&hdspm->lock);
2942 change = (int) val != hdspm_toggle_setting(hdspm, regmask);
2943 hdspm_set_toggle_setting(hdspm, regmask, val);
2944 spin_unlock_irq(&hdspm->lock);
2945 return change;
2946 }
2947
2948 #define HDSPM_INPUT_SELECT(xname, xindex) \
2949 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2950 .name = xname, \
2951 .index = xindex, \
2952 .info = snd_hdspm_info_input_select, \
2953 .get = snd_hdspm_get_input_select, \
2954 .put = snd_hdspm_put_input_select \
2955 }
2956
2957 static int hdspm_input_select(struct hdspm * hdspm)
2958 {
2959 return (hdspm->control_register & HDSPM_InputSelect0) ? 1 : 0;
2960 }
2961
2962 static int hdspm_set_input_select(struct hdspm * hdspm, int out)
2963 {
2964 if (out)
2965 hdspm->control_register |= HDSPM_InputSelect0;
2966 else
2967 hdspm->control_register &= ~HDSPM_InputSelect0;
2968 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2969
2970 return 0;
2971 }
2972
2973 static int snd_hdspm_info_input_select(struct snd_kcontrol *kcontrol,
2974 struct snd_ctl_elem_info *uinfo)
2975 {
2976 static char *texts[] = { "optical", "coaxial" };
2977
2978 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2979 uinfo->count = 1;
2980 uinfo->value.enumerated.items = 2;
2981
2982 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2983 uinfo->value.enumerated.item =
2984 uinfo->value.enumerated.items - 1;
2985 strcpy(uinfo->value.enumerated.name,
2986 texts[uinfo->value.enumerated.item]);
2987
2988 return 0;
2989 }
2990
2991 static int snd_hdspm_get_input_select(struct snd_kcontrol *kcontrol,
2992 struct snd_ctl_elem_value *ucontrol)
2993 {
2994 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2995
2996 spin_lock_irq(&hdspm->lock);
2997 ucontrol->value.enumerated.item[0] = hdspm_input_select(hdspm);
2998 spin_unlock_irq(&hdspm->lock);
2999 return 0;
3000 }
3001
3002 static int snd_hdspm_put_input_select(struct snd_kcontrol *kcontrol,
3003 struct snd_ctl_elem_value *ucontrol)
3004 {
3005 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3006 int change;
3007 unsigned int val;
3008
3009 if (!snd_hdspm_use_is_exclusive(hdspm))
3010 return -EBUSY;
3011 val = ucontrol->value.integer.value[0] & 1;
3012 spin_lock_irq(&hdspm->lock);
3013 change = (int) val != hdspm_input_select(hdspm);
3014 hdspm_set_input_select(hdspm, val);
3015 spin_unlock_irq(&hdspm->lock);
3016 return change;
3017 }
3018
3019
3020 #define HDSPM_DS_WIRE(xname, xindex) \
3021 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3022 .name = xname, \
3023 .index = xindex, \
3024 .info = snd_hdspm_info_ds_wire, \
3025 .get = snd_hdspm_get_ds_wire, \
3026 .put = snd_hdspm_put_ds_wire \
3027 }
3028
3029 static int hdspm_ds_wire(struct hdspm * hdspm)
3030 {
3031 return (hdspm->control_register & HDSPM_DS_DoubleWire) ? 1 : 0;
3032 }
3033
3034 static int hdspm_set_ds_wire(struct hdspm * hdspm, int ds)
3035 {
3036 if (ds)
3037 hdspm->control_register |= HDSPM_DS_DoubleWire;
3038 else
3039 hdspm->control_register &= ~HDSPM_DS_DoubleWire;
3040 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
3041
3042 return 0;
3043 }
3044
3045 static int snd_hdspm_info_ds_wire(struct snd_kcontrol *kcontrol,
3046 struct snd_ctl_elem_info *uinfo)
3047 {
3048 static char *texts[] = { "Single", "Double" };
3049
3050 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3051 uinfo->count = 1;
3052 uinfo->value.enumerated.items = 2;
3053
3054 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3055 uinfo->value.enumerated.item =
3056 uinfo->value.enumerated.items - 1;
3057 strcpy(uinfo->value.enumerated.name,
3058 texts[uinfo->value.enumerated.item]);
3059
3060 return 0;
3061 }
3062
3063 static int snd_hdspm_get_ds_wire(struct snd_kcontrol *kcontrol,
3064 struct snd_ctl_elem_value *ucontrol)
3065 {
3066 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3067
3068 spin_lock_irq(&hdspm->lock);
3069 ucontrol->value.enumerated.item[0] = hdspm_ds_wire(hdspm);
3070 spin_unlock_irq(&hdspm->lock);
3071 return 0;
3072 }
3073
3074 static int snd_hdspm_put_ds_wire(struct snd_kcontrol *kcontrol,
3075 struct snd_ctl_elem_value *ucontrol)
3076 {
3077 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3078 int change;
3079 unsigned int val;
3080
3081 if (!snd_hdspm_use_is_exclusive(hdspm))
3082 return -EBUSY;
3083 val = ucontrol->value.integer.value[0] & 1;
3084 spin_lock_irq(&hdspm->lock);
3085 change = (int) val != hdspm_ds_wire(hdspm);
3086 hdspm_set_ds_wire(hdspm, val);
3087 spin_unlock_irq(&hdspm->lock);
3088 return change;
3089 }
3090
3091
3092 #define HDSPM_QS_WIRE(xname, xindex) \
3093 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3094 .name = xname, \
3095 .index = xindex, \
3096 .info = snd_hdspm_info_qs_wire, \
3097 .get = snd_hdspm_get_qs_wire, \
3098 .put = snd_hdspm_put_qs_wire \
3099 }
3100
3101 static int hdspm_qs_wire(struct hdspm * hdspm)
3102 {
3103 if (hdspm->control_register & HDSPM_QS_DoubleWire)
3104 return 1;
3105 if (hdspm->control_register & HDSPM_QS_QuadWire)
3106 return 2;
3107 return 0;
3108 }
3109
3110 static int hdspm_set_qs_wire(struct hdspm * hdspm, int mode)
3111 {
3112 hdspm->control_register &= ~(HDSPM_QS_DoubleWire | HDSPM_QS_QuadWire);
3113 switch (mode) {
3114 case 0:
3115 break;
3116 case 1:
3117 hdspm->control_register |= HDSPM_QS_DoubleWire;
3118 break;
3119 case 2:
3120 hdspm->control_register |= HDSPM_QS_QuadWire;
3121 break;
3122 }
3123 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
3124
3125 return 0;
3126 }
3127
3128 static int snd_hdspm_info_qs_wire(struct snd_kcontrol *kcontrol,
3129 struct snd_ctl_elem_info *uinfo)
3130 {
3131 static char *texts[] = { "Single", "Double", "Quad" };
3132
3133 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3134 uinfo->count = 1;
3135 uinfo->value.enumerated.items = 3;
3136
3137 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3138 uinfo->value.enumerated.item =
3139 uinfo->value.enumerated.items - 1;
3140 strcpy(uinfo->value.enumerated.name,
3141 texts[uinfo->value.enumerated.item]);
3142
3143 return 0;
3144 }
3145
3146 static int snd_hdspm_get_qs_wire(struct snd_kcontrol *kcontrol,
3147 struct snd_ctl_elem_value *ucontrol)
3148 {
3149 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3150
3151 spin_lock_irq(&hdspm->lock);
3152 ucontrol->value.enumerated.item[0] = hdspm_qs_wire(hdspm);
3153 spin_unlock_irq(&hdspm->lock);
3154 return 0;
3155 }
3156
3157 static int snd_hdspm_put_qs_wire(struct snd_kcontrol *kcontrol,
3158 struct snd_ctl_elem_value *ucontrol)
3159 {
3160 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3161 int change;
3162 int val;
3163
3164 if (!snd_hdspm_use_is_exclusive(hdspm))
3165 return -EBUSY;
3166 val = ucontrol->value.integer.value[0];
3167 if (val < 0)
3168 val = 0;
3169 if (val > 2)
3170 val = 2;
3171 spin_lock_irq(&hdspm->lock);
3172 change = val != hdspm_qs_wire(hdspm);
3173 hdspm_set_qs_wire(hdspm, val);
3174 spin_unlock_irq(&hdspm->lock);
3175 return change;
3176 }
3177
3178 #define HDSPM_MADI_SPEEDMODE(xname, xindex) \
3179 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3180 .name = xname, \
3181 .index = xindex, \
3182 .info = snd_hdspm_info_madi_speedmode, \
3183 .get = snd_hdspm_get_madi_speedmode, \
3184 .put = snd_hdspm_put_madi_speedmode \
3185 }
3186
3187 static int hdspm_madi_speedmode(struct hdspm *hdspm)
3188 {
3189 if (hdspm->control_register & HDSPM_QuadSpeed)
3190 return 2;
3191 if (hdspm->control_register & HDSPM_DoubleSpeed)
3192 return 1;
3193 return 0;
3194 }
3195
3196 static int hdspm_set_madi_speedmode(struct hdspm *hdspm, int mode)
3197 {
3198 hdspm->control_register &= ~(HDSPM_DoubleSpeed | HDSPM_QuadSpeed);
3199 switch (mode) {
3200 case 0:
3201 break;
3202 case 1:
3203 hdspm->control_register |= HDSPM_DoubleSpeed;
3204 break;
3205 case 2:
3206 hdspm->control_register |= HDSPM_QuadSpeed;
3207 break;
3208 }
3209 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
3210
3211 return 0;
3212 }
3213
3214 static int snd_hdspm_info_madi_speedmode(struct snd_kcontrol *kcontrol,
3215 struct snd_ctl_elem_info *uinfo)
3216 {
3217 static char *texts[] = { "Single", "Double", "Quad" };
3218
3219 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3220 uinfo->count = 1;
3221 uinfo->value.enumerated.items = 3;
3222
3223 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3224 uinfo->value.enumerated.item =
3225 uinfo->value.enumerated.items - 1;
3226 strcpy(uinfo->value.enumerated.name,
3227 texts[uinfo->value.enumerated.item]);
3228
3229 return 0;
3230 }
3231
3232 static int snd_hdspm_get_madi_speedmode(struct snd_kcontrol *kcontrol,
3233 struct snd_ctl_elem_value *ucontrol)
3234 {
3235 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3236
3237 spin_lock_irq(&hdspm->lock);
3238 ucontrol->value.enumerated.item[0] = hdspm_madi_speedmode(hdspm);
3239 spin_unlock_irq(&hdspm->lock);
3240 return 0;
3241 }
3242
3243 static int snd_hdspm_put_madi_speedmode(struct snd_kcontrol *kcontrol,
3244 struct snd_ctl_elem_value *ucontrol)
3245 {
3246 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3247 int change;
3248 int val;
3249
3250 if (!snd_hdspm_use_is_exclusive(hdspm))
3251 return -EBUSY;
3252 val = ucontrol->value.integer.value[0];
3253 if (val < 0)
3254 val = 0;
3255 if (val > 2)
3256 val = 2;
3257 spin_lock_irq(&hdspm->lock);
3258 change = val != hdspm_madi_speedmode(hdspm);
3259 hdspm_set_madi_speedmode(hdspm, val);
3260 spin_unlock_irq(&hdspm->lock);
3261 return change;
3262 }
3263
3264 #define HDSPM_MIXER(xname, xindex) \
3265 { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
3266 .name = xname, \
3267 .index = xindex, \
3268 .device = 0, \
3269 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
3270 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3271 .info = snd_hdspm_info_mixer, \
3272 .get = snd_hdspm_get_mixer, \
3273 .put = snd_hdspm_put_mixer \
3274 }
3275
3276 static int snd_hdspm_info_mixer(struct snd_kcontrol *kcontrol,
3277 struct snd_ctl_elem_info *uinfo)
3278 {
3279 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3280 uinfo->count = 3;
3281 uinfo->value.integer.min = 0;
3282 uinfo->value.integer.max = 65535;
3283 uinfo->value.integer.step = 1;
3284 return 0;
3285 }
3286
3287 static int snd_hdspm_get_mixer(struct snd_kcontrol *kcontrol,
3288 struct snd_ctl_elem_value *ucontrol)
3289 {
3290 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3291 int source;
3292 int destination;
3293
3294 source = ucontrol->value.integer.value[0];
3295 if (source < 0)
3296 source = 0;
3297 else if (source >= 2 * HDSPM_MAX_CHANNELS)
3298 source = 2 * HDSPM_MAX_CHANNELS - 1;
3299
3300 destination = ucontrol->value.integer.value[1];
3301 if (destination < 0)
3302 destination = 0;
3303 else if (destination >= HDSPM_MAX_CHANNELS)
3304 destination = HDSPM_MAX_CHANNELS - 1;
3305
3306 spin_lock_irq(&hdspm->lock);
3307 if (source >= HDSPM_MAX_CHANNELS)
3308 ucontrol->value.integer.value[2] =
3309 hdspm_read_pb_gain(hdspm, destination,
3310 source - HDSPM_MAX_CHANNELS);
3311 else
3312 ucontrol->value.integer.value[2] =
3313 hdspm_read_in_gain(hdspm, destination, source);
3314
3315 spin_unlock_irq(&hdspm->lock);
3316
3317 return 0;
3318 }
3319
3320 static int snd_hdspm_put_mixer(struct snd_kcontrol *kcontrol,
3321 struct snd_ctl_elem_value *ucontrol)
3322 {
3323 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3324 int change;
3325 int source;
3326 int destination;
3327 int gain;
3328
3329 if (!snd_hdspm_use_is_exclusive(hdspm))
3330 return -EBUSY;
3331
3332 source = ucontrol->value.integer.value[0];
3333 destination = ucontrol->value.integer.value[1];
3334
3335 if (source < 0 || source >= 2 * HDSPM_MAX_CHANNELS)
3336 return -1;
3337 if (destination < 0 || destination >= HDSPM_MAX_CHANNELS)
3338 return -1;
3339
3340 gain = ucontrol->value.integer.value[2];
3341
3342 spin_lock_irq(&hdspm->lock);
3343
3344 if (source >= HDSPM_MAX_CHANNELS)
3345 change = gain != hdspm_read_pb_gain(hdspm, destination,
3346 source -
3347 HDSPM_MAX_CHANNELS);
3348 else
3349 change = gain != hdspm_read_in_gain(hdspm, destination,
3350 source);
3351
3352 if (change) {
3353 if (source >= HDSPM_MAX_CHANNELS)
3354 hdspm_write_pb_gain(hdspm, destination,
3355 source - HDSPM_MAX_CHANNELS,
3356 gain);
3357 else
3358 hdspm_write_in_gain(hdspm, destination, source,
3359 gain);
3360 }
3361 spin_unlock_irq(&hdspm->lock);
3362
3363 return change;
3364 }
3365
3366 /* The simple mixer control(s) provide gain control for the
3367 basic 1:1 mappings of playback streams to output
3368 streams.
3369 */
3370
3371 #define HDSPM_PLAYBACK_MIXER \
3372 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3373 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE | \
3374 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3375 .info = snd_hdspm_info_playback_mixer, \
3376 .get = snd_hdspm_get_playback_mixer, \
3377 .put = snd_hdspm_put_playback_mixer \
3378 }
3379
3380 static int snd_hdspm_info_playback_mixer(struct snd_kcontrol *kcontrol,
3381 struct snd_ctl_elem_info *uinfo)
3382 {
3383 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3384 uinfo->count = 1;
3385 uinfo->value.integer.min = 0;
3386 uinfo->value.integer.max = 64;
3387 uinfo->value.integer.step = 1;
3388 return 0;
3389 }
3390
3391 static int snd_hdspm_get_playback_mixer(struct snd_kcontrol *kcontrol,
3392 struct snd_ctl_elem_value *ucontrol)
3393 {
3394 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3395 int channel;
3396
3397 channel = ucontrol->id.index - 1;
3398
3399 if (snd_BUG_ON(channel < 0 || channel >= HDSPM_MAX_CHANNELS))
3400 return -EINVAL;
3401
3402 spin_lock_irq(&hdspm->lock);
3403 ucontrol->value.integer.value[0] =
3404 (hdspm_read_pb_gain(hdspm, channel, channel)*64)/UNITY_GAIN;
3405 spin_unlock_irq(&hdspm->lock);
3406
3407 return 0;
3408 }
3409
3410 static int snd_hdspm_put_playback_mixer(struct snd_kcontrol *kcontrol,
3411 struct snd_ctl_elem_value *ucontrol)
3412 {
3413 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3414 int change;
3415 int channel;
3416 int gain;
3417
3418 if (!snd_hdspm_use_is_exclusive(hdspm))
3419 return -EBUSY;
3420
3421 channel = ucontrol->id.index - 1;
3422
3423 if (snd_BUG_ON(channel < 0 || channel >= HDSPM_MAX_CHANNELS))
3424 return -EINVAL;
3425
3426 gain = ucontrol->value.integer.value[0]*UNITY_GAIN/64;
3427
3428 spin_lock_irq(&hdspm->lock);
3429 change =
3430 gain != hdspm_read_pb_gain(hdspm, channel,
3431 channel);
3432 if (change)
3433 hdspm_write_pb_gain(hdspm, channel, channel,
3434 gain);
3435 spin_unlock_irq(&hdspm->lock);
3436 return change;
3437 }
3438
3439 #define HDSPM_SYNC_CHECK(xname, xindex) \
3440 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3441 .name = xname, \
3442 .private_value = xindex, \
3443 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3444 .info = snd_hdspm_info_sync_check, \
3445 .get = snd_hdspm_get_sync_check \
3446 }
3447
3448
3449 static int snd_hdspm_info_sync_check(struct snd_kcontrol *kcontrol,
3450 struct snd_ctl_elem_info *uinfo)
3451 {
3452 static char *texts[] = { "No Lock", "Lock", "Sync", "N/A" };
3453 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3454 uinfo->count = 1;
3455 uinfo->value.enumerated.items = 4;
3456 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3457 uinfo->value.enumerated.item =
3458 uinfo->value.enumerated.items - 1;
3459 strcpy(uinfo->value.enumerated.name,
3460 texts[uinfo->value.enumerated.item]);
3461 return 0;
3462 }
3463
3464 static int hdspm_wc_sync_check(struct hdspm *hdspm)
3465 {
3466 int status, status2;
3467
3468 switch (hdspm->io_type) {
3469 case AES32:
3470 status = hdspm_read(hdspm, HDSPM_statusRegister);
3471 if (status & HDSPM_AES32_wcLock) {
3472 if (status & HDSPM_AES32_wcSync)
3473 return 2;
3474 else
3475 return 1;
3476 }
3477 return 0;
3478 break;
3479
3480 case MADI:
3481 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
3482 if (status2 & HDSPM_wcLock) {
3483 if (status2 & HDSPM_wcSync)
3484 return 2;
3485 else
3486 return 1;
3487 }
3488 return 0;
3489 break;
3490
3491 case RayDAT:
3492 case AIO:
3493 status = hdspm_read(hdspm, HDSPM_statusRegister);
3494
3495 if (status & 0x2000000)
3496 return 2;
3497 else if (status & 0x1000000)
3498 return 1;
3499 return 0;
3500
3501 break;
3502
3503 case MADIface:
3504 break;
3505 }
3506
3507
3508 return 3;
3509 }
3510
3511
3512 static int hdspm_madi_sync_check(struct hdspm *hdspm)
3513 {
3514 int status = hdspm_read(hdspm, HDSPM_statusRegister);
3515 if (status & HDSPM_madiLock) {
3516 if (status & HDSPM_madiSync)
3517 return 2;
3518 else
3519 return 1;
3520 }
3521 return 0;
3522 }
3523
3524
3525 static int hdspm_s1_sync_check(struct hdspm *hdspm, int idx)
3526 {
3527 int status, lock, sync;
3528
3529 status = hdspm_read(hdspm, HDSPM_RD_STATUS_1);
3530
3531 lock = (status & (0x1<<idx)) ? 1 : 0;
3532 sync = (status & (0x100<<idx)) ? 1 : 0;
3533
3534 if (lock && sync)
3535 return 2;
3536 else if (lock)
3537 return 1;
3538 return 0;
3539 }
3540
3541
3542 static int hdspm_sync_in_sync_check(struct hdspm *hdspm)
3543 {
3544 int status, lock = 0, sync = 0;
3545
3546 switch (hdspm->io_type) {
3547 case RayDAT:
3548 case AIO:
3549 status = hdspm_read(hdspm, HDSPM_RD_STATUS_3);
3550 lock = (status & 0x400) ? 1 : 0;
3551 sync = (status & 0x800) ? 1 : 0;
3552 break;
3553
3554 case MADI:
3555 status = hdspm_read(hdspm, HDSPM_statusRegister);
3556 lock = (status & HDSPM_syncInLock) ? 1 : 0;
3557 sync = (status & HDSPM_syncInSync) ? 1 : 0;
3558 break;
3559
3560 case AES32:
3561 status = hdspm_read(hdspm, HDSPM_statusRegister2);
3562 lock = (status & 0x100000) ? 1 : 0;
3563 sync = (status & 0x200000) ? 1 : 0;
3564 break;
3565
3566 case MADIface:
3567 break;
3568 }
3569
3570 if (lock && sync)
3571 return 2;
3572 else if (lock)
3573 return 1;
3574
3575 return 0;
3576 }
3577
3578 static int hdspm_aes_sync_check(struct hdspm *hdspm, int idx)
3579 {
3580 int status2, lock, sync;
3581 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
3582
3583 lock = (status2 & (0x0080 >> idx)) ? 1 : 0;
3584 sync = (status2 & (0x8000 >> idx)) ? 1 : 0;
3585
3586 if (sync)
3587 return 2;
3588 else if (lock)
3589 return 1;
3590 return 0;
3591 }
3592
3593
3594 static int hdspm_tco_sync_check(struct hdspm *hdspm)
3595 {
3596 int status;
3597
3598 if (hdspm->tco) {
3599 switch (hdspm->io_type) {
3600 case MADI:
3601 case AES32:
3602 status = hdspm_read(hdspm, HDSPM_statusRegister);
3603 if (status & HDSPM_tcoLock) {
3604 if (status & HDSPM_tcoSync)
3605 return 2;
3606 else
3607 return 1;
3608 }
3609 return 0;
3610
3611 break;
3612
3613 case RayDAT:
3614 case AIO:
3615 status = hdspm_read(hdspm, HDSPM_RD_STATUS_1);
3616
3617 if (status & 0x8000000)
3618 return 2; /* Sync */
3619 if (status & 0x4000000)
3620 return 1; /* Lock */
3621 return 0; /* No signal */
3622 break;
3623
3624 default:
3625 break;
3626 }
3627 }
3628
3629 return 3; /* N/A */
3630 }
3631
3632
3633 static int snd_hdspm_get_sync_check(struct snd_kcontrol *kcontrol,
3634 struct snd_ctl_elem_value *ucontrol)
3635 {
3636 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3637 int val = -1;
3638
3639 switch (hdspm->io_type) {
3640 case RayDAT:
3641 switch (kcontrol->private_value) {
3642 case 0: /* WC */
3643 val = hdspm_wc_sync_check(hdspm); break;
3644 case 7: /* TCO */
3645 val = hdspm_tco_sync_check(hdspm); break;
3646 case 8: /* SYNC IN */
3647 val = hdspm_sync_in_sync_check(hdspm); break;
3648 default:
3649 val = hdspm_s1_sync_check(hdspm,
3650 kcontrol->private_value-1);
3651 }
3652 break;
3653
3654 case AIO:
3655 switch (kcontrol->private_value) {
3656 case 0: /* WC */
3657 val = hdspm_wc_sync_check(hdspm); break;
3658 case 4: /* TCO */
3659 val = hdspm_tco_sync_check(hdspm); break;
3660 case 5: /* SYNC IN */
3661 val = hdspm_sync_in_sync_check(hdspm); break;
3662 default:
3663 val = hdspm_s1_sync_check(hdspm, ucontrol->id.index-1);
3664 }
3665 break;
3666
3667 case MADI:
3668 switch (kcontrol->private_value) {
3669 case 0: /* WC */
3670 val = hdspm_wc_sync_check(hdspm); break;
3671 case 1: /* MADI */
3672 val = hdspm_madi_sync_check(hdspm); break;
3673 case 2: /* TCO */
3674 val = hdspm_tco_sync_check(hdspm); break;
3675 case 3: /* SYNC_IN */
3676 val = hdspm_sync_in_sync_check(hdspm); break;
3677 }
3678 break;
3679
3680 case MADIface:
3681 val = hdspm_madi_sync_check(hdspm); /* MADI */
3682 break;
3683
3684 case AES32:
3685 switch (kcontrol->private_value) {
3686 case 0: /* WC */
3687 val = hdspm_wc_sync_check(hdspm); break;
3688 case 9: /* TCO */
3689 val = hdspm_tco_sync_check(hdspm); break;
3690 case 10 /* SYNC IN */:
3691 val = hdspm_sync_in_sync_check(hdspm); break;
3692 default: /* AES1 to AES8 */
3693 val = hdspm_aes_sync_check(hdspm,
3694 kcontrol->private_value-1);
3695 }
3696 break;
3697
3698 }
3699
3700 if (-1 == val)
3701 val = 3;
3702
3703 ucontrol->value.enumerated.item[0] = val;
3704 return 0;
3705 }
3706
3707
3708
3709 /**
3710 * TCO controls
3711 **/
3712 static void hdspm_tco_write(struct hdspm *hdspm)
3713 {
3714 unsigned int tc[4] = { 0, 0, 0, 0};
3715
3716 switch (hdspm->tco->input) {
3717 case 0:
3718 tc[2] |= HDSPM_TCO2_set_input_MSB;
3719 break;
3720 case 1:
3721 tc[2] |= HDSPM_TCO2_set_input_LSB;
3722 break;
3723 default:
3724 break;
3725 }
3726
3727 switch (hdspm->tco->framerate) {
3728 case 1:
3729 tc[1] |= HDSPM_TCO1_LTC_Format_LSB;
3730 break;
3731 case 2:
3732 tc[1] |= HDSPM_TCO1_LTC_Format_MSB;
3733 break;
3734 case 3:
3735 tc[1] |= HDSPM_TCO1_LTC_Format_MSB +
3736 HDSPM_TCO1_set_drop_frame_flag;
3737 break;
3738 case 4:
3739 tc[1] |= HDSPM_TCO1_LTC_Format_LSB +
3740 HDSPM_TCO1_LTC_Format_MSB;
3741 break;
3742 case 5:
3743 tc[1] |= HDSPM_TCO1_LTC_Format_LSB +
3744 HDSPM_TCO1_LTC_Format_MSB +
3745 HDSPM_TCO1_set_drop_frame_flag;
3746 break;
3747 default:
3748 break;
3749 }
3750
3751 switch (hdspm->tco->wordclock) {
3752 case 1:
3753 tc[2] |= HDSPM_TCO2_WCK_IO_ratio_LSB;
3754 break;
3755 case 2:
3756 tc[2] |= HDSPM_TCO2_WCK_IO_ratio_MSB;
3757 break;
3758 default:
3759 break;
3760 }
3761
3762 switch (hdspm->tco->samplerate) {
3763 case 1:
3764 tc[2] |= HDSPM_TCO2_set_freq;
3765 break;
3766 case 2:
3767 tc[2] |= HDSPM_TCO2_set_freq_from_app;
3768 break;
3769 default:
3770 break;
3771 }
3772
3773 switch (hdspm->tco->pull) {
3774 case 1:
3775 tc[2] |= HDSPM_TCO2_set_pull_up;
3776 break;
3777 case 2:
3778 tc[2] |= HDSPM_TCO2_set_pull_down;
3779 break;
3780 case 3:
3781 tc[2] |= HDSPM_TCO2_set_pull_up + HDSPM_TCO2_set_01_4;
3782 break;
3783 case 4:
3784 tc[2] |= HDSPM_TCO2_set_pull_down + HDSPM_TCO2_set_01_4;
3785 break;
3786 default:
3787 break;
3788 }
3789
3790 if (1 == hdspm->tco->term) {
3791 tc[2] |= HDSPM_TCO2_set_term_75R;
3792 }
3793
3794 hdspm_write(hdspm, HDSPM_WR_TCO, tc[0]);
3795 hdspm_write(hdspm, HDSPM_WR_TCO+4, tc[1]);
3796 hdspm_write(hdspm, HDSPM_WR_TCO+8, tc[2]);
3797 hdspm_write(hdspm, HDSPM_WR_TCO+12, tc[3]);
3798 }
3799
3800
3801 #define HDSPM_TCO_SAMPLE_RATE(xname, xindex) \
3802 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3803 .name = xname, \
3804 .index = xindex, \
3805 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
3806 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3807 .info = snd_hdspm_info_tco_sample_rate, \
3808 .get = snd_hdspm_get_tco_sample_rate, \
3809 .put = snd_hdspm_put_tco_sample_rate \
3810 }
3811
3812 static int snd_hdspm_info_tco_sample_rate(struct snd_kcontrol *kcontrol,
3813 struct snd_ctl_elem_info *uinfo)
3814 {
3815 static char *texts[] = { "44.1 kHz", "48 kHz" };
3816 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3817 uinfo->count = 1;
3818 uinfo->value.enumerated.items = 2;
3819
3820 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3821 uinfo->value.enumerated.item =
3822 uinfo->value.enumerated.items - 1;
3823
3824 strcpy(uinfo->value.enumerated.name,
3825 texts[uinfo->value.enumerated.item]);
3826
3827 return 0;
3828 }
3829
3830 static int snd_hdspm_get_tco_sample_rate(struct snd_kcontrol *kcontrol,
3831 struct snd_ctl_elem_value *ucontrol)
3832 {
3833 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3834
3835 ucontrol->value.enumerated.item[0] = hdspm->tco->samplerate;
3836
3837 return 0;
3838 }
3839
3840 static int snd_hdspm_put_tco_sample_rate(struct snd_kcontrol *kcontrol,
3841 struct snd_ctl_elem_value *ucontrol)
3842 {
3843 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3844
3845 if (hdspm->tco->samplerate != ucontrol->value.enumerated.item[0]) {
3846 hdspm->tco->samplerate = ucontrol->value.enumerated.item[0];
3847
3848 hdspm_tco_write(hdspm);
3849
3850 return 1;
3851 }
3852
3853 return 0;
3854 }
3855
3856
3857 #define HDSPM_TCO_PULL(xname, xindex) \
3858 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3859 .name = xname, \
3860 .index = xindex, \
3861 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
3862 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3863 .info = snd_hdspm_info_tco_pull, \
3864 .get = snd_hdspm_get_tco_pull, \
3865 .put = snd_hdspm_put_tco_pull \
3866 }
3867
3868 static int snd_hdspm_info_tco_pull(struct snd_kcontrol *kcontrol,
3869 struct snd_ctl_elem_info *uinfo)
3870 {
3871 static char *texts[] = { "0", "+ 0.1 %", "- 0.1 %", "+ 4 %", "- 4 %" };
3872 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3873 uinfo->count = 1;
3874 uinfo->value.enumerated.items = 5;
3875
3876 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3877 uinfo->value.enumerated.item =
3878 uinfo->value.enumerated.items - 1;
3879
3880 strcpy(uinfo->value.enumerated.name,
3881 texts[uinfo->value.enumerated.item]);
3882
3883 return 0;
3884 }
3885
3886 static int snd_hdspm_get_tco_pull(struct snd_kcontrol *kcontrol,
3887 struct snd_ctl_elem_value *ucontrol)
3888 {
3889 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3890
3891 ucontrol->value.enumerated.item[0] = hdspm->tco->pull;
3892
3893 return 0;
3894 }
3895
3896 static int snd_hdspm_put_tco_pull(struct snd_kcontrol *kcontrol,
3897 struct snd_ctl_elem_value *ucontrol)
3898 {
3899 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3900
3901 if (hdspm->tco->pull != ucontrol->value.enumerated.item[0]) {
3902 hdspm->tco->pull = ucontrol->value.enumerated.item[0];
3903
3904 hdspm_tco_write(hdspm);
3905
3906 return 1;
3907 }
3908
3909 return 0;
3910 }
3911
3912 #define HDSPM_TCO_WCK_CONVERSION(xname, xindex) \
3913 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3914 .name = xname, \
3915 .index = xindex, \
3916 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
3917 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3918 .info = snd_hdspm_info_tco_wck_conversion, \
3919 .get = snd_hdspm_get_tco_wck_conversion, \
3920 .put = snd_hdspm_put_tco_wck_conversion \
3921 }
3922
3923 static int snd_hdspm_info_tco_wck_conversion(struct snd_kcontrol *kcontrol,
3924 struct snd_ctl_elem_info *uinfo)
3925 {
3926 static char *texts[] = { "1:1", "44.1 -> 48", "48 -> 44.1" };
3927 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3928 uinfo->count = 1;
3929 uinfo->value.enumerated.items = 3;
3930
3931 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3932 uinfo->value.enumerated.item =
3933 uinfo->value.enumerated.items - 1;
3934
3935 strcpy(uinfo->value.enumerated.name,
3936 texts[uinfo->value.enumerated.item]);
3937
3938 return 0;
3939 }
3940
3941 static int snd_hdspm_get_tco_wck_conversion(struct snd_kcontrol *kcontrol,
3942 struct snd_ctl_elem_value *ucontrol)
3943 {
3944 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3945
3946 ucontrol->value.enumerated.item[0] = hdspm->tco->wordclock;
3947
3948 return 0;
3949 }
3950
3951 static int snd_hdspm_put_tco_wck_conversion(struct snd_kcontrol *kcontrol,
3952 struct snd_ctl_elem_value *ucontrol)
3953 {
3954 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
3955
3956 if (hdspm->tco->wordclock != ucontrol->value.enumerated.item[0]) {
3957 hdspm->tco->wordclock = ucontrol->value.enumerated.item[0];
3958
3959 hdspm_tco_write(hdspm);
3960
3961 return 1;
3962 }
3963
3964 return 0;
3965 }
3966
3967
3968 #define HDSPM_TCO_FRAME_RATE(xname, xindex) \
3969 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3970 .name = xname, \
3971 .index = xindex, \
3972 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
3973 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
3974 .info = snd_hdspm_info_tco_frame_rate, \
3975 .get = snd_hdspm_get_tco_frame_rate, \
3976 .put = snd_hdspm_put_tco_frame_rate \
3977 }
3978
3979 static int snd_hdspm_info_tco_frame_rate(struct snd_kcontrol *kcontrol,
3980 struct snd_ctl_elem_info *uinfo)
3981 {
3982 static char *texts[] = { "24 fps", "25 fps", "29.97fps",
3983 "29.97 dfps", "30 fps", "30 dfps" };
3984 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3985 uinfo->count = 1;
3986 uinfo->value.enumerated.items = 6;
3987
3988 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
3989 uinfo->value.enumerated.item =
3990 uinfo->value.enumerated.items - 1;
3991
3992 strcpy(uinfo->value.enumerated.name,
3993 texts[uinfo->value.enumerated.item]);
3994
3995 return 0;
3996 }
3997
3998 static int snd_hdspm_get_tco_frame_rate(struct snd_kcontrol *kcontrol,
3999 struct snd_ctl_elem_value *ucontrol)
4000 {
4001 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4002
4003 ucontrol->value.enumerated.item[0] = hdspm->tco->framerate;
4004
4005 return 0;
4006 }
4007
4008 static int snd_hdspm_put_tco_frame_rate(struct snd_kcontrol *kcontrol,
4009 struct snd_ctl_elem_value *ucontrol)
4010 {
4011 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4012
4013 if (hdspm->tco->framerate != ucontrol->value.enumerated.item[0]) {
4014 hdspm->tco->framerate = ucontrol->value.enumerated.item[0];
4015
4016 hdspm_tco_write(hdspm);
4017
4018 return 1;
4019 }
4020
4021 return 0;
4022 }
4023
4024
4025 #define HDSPM_TCO_SYNC_SOURCE(xname, xindex) \
4026 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
4027 .name = xname, \
4028 .index = xindex, \
4029 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
4030 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
4031 .info = snd_hdspm_info_tco_sync_source, \
4032 .get = snd_hdspm_get_tco_sync_source, \
4033 .put = snd_hdspm_put_tco_sync_source \
4034 }
4035
4036 static int snd_hdspm_info_tco_sync_source(struct snd_kcontrol *kcontrol,
4037 struct snd_ctl_elem_info *uinfo)
4038 {
4039 static char *texts[] = { "LTC", "Video", "WCK" };
4040 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4041 uinfo->count = 1;
4042 uinfo->value.enumerated.items = 3;
4043
4044 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
4045 uinfo->value.enumerated.item =
4046 uinfo->value.enumerated.items - 1;
4047
4048 strcpy(uinfo->value.enumerated.name,
4049 texts[uinfo->value.enumerated.item]);
4050
4051 return 0;
4052 }
4053
4054 static int snd_hdspm_get_tco_sync_source(struct snd_kcontrol *kcontrol,
4055 struct snd_ctl_elem_value *ucontrol)
4056 {
4057 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4058
4059 ucontrol->value.enumerated.item[0] = hdspm->tco->input;
4060
4061 return 0;
4062 }
4063
4064 static int snd_hdspm_put_tco_sync_source(struct snd_kcontrol *kcontrol,
4065 struct snd_ctl_elem_value *ucontrol)
4066 {
4067 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4068
4069 if (hdspm->tco->input != ucontrol->value.enumerated.item[0]) {
4070 hdspm->tco->input = ucontrol->value.enumerated.item[0];
4071
4072 hdspm_tco_write(hdspm);
4073
4074 return 1;
4075 }
4076
4077 return 0;
4078 }
4079
4080
4081 #define HDSPM_TCO_WORD_TERM(xname, xindex) \
4082 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
4083 .name = xname, \
4084 .index = xindex, \
4085 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\
4086 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
4087 .info = snd_hdspm_info_tco_word_term, \
4088 .get = snd_hdspm_get_tco_word_term, \
4089 .put = snd_hdspm_put_tco_word_term \
4090 }
4091
4092 static int snd_hdspm_info_tco_word_term(struct snd_kcontrol *kcontrol,
4093 struct snd_ctl_elem_info *uinfo)
4094 {
4095 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
4096 uinfo->count = 1;
4097 uinfo->value.integer.min = 0;
4098 uinfo->value.integer.max = 1;
4099
4100 return 0;
4101 }
4102
4103
4104 static int snd_hdspm_get_tco_word_term(struct snd_kcontrol *kcontrol,
4105 struct snd_ctl_elem_value *ucontrol)
4106 {
4107 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4108
4109 ucontrol->value.enumerated.item[0] = hdspm->tco->term;
4110
4111 return 0;
4112 }
4113
4114
4115 static int snd_hdspm_put_tco_word_term(struct snd_kcontrol *kcontrol,
4116 struct snd_ctl_elem_value *ucontrol)
4117 {
4118 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
4119
4120 if (hdspm->tco->term != ucontrol->value.enumerated.item[0]) {
4121 hdspm->tco->term = ucontrol->value.enumerated.item[0];
4122
4123 hdspm_tco_write(hdspm);
4124
4125 return 1;
4126 }
4127
4128 return 0;
4129 }
4130
4131
4132
4133
4134 static struct snd_kcontrol_new snd_hdspm_controls_madi[] = {
4135 HDSPM_MIXER("Mixer", 0),
4136 HDSPM_INTERNAL_CLOCK("Internal Clock", 0),
4137 HDSPM_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
4138 HDSPM_PREF_SYNC_REF("Preferred Sync Reference", 0),
4139 HDSPM_AUTOSYNC_REF("AutoSync Reference", 0),
4140 HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
4141 HDSPM_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
4142 HDSPM_SYNC_CHECK("WC SyncCheck", 0),
4143 HDSPM_SYNC_CHECK("MADI SyncCheck", 1),
4144 HDSPM_SYNC_CHECK("TCO SyncCheck", 2),
4145 HDSPM_SYNC_CHECK("SYNC IN SyncCheck", 3),
4146 HDSPM_TOGGLE_SETTING("Line Out", HDSPM_LineOut),
4147 HDSPM_TOGGLE_SETTING("TX 64 channels mode", HDSPM_TX_64ch),
4148 HDSPM_TOGGLE_SETTING("Clear Track Marker", HDSPM_clr_tms),
4149 HDSPM_TOGGLE_SETTING("Safe Mode", HDSPM_AutoInp),
4150 HDSPM_INPUT_SELECT("Input Select", 0),
4151 HDSPM_MADI_SPEEDMODE("MADI Speed Mode", 0)
4152 };
4153
4154
4155 static struct snd_kcontrol_new snd_hdspm_controls_madiface[] = {
4156 HDSPM_MIXER("Mixer", 0),
4157 HDSPM_INTERNAL_CLOCK("Internal Clock", 0),
4158 HDSPM_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
4159 HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
4160 HDSPM_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
4161 HDSPM_SYNC_CHECK("MADI SyncCheck", 0),
4162 HDSPM_TOGGLE_SETTING("TX 64 channels mode", HDSPM_TX_64ch),
4163 HDSPM_TOGGLE_SETTING("Clear Track Marker", HDSPM_clr_tms),
4164 HDSPM_TOGGLE_SETTING("Safe Mode", HDSPM_AutoInp),
4165 HDSPM_MADI_SPEEDMODE("MADI Speed Mode", 0)
4166 };
4167
4168 static struct snd_kcontrol_new snd_hdspm_controls_aio[] = {
4169 HDSPM_MIXER("Mixer", 0),
4170 HDSPM_INTERNAL_CLOCK("Internal Clock", 0),
4171 HDSPM_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
4172 HDSPM_PREF_SYNC_REF("Preferred Sync Reference", 0),
4173 HDSPM_AUTOSYNC_REF("AutoSync Reference", 0),
4174 HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
4175 HDSPM_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
4176 HDSPM_SYNC_CHECK("WC SyncCheck", 0),
4177 HDSPM_SYNC_CHECK("AES SyncCheck", 1),
4178 HDSPM_SYNC_CHECK("SPDIF SyncCheck", 2),
4179 HDSPM_SYNC_CHECK("ADAT SyncCheck", 3),
4180 HDSPM_SYNC_CHECK("TCO SyncCheck", 4),
4181 HDSPM_SYNC_CHECK("SYNC IN SyncCheck", 5),
4182 HDSPM_AUTOSYNC_SAMPLE_RATE("WC Frequency", 0),
4183 HDSPM_AUTOSYNC_SAMPLE_RATE("AES Frequency", 1),
4184 HDSPM_AUTOSYNC_SAMPLE_RATE("SPDIF Frequency", 2),
4185 HDSPM_AUTOSYNC_SAMPLE_RATE("ADAT Frequency", 3),
4186 HDSPM_AUTOSYNC_SAMPLE_RATE("TCO Frequency", 4),
4187 HDSPM_AUTOSYNC_SAMPLE_RATE("SYNC IN Frequency", 5)
4188
4189 /*
4190 HDSPM_INPUT_SELECT("Input Select", 0),
4191 HDSPM_SPDIF_OPTICAL("SPDIF Out Optical", 0),
4192 HDSPM_PROFESSIONAL("SPDIF Out Professional", 0);
4193 HDSPM_SPDIF_IN("SPDIF In", 0);
4194 HDSPM_BREAKOUT_CABLE("Breakout Cable", 0);
4195 HDSPM_INPUT_LEVEL("Input Level", 0);
4196 HDSPM_OUTPUT_LEVEL("Output Level", 0);
4197 HDSPM_PHONES("Phones", 0);
4198 */
4199 };
4200
4201 static struct snd_kcontrol_new snd_hdspm_controls_raydat[] = {
4202 HDSPM_MIXER("Mixer", 0),
4203 HDSPM_INTERNAL_CLOCK("Internal Clock", 0),
4204 HDSPM_SYSTEM_CLOCK_MODE("Clock Mode", 0),
4205 HDSPM_PREF_SYNC_REF("Pref Sync Ref", 0),
4206 HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
4207 HDSPM_SYNC_CHECK("WC SyncCheck", 0),
4208 HDSPM_SYNC_CHECK("AES SyncCheck", 1),
4209 HDSPM_SYNC_CHECK("SPDIF SyncCheck", 2),
4210 HDSPM_SYNC_CHECK("ADAT1 SyncCheck", 3),
4211 HDSPM_SYNC_CHECK("ADAT2 SyncCheck", 4),
4212 HDSPM_SYNC_CHECK("ADAT3 SyncCheck", 5),
4213 HDSPM_SYNC_CHECK("ADAT4 SyncCheck", 6),
4214 HDSPM_SYNC_CHECK("TCO SyncCheck", 7),
4215 HDSPM_SYNC_CHECK("SYNC IN SyncCheck", 8),
4216 HDSPM_AUTOSYNC_SAMPLE_RATE("WC Frequency", 0),
4217 HDSPM_AUTOSYNC_SAMPLE_RATE("AES Frequency", 1),
4218 HDSPM_AUTOSYNC_SAMPLE_RATE("SPDIF Frequency", 2),
4219 HDSPM_AUTOSYNC_SAMPLE_RATE("ADAT1 Frequency", 3),
4220 HDSPM_AUTOSYNC_SAMPLE_RATE("ADAT2 Frequency", 4),
4221 HDSPM_AUTOSYNC_SAMPLE_RATE("ADAT3 Frequency", 5),
4222 HDSPM_AUTOSYNC_SAMPLE_RATE("ADAT4 Frequency", 6),
4223 HDSPM_AUTOSYNC_SAMPLE_RATE("TCO Frequency", 7),
4224 HDSPM_AUTOSYNC_SAMPLE_RATE("SYNC IN Frequency", 8)
4225 };
4226
4227 static struct snd_kcontrol_new snd_hdspm_controls_aes32[] = {
4228 HDSPM_MIXER("Mixer", 0),
4229 HDSPM_INTERNAL_CLOCK("Internal Clock", 0),
4230 HDSPM_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
4231 HDSPM_PREF_SYNC_REF("Preferred Sync Reference", 0),
4232 HDSPM_AUTOSYNC_REF("AutoSync Reference", 0),
4233 HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
4234 HDSPM_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
4235 HDSPM_SYNC_CHECK("WC Sync Check", 0),
4236 HDSPM_SYNC_CHECK("AES1 Sync Check", 1),
4237 HDSPM_SYNC_CHECK("AES2 Sync Check", 2),
4238 HDSPM_SYNC_CHECK("AES3 Sync Check", 3),
4239 HDSPM_SYNC_CHECK("AES4 Sync Check", 4),
4240 HDSPM_SYNC_CHECK("AES5 Sync Check", 5),
4241 HDSPM_SYNC_CHECK("AES6 Sync Check", 6),
4242 HDSPM_SYNC_CHECK("AES7 Sync Check", 7),
4243 HDSPM_SYNC_CHECK("AES8 Sync Check", 8),
4244 HDSPM_SYNC_CHECK("TCO Sync Check", 9),
4245 HDSPM_SYNC_CHECK("SYNC IN Sync Check", 10),
4246 HDSPM_AUTOSYNC_SAMPLE_RATE("WC Frequency", 0),
4247 HDSPM_AUTOSYNC_SAMPLE_RATE("AES1 Frequency", 1),
4248 HDSPM_AUTOSYNC_SAMPLE_RATE("AES2 Frequency", 2),
4249 HDSPM_AUTOSYNC_SAMPLE_RATE("AES3 Frequency", 3),
4250 HDSPM_AUTOSYNC_SAMPLE_RATE("AES4 Frequency", 4),
4251 HDSPM_AUTOSYNC_SAMPLE_RATE("AES5 Frequency", 5),
4252 HDSPM_AUTOSYNC_SAMPLE_RATE("AES6 Frequency", 6),
4253 HDSPM_AUTOSYNC_SAMPLE_RATE("AES7 Frequency", 7),
4254 HDSPM_AUTOSYNC_SAMPLE_RATE("AES8 Frequency", 8),
4255 HDSPM_AUTOSYNC_SAMPLE_RATE("TCO Frequency", 9),
4256 HDSPM_AUTOSYNC_SAMPLE_RATE("SYNC IN Frequency", 10),
4257 HDSPM_TOGGLE_SETTING("Line Out", HDSPM_LineOut),
4258 HDSPM_TOGGLE_SETTING("Emphasis", HDSPM_Emphasis),
4259 HDSPM_TOGGLE_SETTING("Non Audio", HDSPM_Dolby),
4260 HDSPM_TOGGLE_SETTING("Professional", HDSPM_Professional),
4261 HDSPM_TOGGLE_SETTING("Clear Track Marker", HDSPM_clr_tms),
4262 HDSPM_DS_WIRE("Double Speed Wire Mode", 0),
4263 HDSPM_QS_WIRE("Quad Speed Wire Mode", 0),
4264 };
4265
4266
4267
4268 /* Control elements for the optional TCO module */
4269 static struct snd_kcontrol_new snd_hdspm_controls_tco[] = {
4270 HDSPM_TCO_SAMPLE_RATE("TCO Sample Rate", 0),
4271 HDSPM_TCO_PULL("TCO Pull", 0),
4272 HDSPM_TCO_WCK_CONVERSION("TCO WCK Conversion", 0),
4273 HDSPM_TCO_FRAME_RATE("TCO Frame Rate", 0),
4274 HDSPM_TCO_SYNC_SOURCE("TCO Sync Source", 0),
4275 HDSPM_TCO_WORD_TERM("TCO Word Term", 0)
4276 };
4277
4278
4279 static struct snd_kcontrol_new snd_hdspm_playback_mixer = HDSPM_PLAYBACK_MIXER;
4280
4281
4282 static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm)
4283 {
4284 int i;
4285
4286 for (i = hdspm->ds_out_channels; i < hdspm->ss_out_channels; ++i) {
4287 if (hdspm->system_sample_rate > 48000) {
4288 hdspm->playback_mixer_ctls[i]->vd[0].access =
4289 SNDRV_CTL_ELEM_ACCESS_INACTIVE |
4290 SNDRV_CTL_ELEM_ACCESS_READ |
4291 SNDRV_CTL_ELEM_ACCESS_VOLATILE;
4292 } else {
4293 hdspm->playback_mixer_ctls[i]->vd[0].access =
4294 SNDRV_CTL_ELEM_ACCESS_READWRITE |
4295 SNDRV_CTL_ELEM_ACCESS_VOLATILE;
4296 }
4297 snd_ctl_notify(hdspm->card, SNDRV_CTL_EVENT_MASK_VALUE |
4298 SNDRV_CTL_EVENT_MASK_INFO,
4299 &hdspm->playback_mixer_ctls[i]->id);
4300 }
4301
4302 return 0;
4303 }
4304
4305
4306 static int snd_hdspm_create_controls(struct snd_card *card,
4307 struct hdspm *hdspm)
4308 {
4309 unsigned int idx, limit;
4310 int err;
4311 struct snd_kcontrol *kctl;
4312 struct snd_kcontrol_new *list = NULL;
4313
4314 switch (hdspm->io_type) {
4315 case MADI:
4316 list = snd_hdspm_controls_madi;
4317 limit = ARRAY_SIZE(snd_hdspm_controls_madi);
4318 break;
4319 case MADIface:
4320 list = snd_hdspm_controls_madiface;
4321 limit = ARRAY_SIZE(snd_hdspm_controls_madiface);
4322 break;
4323 case AIO:
4324 list = snd_hdspm_controls_aio;
4325 limit = ARRAY_SIZE(snd_hdspm_controls_aio);
4326 break;
4327 case RayDAT:
4328 list = snd_hdspm_controls_raydat;
4329 limit = ARRAY_SIZE(snd_hdspm_controls_raydat);
4330 break;
4331 case AES32:
4332 list = snd_hdspm_controls_aes32;
4333 limit = ARRAY_SIZE(snd_hdspm_controls_aes32);
4334 break;
4335 }
4336
4337 if (NULL != list) {
4338 for (idx = 0; idx < limit; idx++) {
4339 err = snd_ctl_add(card,
4340 snd_ctl_new1(&list[idx], hdspm));
4341 if (err < 0)
4342 return err;
4343 }
4344 }
4345
4346
4347 /* create simple 1:1 playback mixer controls */
4348 snd_hdspm_playback_mixer.name = "Chn";
4349 if (hdspm->system_sample_rate >= 128000) {
4350 limit = hdspm->qs_out_channels;
4351 } else if (hdspm->system_sample_rate >= 64000) {
4352 limit = hdspm->ds_out_channels;
4353 } else {
4354 limit = hdspm->ss_out_channels;
4355 }
4356 for (idx = 0; idx < limit; ++idx) {
4357 snd_hdspm_playback_mixer.index = idx + 1;
4358 kctl = snd_ctl_new1(&snd_hdspm_playback_mixer, hdspm);
4359 err = snd_ctl_add(card, kctl);
4360 if (err < 0)
4361 return err;
4362 hdspm->playback_mixer_ctls[idx] = kctl;
4363 }
4364
4365
4366 if (hdspm->tco) {
4367 /* add tco control elements */
4368 list = snd_hdspm_controls_tco;
4369 limit = ARRAY_SIZE(snd_hdspm_controls_tco);
4370 for (idx = 0; idx < limit; idx++) {
4371 err = snd_ctl_add(card,
4372 snd_ctl_new1(&list[idx], hdspm));
4373 if (err < 0)
4374 return err;
4375 }
4376 }
4377
4378 return 0;
4379 }
4380
4381 /*------------------------------------------------------------
4382 /proc interface
4383 ------------------------------------------------------------*/
4384
4385 static void
4386 snd_hdspm_proc_read_madi(struct snd_info_entry * entry,
4387 struct snd_info_buffer *buffer)
4388 {
4389 struct hdspm *hdspm = entry->private_data;
4390 unsigned int status, status2, control, freq;
4391
4392 char *pref_sync_ref;
4393 char *autosync_ref;
4394 char *system_clock_mode;
4395 char *insel;
4396 int x, x2;
4397
4398 /* TCO stuff */
4399 int a, ltc, frames, seconds, minutes, hours;
4400 unsigned int period;
4401 u64 freq_const = 0;
4402 u32 rate;
4403
4404 status = hdspm_read(hdspm, HDSPM_statusRegister);
4405 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
4406 control = hdspm->control_register;
4407 freq = hdspm_read(hdspm, HDSPM_timecodeRegister);
4408
4409 snd_iprintf(buffer, "%s (Card #%d) Rev.%x Status2first3bits: %x\n",
4410 hdspm->card_name, hdspm->card->number + 1,
4411 hdspm->firmware_rev,
4412 (status2 & HDSPM_version0) |
4413 (status2 & HDSPM_version1) | (status2 &
4414 HDSPM_version2));
4415
4416 snd_iprintf(buffer, "HW Serial: 0x%06x%06x\n",
4417 (hdspm_read(hdspm, HDSPM_midiStatusIn1)>>8) & 0xFFFFFF,
4418 hdspm->serial);
4419
4420 snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
4421 hdspm->irq, hdspm->port, (unsigned long)hdspm->iobase);
4422
4423 snd_iprintf(buffer, "--- System ---\n");
4424
4425 snd_iprintf(buffer,
4426 "IRQ Pending: Audio=%d, MIDI0=%d, MIDI1=%d, IRQcount=%d\n",
4427 status & HDSPM_audioIRQPending,
4428 (status & HDSPM_midi0IRQPending) ? 1 : 0,
4429 (status & HDSPM_midi1IRQPending) ? 1 : 0,
4430 hdspm->irq_count);
4431 snd_iprintf(buffer,
4432 "HW pointer: id = %d, rawptr = %d (%d->%d) "
4433 "estimated= %ld (bytes)\n",
4434 ((status & HDSPM_BufferID) ? 1 : 0),
4435 (status & HDSPM_BufferPositionMask),
4436 (status & HDSPM_BufferPositionMask) %
4437 (2 * (int)hdspm->period_bytes),
4438 ((status & HDSPM_BufferPositionMask) - 64) %
4439 (2 * (int)hdspm->period_bytes),
4440 (long) hdspm_hw_pointer(hdspm) * 4);
4441
4442 snd_iprintf(buffer,
4443 "MIDI FIFO: Out1=0x%x, Out2=0x%x, In1=0x%x, In2=0x%x \n",
4444 hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xFF,
4445 hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xFF,
4446 hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xFF,
4447 hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xFF);
4448 snd_iprintf(buffer,
4449 "MIDIoverMADI FIFO: In=0x%x, Out=0x%x \n",
4450 hdspm_read(hdspm, HDSPM_midiStatusIn2) & 0xFF,
4451 hdspm_read(hdspm, HDSPM_midiStatusOut2) & 0xFF);
4452 snd_iprintf(buffer,
4453 "Register: ctrl1=0x%x, ctrl2=0x%x, status1=0x%x, "
4454 "status2=0x%x\n",
4455 hdspm->control_register, hdspm->control2_register,
4456 status, status2);
4457 if (status & HDSPM_tco_detect) {
4458 snd_iprintf(buffer, "TCO module detected.\n");
4459 a = hdspm_read(hdspm, HDSPM_RD_TCO+4);
4460 if (a & HDSPM_TCO1_LTC_Input_valid) {
4461 snd_iprintf(buffer, " LTC valid, ");
4462 switch (a & (HDSPM_TCO1_LTC_Format_LSB |
4463 HDSPM_TCO1_LTC_Format_MSB)) {
4464 case 0:
4465 snd_iprintf(buffer, "24 fps, ");
4466 break;
4467 case HDSPM_TCO1_LTC_Format_LSB:
4468 snd_iprintf(buffer, "25 fps, ");
4469 break;
4470 case HDSPM_TCO1_LTC_Format_MSB:
4471 snd_iprintf(buffer, "29.97 fps, ");
4472 break;
4473 default:
4474 snd_iprintf(buffer, "30 fps, ");
4475 break;
4476 }
4477 if (a & HDSPM_TCO1_set_drop_frame_flag) {
4478 snd_iprintf(buffer, "drop frame\n");
4479 } else {
4480 snd_iprintf(buffer, "full frame\n");
4481 }
4482 } else {
4483 snd_iprintf(buffer, " no LTC\n");
4484 }
4485 if (a & HDSPM_TCO1_Video_Input_Format_NTSC) {
4486 snd_iprintf(buffer, " Video: NTSC\n");
4487 } else if (a & HDSPM_TCO1_Video_Input_Format_PAL) {
4488 snd_iprintf(buffer, " Video: PAL\n");
4489 } else {
4490 snd_iprintf(buffer, " No video\n");
4491 }
4492 if (a & HDSPM_TCO1_TCO_lock) {
4493 snd_iprintf(buffer, " Sync: lock\n");
4494 } else {
4495 snd_iprintf(buffer, " Sync: no lock\n");
4496 }
4497
4498 switch (hdspm->io_type) {
4499 case MADI:
4500 case AES32:
4501 freq_const = 110069313433624ULL;
4502 break;
4503 case RayDAT:
4504 case AIO:
4505 freq_const = 104857600000000ULL;
4506 break;
4507 case MADIface:
4508 break; /* no TCO possible */
4509 }
4510
4511 period = hdspm_read(hdspm, HDSPM_RD_PLL_FREQ);
4512 snd_iprintf(buffer, " period: %u\n", period);
4513
4514
4515 /* rate = freq_const/period; */
4516 rate = div_u64(freq_const, period);
4517
4518 if (control & HDSPM_QuadSpeed) {
4519 rate *= 4;
4520 } else if (control & HDSPM_DoubleSpeed) {
4521 rate *= 2;
4522 }
4523
4524 snd_iprintf(buffer, " Frequency: %u Hz\n",
4525 (unsigned int) rate);
4526
4527 ltc = hdspm_read(hdspm, HDSPM_RD_TCO);
4528 frames = ltc & 0xF;
4529 ltc >>= 4;
4530 frames += (ltc & 0x3) * 10;
4531 ltc >>= 4;
4532 seconds = ltc & 0xF;
4533 ltc >>= 4;
4534 seconds += (ltc & 0x7) * 10;
4535 ltc >>= 4;
4536 minutes = ltc & 0xF;
4537 ltc >>= 4;
4538 minutes += (ltc & 0x7) * 10;
4539 ltc >>= 4;
4540 hours = ltc & 0xF;
4541 ltc >>= 4;
4542 hours += (ltc & 0x3) * 10;
4543 snd_iprintf(buffer,
4544 " LTC In: %02d:%02d:%02d:%02d\n",
4545 hours, minutes, seconds, frames);
4546
4547 } else {
4548 snd_iprintf(buffer, "No TCO module detected.\n");
4549 }
4550
4551 snd_iprintf(buffer, "--- Settings ---\n");
4552
4553 x = hdspm_get_latency(hdspm);
4554
4555 snd_iprintf(buffer,
4556 "Size (Latency): %d samples (2 periods of %lu bytes)\n",
4557 x, (unsigned long) hdspm->period_bytes);
4558
4559 snd_iprintf(buffer, "Line out: %s\n",
4560 (hdspm->control_register & HDSPM_LineOut) ? "on " : "off");
4561
4562 switch (hdspm->control_register & HDSPM_InputMask) {
4563 case HDSPM_InputOptical:
4564 insel = "Optical";
4565 break;
4566 case HDSPM_InputCoaxial:
4567 insel = "Coaxial";
4568 break;
4569 default:
4570 insel = "Unknown";
4571 }
4572
4573 snd_iprintf(buffer,
4574 "ClearTrackMarker = %s, Transmit in %s Channel Mode, "
4575 "Auto Input %s\n",
4576 (hdspm->control_register & HDSPM_clr_tms) ? "on" : "off",
4577 (hdspm->control_register & HDSPM_TX_64ch) ? "64" : "56",
4578 (hdspm->control_register & HDSPM_AutoInp) ? "on" : "off");
4579
4580
4581 if (!(hdspm->control_register & HDSPM_ClockModeMaster))
4582 system_clock_mode = "AutoSync";
4583 else
4584 system_clock_mode = "Master";
4585 snd_iprintf(buffer, "AutoSync Reference: %s\n", system_clock_mode);
4586
4587 switch (hdspm_pref_sync_ref(hdspm)) {
4588 case HDSPM_SYNC_FROM_WORD:
4589 pref_sync_ref = "Word Clock";
4590 break;
4591 case HDSPM_SYNC_FROM_MADI:
4592 pref_sync_ref = "MADI Sync";
4593 break;
4594 case HDSPM_SYNC_FROM_TCO:
4595 pref_sync_ref = "TCO";
4596 break;
4597 case HDSPM_SYNC_FROM_SYNC_IN:
4598 pref_sync_ref = "Sync In";
4599 break;
4600 default:
4601 pref_sync_ref = "XXXX Clock";
4602 break;
4603 }
4604 snd_iprintf(buffer, "Preferred Sync Reference: %s\n",
4605 pref_sync_ref);
4606
4607 snd_iprintf(buffer, "System Clock Frequency: %d\n",
4608 hdspm->system_sample_rate);
4609
4610
4611 snd_iprintf(buffer, "--- Status:\n");
4612
4613 x = status & HDSPM_madiSync;
4614 x2 = status2 & HDSPM_wcSync;
4615
4616 snd_iprintf(buffer, "Inputs MADI=%s, WordClock=%s\n",
4617 (status & HDSPM_madiLock) ? (x ? "Sync" : "Lock") :
4618 "NoLock",
4619 (status2 & HDSPM_wcLock) ? (x2 ? "Sync" : "Lock") :
4620 "NoLock");
4621
4622 switch (hdspm_autosync_ref(hdspm)) {
4623 case HDSPM_AUTOSYNC_FROM_SYNC_IN:
4624 autosync_ref = "Sync In";
4625 break;
4626 case HDSPM_AUTOSYNC_FROM_TCO:
4627 autosync_ref = "TCO";
4628 break;
4629 case HDSPM_AUTOSYNC_FROM_WORD:
4630 autosync_ref = "Word Clock";
4631 break;
4632 case HDSPM_AUTOSYNC_FROM_MADI:
4633 autosync_ref = "MADI Sync";
4634 break;
4635 case HDSPM_AUTOSYNC_FROM_NONE:
4636 autosync_ref = "Input not valid";
4637 break;
4638 default:
4639 autosync_ref = "---";
4640 break;
4641 }
4642 snd_iprintf(buffer,
4643 "AutoSync: Reference= %s, Freq=%d (MADI = %d, Word = %d)\n",
4644 autosync_ref, hdspm_external_sample_rate(hdspm),
4645 (status & HDSPM_madiFreqMask) >> 22,
4646 (status2 & HDSPM_wcFreqMask) >> 5);
4647
4648 snd_iprintf(buffer, "Input: %s, Mode=%s\n",
4649 (status & HDSPM_AB_int) ? "Coax" : "Optical",
4650 (status & HDSPM_RX_64ch) ? "64 channels" :
4651 "56 channels");
4652
4653 snd_iprintf(buffer, "\n");
4654 }
4655
4656 static void
4657 snd_hdspm_proc_read_aes32(struct snd_info_entry * entry,
4658 struct snd_info_buffer *buffer)
4659 {
4660 struct hdspm *hdspm = entry->private_data;
4661 unsigned int status;
4662 unsigned int status2;
4663 unsigned int timecode;
4664 unsigned int wcLock, wcSync;
4665 int pref_syncref;
4666 char *autosync_ref;
4667 int x;
4668
4669 status = hdspm_read(hdspm, HDSPM_statusRegister);
4670 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
4671 timecode = hdspm_read(hdspm, HDSPM_timecodeRegister);
4672
4673 snd_iprintf(buffer, "%s (Card #%d) Rev.%x\n",
4674 hdspm->card_name, hdspm->card->number + 1,
4675 hdspm->firmware_rev);
4676
4677 snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
4678 hdspm->irq, hdspm->port, (unsigned long)hdspm->iobase);
4679
4680 snd_iprintf(buffer, "--- System ---\n");
4681
4682 snd_iprintf(buffer,
4683 "IRQ Pending: Audio=%d, MIDI0=%d, MIDI1=%d, IRQcount=%d\n",
4684 status & HDSPM_audioIRQPending,
4685 (status & HDSPM_midi0IRQPending) ? 1 : 0,
4686 (status & HDSPM_midi1IRQPending) ? 1 : 0,
4687 hdspm->irq_count);
4688 snd_iprintf(buffer,
4689 "HW pointer: id = %d, rawptr = %d (%d->%d) "
4690 "estimated= %ld (bytes)\n",
4691 ((status & HDSPM_BufferID) ? 1 : 0),
4692 (status & HDSPM_BufferPositionMask),
4693 (status & HDSPM_BufferPositionMask) %
4694 (2 * (int)hdspm->period_bytes),
4695 ((status & HDSPM_BufferPositionMask) - 64) %
4696 (2 * (int)hdspm->period_bytes),
4697 (long) hdspm_hw_pointer(hdspm) * 4);
4698
4699 snd_iprintf(buffer,
4700 "MIDI FIFO: Out1=0x%x, Out2=0x%x, In1=0x%x, In2=0x%x \n",
4701 hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xFF,
4702 hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xFF,
4703 hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xFF,
4704 hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xFF);
4705 snd_iprintf(buffer,
4706 "MIDIoverMADI FIFO: In=0x%x, Out=0x%x \n",
4707 hdspm_read(hdspm, HDSPM_midiStatusIn2) & 0xFF,
4708 hdspm_read(hdspm, HDSPM_midiStatusOut2) & 0xFF);
4709 snd_iprintf(buffer,
4710 "Register: ctrl1=0x%x, ctrl2=0x%x, status1=0x%x, "
4711 "status2=0x%x\n",
4712 hdspm->control_register, hdspm->control2_register,
4713 status, status2);
4714
4715 snd_iprintf(buffer, "--- Settings ---\n");
4716
4717 x = hdspm_get_latency(hdspm);
4718
4719 snd_iprintf(buffer,
4720 "Size (Latency): %d samples (2 periods of %lu bytes)\n",
4721 x, (unsigned long) hdspm->period_bytes);
4722
4723 snd_iprintf(buffer, "Line out: %s\n",
4724 (hdspm->
4725 control_register & HDSPM_LineOut) ? "on " : "off");
4726
4727 snd_iprintf(buffer,
4728 "ClearTrackMarker %s, Emphasis %s, Dolby %s\n",
4729 (hdspm->
4730 control_register & HDSPM_clr_tms) ? "on" : "off",
4731 (hdspm->
4732 control_register & HDSPM_Emphasis) ? "on" : "off",
4733 (hdspm->
4734 control_register & HDSPM_Dolby) ? "on" : "off");
4735
4736
4737 pref_syncref = hdspm_pref_sync_ref(hdspm);
4738 if (pref_syncref == 0)
4739 snd_iprintf(buffer, "Preferred Sync Reference: Word Clock\n");
4740 else
4741 snd_iprintf(buffer, "Preferred Sync Reference: AES%d\n",
4742 pref_syncref);
4743
4744 snd_iprintf(buffer, "System Clock Frequency: %d\n",
4745 hdspm->system_sample_rate);
4746
4747 snd_iprintf(buffer, "Double speed: %s\n",
4748 hdspm->control_register & HDSPM_DS_DoubleWire?
4749 "Double wire" : "Single wire");
4750 snd_iprintf(buffer, "Quad speed: %s\n",
4751 hdspm->control_register & HDSPM_QS_DoubleWire?
4752 "Double wire" :
4753 hdspm->control_register & HDSPM_QS_QuadWire?
4754 "Quad wire" : "Single wire");
4755
4756 snd_iprintf(buffer, "--- Status:\n");
4757
4758 wcLock = status & HDSPM_AES32_wcLock;
4759 wcSync = wcLock && (status & HDSPM_AES32_wcSync);
4760
4761 snd_iprintf(buffer, "Word: %s Frequency: %d\n",
4762 (wcLock) ? (wcSync ? "Sync " : "Lock ") : "No Lock",
4763 HDSPM_bit2freq((status >> HDSPM_AES32_wcFreq_bit) & 0xF));
4764
4765 for (x = 0; x < 8; x++) {
4766 snd_iprintf(buffer, "AES%d: %s Frequency: %d\n",
4767 x+1,
4768 (status2 & (HDSPM_LockAES >> x)) ?
4769 "Sync " : "No Lock",
4770 HDSPM_bit2freq((timecode >> (4*x)) & 0xF));
4771 }
4772
4773 switch (hdspm_autosync_ref(hdspm)) {
4774 case HDSPM_AES32_AUTOSYNC_FROM_NONE:
4775 autosync_ref = "None"; break;
4776 case HDSPM_AES32_AUTOSYNC_FROM_WORD:
4777 autosync_ref = "Word Clock"; break;
4778 case HDSPM_AES32_AUTOSYNC_FROM_AES1:
4779 autosync_ref = "AES1"; break;
4780 case HDSPM_AES32_AUTOSYNC_FROM_AES2:
4781 autosync_ref = "AES2"; break;
4782 case HDSPM_AES32_AUTOSYNC_FROM_AES3:
4783 autosync_ref = "AES3"; break;
4784 case HDSPM_AES32_AUTOSYNC_FROM_AES4:
4785 autosync_ref = "AES4"; break;
4786 case HDSPM_AES32_AUTOSYNC_FROM_AES5:
4787 autosync_ref = "AES5"; break;
4788 case HDSPM_AES32_AUTOSYNC_FROM_AES6:
4789 autosync_ref = "AES6"; break;
4790 case HDSPM_AES32_AUTOSYNC_FROM_AES7:
4791 autosync_ref = "AES7"; break;
4792 case HDSPM_AES32_AUTOSYNC_FROM_AES8:
4793 autosync_ref = "AES8"; break;
4794 default:
4795 autosync_ref = "---"; break;
4796 }
4797 snd_iprintf(buffer, "AutoSync ref = %s\n", autosync_ref);
4798
4799 snd_iprintf(buffer, "\n");
4800 }
4801
4802 static void
4803 snd_hdspm_proc_read_raydat(struct snd_info_entry *entry,
4804 struct snd_info_buffer *buffer)
4805 {
4806 struct hdspm *hdspm = entry->private_data;
4807 unsigned int status1, status2, status3, control, i;
4808 unsigned int lock, sync;
4809
4810 status1 = hdspm_read(hdspm, HDSPM_RD_STATUS_1); /* s1 */
4811 status2 = hdspm_read(hdspm, HDSPM_RD_STATUS_2); /* freq */
4812 status3 = hdspm_read(hdspm, HDSPM_RD_STATUS_3); /* s2 */
4813
4814 control = hdspm->control_register;
4815
4816 snd_iprintf(buffer, "STATUS1: 0x%08x\n", status1);
4817 snd_iprintf(buffer, "STATUS2: 0x%08x\n", status2);
4818 snd_iprintf(buffer, "STATUS3: 0x%08x\n", status3);
4819
4820
4821 snd_iprintf(buffer, "\n*** CLOCK MODE\n\n");
4822
4823 snd_iprintf(buffer, "Clock mode : %s\n",
4824 (hdspm_system_clock_mode(hdspm) == 0) ? "master" : "slave");
4825 snd_iprintf(buffer, "System frequency: %d Hz\n",
4826 hdspm_get_system_sample_rate(hdspm));
4827
4828 snd_iprintf(buffer, "\n*** INPUT STATUS\n\n");
4829
4830 lock = 0x1;
4831 sync = 0x100;
4832
4833 for (i = 0; i < 8; i++) {
4834 snd_iprintf(buffer, "s1_input %d: Lock %d, Sync %d, Freq %s\n",
4835 i,
4836 (status1 & lock) ? 1 : 0,
4837 (status1 & sync) ? 1 : 0,
4838 texts_freq[(status2 >> (i * 4)) & 0xF]);
4839
4840 lock = lock<<1;
4841 sync = sync<<1;
4842 }
4843
4844 snd_iprintf(buffer, "WC input: Lock %d, Sync %d, Freq %s\n",
4845 (status1 & 0x1000000) ? 1 : 0,
4846 (status1 & 0x2000000) ? 1 : 0,
4847 texts_freq[(status1 >> 16) & 0xF]);
4848
4849 snd_iprintf(buffer, "TCO input: Lock %d, Sync %d, Freq %s\n",
4850 (status1 & 0x4000000) ? 1 : 0,
4851 (status1 & 0x8000000) ? 1 : 0,
4852 texts_freq[(status1 >> 20) & 0xF]);
4853
4854 snd_iprintf(buffer, "SYNC IN: Lock %d, Sync %d, Freq %s\n",
4855 (status3 & 0x400) ? 1 : 0,
4856 (status3 & 0x800) ? 1 : 0,
4857 texts_freq[(status2 >> 12) & 0xF]);
4858
4859 }
4860
4861 #ifdef CONFIG_SND_DEBUG
4862 static void
4863 snd_hdspm_proc_read_debug(struct snd_info_entry *entry,
4864 struct snd_info_buffer *buffer)
4865 {
4866 struct hdspm *hdspm = entry->private_data;
4867
4868 int j,i;
4869
4870 for (i = 0; i < 256 /* 1024*64 */; i += j) {
4871 snd_iprintf(buffer, "0x%08X: ", i);
4872 for (j = 0; j < 16; j += 4)
4873 snd_iprintf(buffer, "%08X ", hdspm_read(hdspm, i + j));
4874 snd_iprintf(buffer, "\n");
4875 }
4876 }
4877 #endif
4878
4879
4880 static void snd_hdspm_proc_ports_in(struct snd_info_entry *entry,
4881 struct snd_info_buffer *buffer)
4882 {
4883 struct hdspm *hdspm = entry->private_data;
4884 int i;
4885
4886 snd_iprintf(buffer, "# generated by hdspm\n");
4887
4888 for (i = 0; i < hdspm->max_channels_in; i++) {
4889 snd_iprintf(buffer, "%d=%s\n", i+1, hdspm->port_names_in[i]);
4890 }
4891 }
4892
4893 static void snd_hdspm_proc_ports_out(struct snd_info_entry *entry,
4894 struct snd_info_buffer *buffer)
4895 {
4896 struct hdspm *hdspm = entry->private_data;
4897 int i;
4898
4899 snd_iprintf(buffer, "# generated by hdspm\n");
4900
4901 for (i = 0; i < hdspm->max_channels_out; i++) {
4902 snd_iprintf(buffer, "%d=%s\n", i+1, hdspm->port_names_out[i]);
4903 }
4904 }
4905
4906
4907 static void snd_hdspm_proc_init(struct hdspm *hdspm)
4908 {
4909 struct snd_info_entry *entry;
4910
4911 if (!snd_card_proc_new(hdspm->card, "hdspm", &entry)) {
4912 switch (hdspm->io_type) {
4913 case AES32:
4914 snd_info_set_text_ops(entry, hdspm,
4915 snd_hdspm_proc_read_aes32);
4916 break;
4917 case MADI:
4918 snd_info_set_text_ops(entry, hdspm,
4919 snd_hdspm_proc_read_madi);
4920 break;
4921 case MADIface:
4922 /* snd_info_set_text_ops(entry, hdspm,
4923 snd_hdspm_proc_read_madiface); */
4924 break;
4925 case RayDAT:
4926 snd_info_set_text_ops(entry, hdspm,
4927 snd_hdspm_proc_read_raydat);
4928 break;
4929 case AIO:
4930 break;
4931 }
4932 }
4933
4934 if (!snd_card_proc_new(hdspm->card, "ports.in", &entry)) {
4935 snd_info_set_text_ops(entry, hdspm, snd_hdspm_proc_ports_in);
4936 }
4937
4938 if (!snd_card_proc_new(hdspm->card, "ports.out", &entry)) {
4939 snd_info_set_text_ops(entry, hdspm, snd_hdspm_proc_ports_out);
4940 }
4941
4942 #ifdef CONFIG_SND_DEBUG
4943 /* debug file to read all hdspm registers */
4944 if (!snd_card_proc_new(hdspm->card, "debug", &entry))
4945 snd_info_set_text_ops(entry, hdspm,
4946 snd_hdspm_proc_read_debug);
4947 #endif
4948 }
4949
4950 /*------------------------------------------------------------
4951 hdspm intitialize
4952 ------------------------------------------------------------*/
4953
4954 static int snd_hdspm_set_defaults(struct hdspm * hdspm)
4955 {
4956 /* ASSUMPTION: hdspm->lock is either held, or there is no need to
4957 hold it (e.g. during module initialization).
4958 */
4959
4960 /* set defaults: */
4961
4962 hdspm->settings_register = 0;
4963
4964 switch (hdspm->io_type) {
4965 case MADI:
4966 case MADIface:
4967 hdspm->control_register =
4968 0x2 + 0x8 + 0x10 + 0x80 + 0x400 + 0x4000 + 0x1000000;
4969 break;
4970
4971 case RayDAT:
4972 case AIO:
4973 hdspm->settings_register = 0x1 + 0x1000;
4974 /* Magic values are: LAT_0, LAT_2, Master, freq1, tx64ch, inp_0,
4975 * line_out */
4976 hdspm->control_register =
4977 0x2 + 0x8 + 0x10 + 0x80 + 0x400 + 0x4000 + 0x1000000;
4978 break;
4979
4980 case AES32:
4981 hdspm->control_register =
4982 HDSPM_ClockModeMaster | /* Master Cloack Mode on */
4983 hdspm_encode_latency(7) | /* latency max=8192samples */
4984 HDSPM_SyncRef0 | /* AES1 is syncclock */
4985 HDSPM_LineOut | /* Analog output in */
4986 HDSPM_Professional; /* Professional mode */
4987 break;
4988 }
4989
4990 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
4991
4992 if (AES32 == hdspm->io_type) {
4993 /* No control2 register for AES32 */
4994 #ifdef SNDRV_BIG_ENDIAN
4995 hdspm->control2_register = HDSPM_BIGENDIAN_MODE;
4996 #else
4997 hdspm->control2_register = 0;
4998 #endif
4999
5000 hdspm_write(hdspm, HDSPM_control2Reg, hdspm->control2_register);
5001 }
5002 hdspm_compute_period_size(hdspm);
5003
5004 /* silence everything */
5005
5006 all_in_all_mixer(hdspm, 0 * UNITY_GAIN);
5007
5008 if (hdspm->io_type == AIO || hdspm->io_type == RayDAT) {
5009 hdspm_write(hdspm, HDSPM_WR_SETTINGS, hdspm->settings_register);
5010 }
5011
5012 /* set a default rate so that the channel map is set up. */
5013 hdspm_set_rate(hdspm, 48000, 1);
5014
5015 return 0;
5016 }
5017
5018
5019 /*------------------------------------------------------------
5020 interrupt
5021 ------------------------------------------------------------*/
5022
5023 static irqreturn_t snd_hdspm_interrupt(int irq, void *dev_id)
5024 {
5025 struct hdspm *hdspm = (struct hdspm *) dev_id;
5026 unsigned int status;
5027 int i, audio, midi, schedule = 0;
5028 /* cycles_t now; */
5029
5030 status = hdspm_read(hdspm, HDSPM_statusRegister);
5031
5032 audio = status & HDSPM_audioIRQPending;
5033 midi = status & (HDSPM_midi0IRQPending | HDSPM_midi1IRQPending |
5034 HDSPM_midi2IRQPending | HDSPM_midi3IRQPending);
5035
5036 /* now = get_cycles(); */
5037 /**
5038 * LAT_2..LAT_0 period counter (win) counter (mac)
5039 * 6 4096 ~256053425 ~514672358
5040 * 5 2048 ~128024983 ~257373821
5041 * 4 1024 ~64023706 ~128718089
5042 * 3 512 ~32005945 ~64385999
5043 * 2 256 ~16003039 ~32260176
5044 * 1 128 ~7998738 ~16194507
5045 * 0 64 ~3998231 ~8191558
5046 **/
5047 /*
5048 snd_printk(KERN_INFO "snd_hdspm_interrupt %llu @ %llx\n",
5049 now-hdspm->last_interrupt, status & 0xFFC0);
5050 hdspm->last_interrupt = now;
5051 */
5052
5053 if (!audio && !midi)
5054 return IRQ_NONE;
5055
5056 hdspm_write(hdspm, HDSPM_interruptConfirmation, 0);
5057 hdspm->irq_count++;
5058
5059
5060 if (audio) {
5061 if (hdspm->capture_substream)
5062 snd_pcm_period_elapsed(hdspm->capture_substream);
5063
5064 if (hdspm->playback_substream)
5065 snd_pcm_period_elapsed(hdspm->playback_substream);
5066 }
5067
5068 if (midi) {
5069 i = 0;
5070 while (i < hdspm->midiPorts) {
5071 if ((hdspm_read(hdspm,
5072 hdspm->midi[i].statusIn) & 0xff) &&
5073 (status & hdspm->midi[i].irq)) {
5074 /* we disable interrupts for this input until
5075 * processing is done
5076 */
5077 hdspm->control_register &= ~hdspm->midi[i].ie;
5078 hdspm_write(hdspm, HDSPM_controlRegister,
5079 hdspm->control_register);
5080 hdspm->midi[i].pending = 1;
5081 schedule = 1;
5082 }
5083
5084 i++;
5085 }
5086
5087 if (schedule)
5088 tasklet_hi_schedule(&hdspm->midi_tasklet);
5089 }
5090
5091 return IRQ_HANDLED;
5092 }
5093
5094 /*------------------------------------------------------------
5095 pcm interface
5096 ------------------------------------------------------------*/
5097
5098
5099 static snd_pcm_uframes_t snd_hdspm_hw_pointer(struct snd_pcm_substream
5100 *substream)
5101 {
5102 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5103 return hdspm_hw_pointer(hdspm);
5104 }
5105
5106
5107 static int snd_hdspm_reset(struct snd_pcm_substream *substream)
5108 {
5109 struct snd_pcm_runtime *runtime = substream->runtime;
5110 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5111 struct snd_pcm_substream *other;
5112
5113 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
5114 other = hdspm->capture_substream;
5115 else
5116 other = hdspm->playback_substream;
5117
5118 if (hdspm->running)
5119 runtime->status->hw_ptr = hdspm_hw_pointer(hdspm);
5120 else
5121 runtime->status->hw_ptr = 0;
5122 if (other) {
5123 struct snd_pcm_substream *s;
5124 struct snd_pcm_runtime *oruntime = other->runtime;
5125 snd_pcm_group_for_each_entry(s, substream) {
5126 if (s == other) {
5127 oruntime->status->hw_ptr =
5128 runtime->status->hw_ptr;
5129 break;
5130 }
5131 }
5132 }
5133 return 0;
5134 }
5135
5136 static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
5137 struct snd_pcm_hw_params *params)
5138 {
5139 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5140 int err;
5141 int i;
5142 pid_t this_pid;
5143 pid_t other_pid;
5144
5145 spin_lock_irq(&hdspm->lock);
5146
5147 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
5148 this_pid = hdspm->playback_pid;
5149 other_pid = hdspm->capture_pid;
5150 } else {
5151 this_pid = hdspm->capture_pid;
5152 other_pid = hdspm->playback_pid;
5153 }
5154
5155 if (other_pid > 0 && this_pid != other_pid) {
5156
5157 /* The other stream is open, and not by the same
5158 task as this one. Make sure that the parameters
5159 that matter are the same.
5160 */
5161
5162 if (params_rate(params) != hdspm->system_sample_rate) {
5163 spin_unlock_irq(&hdspm->lock);
5164 _snd_pcm_hw_param_setempty(params,
5165 SNDRV_PCM_HW_PARAM_RATE);
5166 return -EBUSY;
5167 }
5168
5169 if (params_period_size(params) != hdspm->period_bytes / 4) {
5170 spin_unlock_irq(&hdspm->lock);
5171 _snd_pcm_hw_param_setempty(params,
5172 SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
5173 return -EBUSY;
5174 }
5175
5176 }
5177 /* We're fine. */
5178 spin_unlock_irq(&hdspm->lock);
5179
5180 /* how to make sure that the rate matches an externally-set one ? */
5181
5182 spin_lock_irq(&hdspm->lock);
5183 err = hdspm_set_rate(hdspm, params_rate(params), 0);
5184 if (err < 0) {
5185 snd_printk(KERN_INFO "err on hdspm_set_rate: %d\n", err);
5186 spin_unlock_irq(&hdspm->lock);
5187 _snd_pcm_hw_param_setempty(params,
5188 SNDRV_PCM_HW_PARAM_RATE);
5189 return err;
5190 }
5191 spin_unlock_irq(&hdspm->lock);
5192
5193 err = hdspm_set_interrupt_interval(hdspm,
5194 params_period_size(params));
5195 if (err < 0) {
5196 snd_printk(KERN_INFO "err on hdspm_set_interrupt_interval: %d\n", err);
5197 _snd_pcm_hw_param_setempty(params,
5198 SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
5199 return err;
5200 }
5201
5202 /* Memory allocation, takashi's method, dont know if we should
5203 * spinlock
5204 */
5205 /* malloc all buffer even if not enabled to get sure */
5206 /* Update for MADI rev 204: we need to allocate for all channels,
5207 * otherwise it doesn't work at 96kHz */
5208
5209 err =
5210 snd_pcm_lib_malloc_pages(substream, HDSPM_DMA_AREA_BYTES);
5211 if (err < 0) {
5212 snd_printk(KERN_INFO "err on snd_pcm_lib_malloc_pages: %d\n", err);
5213 return err;
5214 }
5215
5216 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
5217
5218 hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferOut,
5219 params_channels(params));
5220
5221 for (i = 0; i < params_channels(params); ++i)
5222 snd_hdspm_enable_out(hdspm, i, 1);
5223
5224 hdspm->playback_buffer =
5225 (unsigned char *) substream->runtime->dma_area;
5226 snd_printdd("Allocated sample buffer for playback at %p\n",
5227 hdspm->playback_buffer);
5228 } else {
5229 hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferIn,
5230 params_channels(params));
5231
5232 for (i = 0; i < params_channels(params); ++i)
5233 snd_hdspm_enable_in(hdspm, i, 1);
5234
5235 hdspm->capture_buffer =
5236 (unsigned char *) substream->runtime->dma_area;
5237 snd_printdd("Allocated sample buffer for capture at %p\n",
5238 hdspm->capture_buffer);
5239 }
5240
5241 /*
5242 snd_printdd("Allocated sample buffer for %s at 0x%08X\n",
5243 substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
5244 "playback" : "capture",
5245 snd_pcm_sgbuf_get_addr(substream, 0));
5246 */
5247 /*
5248 snd_printdd("set_hwparams: %s %d Hz, %d channels, bs = %d\n",
5249 substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
5250 "playback" : "capture",
5251 params_rate(params), params_channels(params),
5252 params_buffer_size(params));
5253 */
5254
5255
5256 /* Switch to native float format if requested */
5257 if (SNDRV_PCM_FORMAT_FLOAT_LE == params_format(params)) {
5258 if (!(hdspm->control_register & HDSPe_FLOAT_FORMAT))
5259 snd_printk(KERN_INFO "hdspm: Switching to native 32bit LE float format.\n");
5260
5261 hdspm->control_register |= HDSPe_FLOAT_FORMAT;
5262 } else if (SNDRV_PCM_FORMAT_S32_LE == params_format(params)) {
5263 if (hdspm->control_register & HDSPe_FLOAT_FORMAT)
5264 snd_printk(KERN_INFO "hdspm: Switching to native 32bit LE integer format.\n");
5265
5266 hdspm->control_register &= ~HDSPe_FLOAT_FORMAT;
5267 }
5268 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
5269
5270 return 0;
5271 }
5272
5273 static int snd_hdspm_hw_free(struct snd_pcm_substream *substream)
5274 {
5275 int i;
5276 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5277
5278 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
5279
5280 /* params_channels(params) should be enough,
5281 but to get sure in case of error */
5282 for (i = 0; i < hdspm->max_channels_out; ++i)
5283 snd_hdspm_enable_out(hdspm, i, 0);
5284
5285 hdspm->playback_buffer = NULL;
5286 } else {
5287 for (i = 0; i < hdspm->max_channels_in; ++i)
5288 snd_hdspm_enable_in(hdspm, i, 0);
5289
5290 hdspm->capture_buffer = NULL;
5291
5292 }
5293
5294 snd_pcm_lib_free_pages(substream);
5295
5296 return 0;
5297 }
5298
5299
5300 static int snd_hdspm_channel_info(struct snd_pcm_substream *substream,
5301 struct snd_pcm_channel_info *info)
5302 {
5303 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5304
5305 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
5306 if (snd_BUG_ON(info->channel >= hdspm->max_channels_out)) {
5307 snd_printk(KERN_INFO "snd_hdspm_channel_info: output channel out of range (%d)\n", info->channel);
5308 return -EINVAL;
5309 }
5310
5311 if (hdspm->channel_map_out[info->channel] < 0) {
5312 snd_printk(KERN_INFO "snd_hdspm_channel_info: output channel %d mapped out\n", info->channel);
5313 return -EINVAL;
5314 }
5315
5316 info->offset = hdspm->channel_map_out[info->channel] *
5317 HDSPM_CHANNEL_BUFFER_BYTES;
5318 } else {
5319 if (snd_BUG_ON(info->channel >= hdspm->max_channels_in)) {
5320 snd_printk(KERN_INFO "snd_hdspm_channel_info: input channel out of range (%d)\n", info->channel);
5321 return -EINVAL;
5322 }
5323
5324 if (hdspm->channel_map_in[info->channel] < 0) {
5325 snd_printk(KERN_INFO "snd_hdspm_channel_info: input channel %d mapped out\n", info->channel);
5326 return -EINVAL;
5327 }
5328
5329 info->offset = hdspm->channel_map_in[info->channel] *
5330 HDSPM_CHANNEL_BUFFER_BYTES;
5331 }
5332
5333 info->first = 0;
5334 info->step = 32;
5335 return 0;
5336 }
5337
5338
5339 static int snd_hdspm_ioctl(struct snd_pcm_substream *substream,
5340 unsigned int cmd, void *arg)
5341 {
5342 switch (cmd) {
5343 case SNDRV_PCM_IOCTL1_RESET:
5344 return snd_hdspm_reset(substream);
5345
5346 case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
5347 {
5348 struct snd_pcm_channel_info *info = arg;
5349 return snd_hdspm_channel_info(substream, info);
5350 }
5351 default:
5352 break;
5353 }
5354
5355 return snd_pcm_lib_ioctl(substream, cmd, arg);
5356 }
5357
5358 static int snd_hdspm_trigger(struct snd_pcm_substream *substream, int cmd)
5359 {
5360 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5361 struct snd_pcm_substream *other;
5362 int running;
5363
5364 spin_lock(&hdspm->lock);
5365 running = hdspm->running;
5366 switch (cmd) {
5367 case SNDRV_PCM_TRIGGER_START:
5368 running |= 1 << substream->stream;
5369 break;
5370 case SNDRV_PCM_TRIGGER_STOP:
5371 running &= ~(1 << substream->stream);
5372 break;
5373 default:
5374 snd_BUG();
5375 spin_unlock(&hdspm->lock);
5376 return -EINVAL;
5377 }
5378 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
5379 other = hdspm->capture_substream;
5380 else
5381 other = hdspm->playback_substream;
5382
5383 if (other) {
5384 struct snd_pcm_substream *s;
5385 snd_pcm_group_for_each_entry(s, substream) {
5386 if (s == other) {
5387 snd_pcm_trigger_done(s, substream);
5388 if (cmd == SNDRV_PCM_TRIGGER_START)
5389 running |= 1 << s->stream;
5390 else
5391 running &= ~(1 << s->stream);
5392 goto _ok;
5393 }
5394 }
5395 if (cmd == SNDRV_PCM_TRIGGER_START) {
5396 if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK))
5397 && substream->stream ==
5398 SNDRV_PCM_STREAM_CAPTURE)
5399 hdspm_silence_playback(hdspm);
5400 } else {
5401 if (running &&
5402 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
5403 hdspm_silence_playback(hdspm);
5404 }
5405 } else {
5406 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
5407 hdspm_silence_playback(hdspm);
5408 }
5409 _ok:
5410 snd_pcm_trigger_done(substream, substream);
5411 if (!hdspm->running && running)
5412 hdspm_start_audio(hdspm);
5413 else if (hdspm->running && !running)
5414 hdspm_stop_audio(hdspm);
5415 hdspm->running = running;
5416 spin_unlock(&hdspm->lock);
5417
5418 return 0;
5419 }
5420
5421 static int snd_hdspm_prepare(struct snd_pcm_substream *substream)
5422 {
5423 return 0;
5424 }
5425
5426 static struct snd_pcm_hardware snd_hdspm_playback_subinfo = {
5427 .info = (SNDRV_PCM_INFO_MMAP |
5428 SNDRV_PCM_INFO_MMAP_VALID |
5429 SNDRV_PCM_INFO_NONINTERLEAVED |
5430 SNDRV_PCM_INFO_SYNC_START | SNDRV_PCM_INFO_DOUBLE),
5431 .formats = SNDRV_PCM_FMTBIT_S32_LE,
5432 .rates = (SNDRV_PCM_RATE_32000 |
5433 SNDRV_PCM_RATE_44100 |
5434 SNDRV_PCM_RATE_48000 |
5435 SNDRV_PCM_RATE_64000 |
5436 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
5437 SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000 ),
5438 .rate_min = 32000,
5439 .rate_max = 192000,
5440 .channels_min = 1,
5441 .channels_max = HDSPM_MAX_CHANNELS,
5442 .buffer_bytes_max =
5443 HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
5444 .period_bytes_min = (32 * 4),
5445 .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
5446 .periods_min = 2,
5447 .periods_max = 512,
5448 .fifo_size = 0
5449 };
5450
5451 static struct snd_pcm_hardware snd_hdspm_capture_subinfo = {
5452 .info = (SNDRV_PCM_INFO_MMAP |
5453 SNDRV_PCM_INFO_MMAP_VALID |
5454 SNDRV_PCM_INFO_NONINTERLEAVED |
5455 SNDRV_PCM_INFO_SYNC_START),
5456 .formats = SNDRV_PCM_FMTBIT_S32_LE,
5457 .rates = (SNDRV_PCM_RATE_32000 |
5458 SNDRV_PCM_RATE_44100 |
5459 SNDRV_PCM_RATE_48000 |
5460 SNDRV_PCM_RATE_64000 |
5461 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
5462 SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000),
5463 .rate_min = 32000,
5464 .rate_max = 192000,
5465 .channels_min = 1,
5466 .channels_max = HDSPM_MAX_CHANNELS,
5467 .buffer_bytes_max =
5468 HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
5469 .period_bytes_min = (32 * 4),
5470 .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
5471 .periods_min = 2,
5472 .periods_max = 512,
5473 .fifo_size = 0
5474 };
5475
5476 static int snd_hdspm_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params,
5477 struct snd_pcm_hw_rule *rule)
5478 {
5479 struct hdspm *hdspm = rule->private;
5480 struct snd_interval *c =
5481 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
5482 struct snd_interval *r =
5483 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
5484
5485 if (r->min > 96000 && r->max <= 192000) {
5486 struct snd_interval t = {
5487 .min = hdspm->qs_in_channels,
5488 .max = hdspm->qs_in_channels,
5489 .integer = 1,
5490 };
5491 return snd_interval_refine(c, &t);
5492 } else if (r->min > 48000 && r->max <= 96000) {
5493 struct snd_interval t = {
5494 .min = hdspm->ds_in_channels,
5495 .max = hdspm->ds_in_channels,
5496 .integer = 1,
5497 };
5498 return snd_interval_refine(c, &t);
5499 } else if (r->max < 64000) {
5500 struct snd_interval t = {
5501 .min = hdspm->ss_in_channels,
5502 .max = hdspm->ss_in_channels,
5503 .integer = 1,
5504 };
5505 return snd_interval_refine(c, &t);
5506 }
5507
5508 return 0;
5509 }
5510
5511 static int snd_hdspm_hw_rule_out_channels_rate(struct snd_pcm_hw_params *params,
5512 struct snd_pcm_hw_rule * rule)
5513 {
5514 struct hdspm *hdspm = rule->private;
5515 struct snd_interval *c =
5516 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
5517 struct snd_interval *r =
5518 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
5519
5520 if (r->min > 96000 && r->max <= 192000) {
5521 struct snd_interval t = {
5522 .min = hdspm->qs_out_channels,
5523 .max = hdspm->qs_out_channels,
5524 .integer = 1,
5525 };
5526 return snd_interval_refine(c, &t);
5527 } else if (r->min > 48000 && r->max <= 96000) {
5528 struct snd_interval t = {
5529 .min = hdspm->ds_out_channels,
5530 .max = hdspm->ds_out_channels,
5531 .integer = 1,
5532 };
5533 return snd_interval_refine(c, &t);
5534 } else if (r->max < 64000) {
5535 struct snd_interval t = {
5536 .min = hdspm->ss_out_channels,
5537 .max = hdspm->ss_out_channels,
5538 .integer = 1,
5539 };
5540 return snd_interval_refine(c, &t);
5541 } else {
5542 }
5543 return 0;
5544 }
5545
5546 static int snd_hdspm_hw_rule_rate_in_channels(struct snd_pcm_hw_params *params,
5547 struct snd_pcm_hw_rule * rule)
5548 {
5549 struct hdspm *hdspm = rule->private;
5550 struct snd_interval *c =
5551 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
5552 struct snd_interval *r =
5553 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
5554
5555 if (c->min >= hdspm->ss_in_channels) {
5556 struct snd_interval t = {
5557 .min = 32000,
5558 .max = 48000,
5559 .integer = 1,
5560 };
5561 return snd_interval_refine(r, &t);
5562 } else if (c->max <= hdspm->qs_in_channels) {
5563 struct snd_interval t = {
5564 .min = 128000,
5565 .max = 192000,
5566 .integer = 1,
5567 };
5568 return snd_interval_refine(r, &t);
5569 } else if (c->max <= hdspm->ds_in_channels) {
5570 struct snd_interval t = {
5571 .min = 64000,
5572 .max = 96000,
5573 .integer = 1,
5574 };
5575 return snd_interval_refine(r, &t);
5576 }
5577
5578 return 0;
5579 }
5580 static int snd_hdspm_hw_rule_rate_out_channels(struct snd_pcm_hw_params *params,
5581 struct snd_pcm_hw_rule *rule)
5582 {
5583 struct hdspm *hdspm = rule->private;
5584 struct snd_interval *c =
5585 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
5586 struct snd_interval *r =
5587 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
5588
5589 if (c->min >= hdspm->ss_out_channels) {
5590 struct snd_interval t = {
5591 .min = 32000,
5592 .max = 48000,
5593 .integer = 1,
5594 };
5595 return snd_interval_refine(r, &t);
5596 } else if (c->max <= hdspm->qs_out_channels) {
5597 struct snd_interval t = {
5598 .min = 128000,
5599 .max = 192000,
5600 .integer = 1,
5601 };
5602 return snd_interval_refine(r, &t);
5603 } else if (c->max <= hdspm->ds_out_channels) {
5604 struct snd_interval t = {
5605 .min = 64000,
5606 .max = 96000,
5607 .integer = 1,
5608 };
5609 return snd_interval_refine(r, &t);
5610 }
5611
5612 return 0;
5613 }
5614
5615 static int snd_hdspm_hw_rule_in_channels(struct snd_pcm_hw_params *params,
5616 struct snd_pcm_hw_rule *rule)
5617 {
5618 unsigned int list[3];
5619 struct hdspm *hdspm = rule->private;
5620 struct snd_interval *c = hw_param_interval(params,
5621 SNDRV_PCM_HW_PARAM_CHANNELS);
5622
5623 list[0] = hdspm->qs_in_channels;
5624 list[1] = hdspm->ds_in_channels;
5625 list[2] = hdspm->ss_in_channels;
5626 return snd_interval_list(c, 3, list, 0);
5627 }
5628
5629 static int snd_hdspm_hw_rule_out_channels(struct snd_pcm_hw_params *params,
5630 struct snd_pcm_hw_rule *rule)
5631 {
5632 unsigned int list[3];
5633 struct hdspm *hdspm = rule->private;
5634 struct snd_interval *c = hw_param_interval(params,
5635 SNDRV_PCM_HW_PARAM_CHANNELS);
5636
5637 list[0] = hdspm->qs_out_channels;
5638 list[1] = hdspm->ds_out_channels;
5639 list[2] = hdspm->ss_out_channels;
5640 return snd_interval_list(c, 3, list, 0);
5641 }
5642
5643
5644 static unsigned int hdspm_aes32_sample_rates[] = {
5645 32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000
5646 };
5647
5648 static struct snd_pcm_hw_constraint_list
5649 hdspm_hw_constraints_aes32_sample_rates = {
5650 .count = ARRAY_SIZE(hdspm_aes32_sample_rates),
5651 .list = hdspm_aes32_sample_rates,
5652 .mask = 0
5653 };
5654
5655 static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
5656 {
5657 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5658 struct snd_pcm_runtime *runtime = substream->runtime;
5659
5660 spin_lock_irq(&hdspm->lock);
5661
5662 snd_pcm_set_sync(substream);
5663
5664
5665 runtime->hw = snd_hdspm_playback_subinfo;
5666
5667 if (hdspm->capture_substream == NULL)
5668 hdspm_stop_audio(hdspm);
5669
5670 hdspm->playback_pid = current->pid;
5671 hdspm->playback_substream = substream;
5672
5673 spin_unlock_irq(&hdspm->lock);
5674
5675 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
5676 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
5677
5678 switch (hdspm->io_type) {
5679 case AIO:
5680 case RayDAT:
5681 snd_pcm_hw_constraint_minmax(runtime,
5682 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
5683 32, 4096);
5684 /* RayDAT & AIO have a fixed buffer of 16384 samples per channel */
5685 snd_pcm_hw_constraint_minmax(runtime,
5686 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
5687 16384, 16384);
5688 break;
5689
5690 default:
5691 snd_pcm_hw_constraint_minmax(runtime,
5692 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
5693 64, 8192);
5694 break;
5695 }
5696
5697 if (AES32 == hdspm->io_type) {
5698 runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
5699 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
5700 &hdspm_hw_constraints_aes32_sample_rates);
5701 } else {
5702 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
5703 snd_hdspm_hw_rule_rate_out_channels, hdspm,
5704 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
5705 }
5706
5707 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
5708 snd_hdspm_hw_rule_out_channels, hdspm,
5709 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
5710
5711 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
5712 snd_hdspm_hw_rule_out_channels_rate, hdspm,
5713 SNDRV_PCM_HW_PARAM_RATE, -1);
5714
5715 return 0;
5716 }
5717
5718 static int snd_hdspm_playback_release(struct snd_pcm_substream *substream)
5719 {
5720 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5721
5722 spin_lock_irq(&hdspm->lock);
5723
5724 hdspm->playback_pid = -1;
5725 hdspm->playback_substream = NULL;
5726
5727 spin_unlock_irq(&hdspm->lock);
5728
5729 return 0;
5730 }
5731
5732
5733 static int snd_hdspm_capture_open(struct snd_pcm_substream *substream)
5734 {
5735 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5736 struct snd_pcm_runtime *runtime = substream->runtime;
5737
5738 spin_lock_irq(&hdspm->lock);
5739 snd_pcm_set_sync(substream);
5740 runtime->hw = snd_hdspm_capture_subinfo;
5741
5742 if (hdspm->playback_substream == NULL)
5743 hdspm_stop_audio(hdspm);
5744
5745 hdspm->capture_pid = current->pid;
5746 hdspm->capture_substream = substream;
5747
5748 spin_unlock_irq(&hdspm->lock);
5749
5750 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
5751 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
5752
5753 switch (hdspm->io_type) {
5754 case AIO:
5755 case RayDAT:
5756 snd_pcm_hw_constraint_minmax(runtime,
5757 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
5758 32, 4096);
5759 snd_pcm_hw_constraint_minmax(runtime,
5760 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
5761 16384, 16384);
5762 break;
5763
5764 default:
5765 snd_pcm_hw_constraint_minmax(runtime,
5766 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
5767 64, 8192);
5768 break;
5769 }
5770
5771 if (AES32 == hdspm->io_type) {
5772 runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
5773 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
5774 &hdspm_hw_constraints_aes32_sample_rates);
5775 } else {
5776 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
5777 snd_hdspm_hw_rule_rate_in_channels, hdspm,
5778 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
5779 }
5780
5781 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
5782 snd_hdspm_hw_rule_in_channels, hdspm,
5783 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
5784
5785 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
5786 snd_hdspm_hw_rule_in_channels_rate, hdspm,
5787 SNDRV_PCM_HW_PARAM_RATE, -1);
5788
5789 return 0;
5790 }
5791
5792 static int snd_hdspm_capture_release(struct snd_pcm_substream *substream)
5793 {
5794 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
5795
5796 spin_lock_irq(&hdspm->lock);
5797
5798 hdspm->capture_pid = -1;
5799 hdspm->capture_substream = NULL;
5800
5801 spin_unlock_irq(&hdspm->lock);
5802 return 0;
5803 }
5804
5805 static int snd_hdspm_hwdep_dummy_op(struct snd_hwdep *hw, struct file *file)
5806 {
5807 /* we have nothing to initialize but the call is required */
5808 return 0;
5809 }
5810
5811 static inline int copy_u32_le(void __user *dest, void __iomem *src)
5812 {
5813 u32 val = readl(src);
5814 return copy_to_user(dest, &val, 4);
5815 }
5816
5817 static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
5818 unsigned int cmd, unsigned long arg)
5819 {
5820 void __user *argp = (void __user *)arg;
5821 struct hdspm *hdspm = hw->private_data;
5822 struct hdspm_mixer_ioctl mixer;
5823 struct hdspm_config info;
5824 struct hdspm_status status;
5825 struct hdspm_version hdspm_version;
5826 struct hdspm_peak_rms *levels;
5827 struct hdspm_ltc ltc;
5828 unsigned int statusregister;
5829 long unsigned int s;
5830 int i = 0;
5831
5832 switch (cmd) {
5833
5834 case SNDRV_HDSPM_IOCTL_GET_PEAK_RMS:
5835 levels = &hdspm->peak_rms;
5836 for (i = 0; i < HDSPM_MAX_CHANNELS; i++) {
5837 levels->input_peaks[i] =
5838 readl(hdspm->iobase +
5839 HDSPM_MADI_INPUT_PEAK + i*4);
5840 levels->playback_peaks[i] =
5841 readl(hdspm->iobase +
5842 HDSPM_MADI_PLAYBACK_PEAK + i*4);
5843 levels->output_peaks[i] =
5844 readl(hdspm->iobase +
5845 HDSPM_MADI_OUTPUT_PEAK + i*4);
5846
5847 levels->input_rms[i] =
5848 ((uint64_t) readl(hdspm->iobase +
5849 HDSPM_MADI_INPUT_RMS_H + i*4) << 32) |
5850 (uint64_t) readl(hdspm->iobase +
5851 HDSPM_MADI_INPUT_RMS_L + i*4);
5852 levels->playback_rms[i] =
5853 ((uint64_t)readl(hdspm->iobase +
5854 HDSPM_MADI_PLAYBACK_RMS_H+i*4) << 32) |
5855 (uint64_t)readl(hdspm->iobase +
5856 HDSPM_MADI_PLAYBACK_RMS_L + i*4);
5857 levels->output_rms[i] =
5858 ((uint64_t)readl(hdspm->iobase +
5859 HDSPM_MADI_OUTPUT_RMS_H + i*4) << 32) |
5860 (uint64_t)readl(hdspm->iobase +
5861 HDSPM_MADI_OUTPUT_RMS_L + i*4);
5862 }
5863
5864 if (hdspm->system_sample_rate > 96000) {
5865 levels->speed = qs;
5866 } else if (hdspm->system_sample_rate > 48000) {
5867 levels->speed = ds;
5868 } else {
5869 levels->speed = ss;
5870 }
5871 levels->status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
5872
5873 s = copy_to_user(argp, levels, sizeof(struct hdspm_peak_rms));
5874 if (0 != s) {
5875 /* snd_printk(KERN_ERR "copy_to_user(.., .., %lu): %lu
5876 [Levels]\n", sizeof(struct hdspm_peak_rms), s);
5877 */
5878 return -EFAULT;
5879 }
5880 break;
5881
5882 case SNDRV_HDSPM_IOCTL_GET_LTC:
5883 ltc.ltc = hdspm_read(hdspm, HDSPM_RD_TCO);
5884 i = hdspm_read(hdspm, HDSPM_RD_TCO + 4);
5885 if (i & HDSPM_TCO1_LTC_Input_valid) {
5886 switch (i & (HDSPM_TCO1_LTC_Format_LSB |
5887 HDSPM_TCO1_LTC_Format_MSB)) {
5888 case 0:
5889 ltc.format = fps_24;
5890 break;
5891 case HDSPM_TCO1_LTC_Format_LSB:
5892 ltc.format = fps_25;
5893 break;
5894 case HDSPM_TCO1_LTC_Format_MSB:
5895 ltc.format = fps_2997;
5896 break;
5897 default:
5898 ltc.format = 30;
5899 break;
5900 }
5901 if (i & HDSPM_TCO1_set_drop_frame_flag) {
5902 ltc.frame = drop_frame;
5903 } else {
5904 ltc.frame = full_frame;
5905 }
5906 } else {
5907 ltc.format = format_invalid;
5908 ltc.frame = frame_invalid;
5909 }
5910 if (i & HDSPM_TCO1_Video_Input_Format_NTSC) {
5911 ltc.input_format = ntsc;
5912 } else if (i & HDSPM_TCO1_Video_Input_Format_PAL) {
5913 ltc.input_format = pal;
5914 } else {
5915 ltc.input_format = no_video;
5916 }
5917
5918 s = copy_to_user(argp, &ltc, sizeof(struct hdspm_ltc));
5919 if (0 != s) {
5920 /*
5921 snd_printk(KERN_ERR "copy_to_user(.., .., %lu): %lu [LTC]\n", sizeof(struct hdspm_ltc), s); */
5922 return -EFAULT;
5923 }
5924
5925 break;
5926
5927 case SNDRV_HDSPM_IOCTL_GET_CONFIG:
5928
5929 memset(&info, 0, sizeof(info));
5930 spin_lock_irq(&hdspm->lock);
5931 info.pref_sync_ref = hdspm_pref_sync_ref(hdspm);
5932 info.wordclock_sync_check = hdspm_wc_sync_check(hdspm);
5933
5934 info.system_sample_rate = hdspm->system_sample_rate;
5935 info.autosync_sample_rate =
5936 hdspm_external_sample_rate(hdspm);
5937 info.system_clock_mode = hdspm_system_clock_mode(hdspm);
5938 info.clock_source = hdspm_clock_source(hdspm);
5939 info.autosync_ref = hdspm_autosync_ref(hdspm);
5940 info.line_out = hdspm_toggle_setting(hdspm, HDSPM_LineOut);
5941 info.passthru = 0;
5942 spin_unlock_irq(&hdspm->lock);
5943 if (copy_to_user(argp, &info, sizeof(info)))
5944 return -EFAULT;
5945 break;
5946
5947 case SNDRV_HDSPM_IOCTL_GET_STATUS:
5948 memset(&status, 0, sizeof(status));
5949
5950 status.card_type = hdspm->io_type;
5951
5952 status.autosync_source = hdspm_autosync_ref(hdspm);
5953
5954 status.card_clock = 110069313433624ULL;
5955 status.master_period = hdspm_read(hdspm, HDSPM_RD_PLL_FREQ);
5956
5957 switch (hdspm->io_type) {
5958 case MADI:
5959 case MADIface:
5960 status.card_specific.madi.sync_wc =
5961 hdspm_wc_sync_check(hdspm);
5962 status.card_specific.madi.sync_madi =
5963 hdspm_madi_sync_check(hdspm);
5964 status.card_specific.madi.sync_tco =
5965 hdspm_tco_sync_check(hdspm);
5966 status.card_specific.madi.sync_in =
5967 hdspm_sync_in_sync_check(hdspm);
5968
5969 statusregister =
5970 hdspm_read(hdspm, HDSPM_statusRegister);
5971 status.card_specific.madi.madi_input =
5972 (statusregister & HDSPM_AB_int) ? 1 : 0;
5973 status.card_specific.madi.channel_format =
5974 (statusregister & HDSPM_RX_64ch) ? 1 : 0;
5975 /* TODO: Mac driver sets it when f_s>48kHz */
5976 status.card_specific.madi.frame_format = 0;
5977
5978 default:
5979 break;
5980 }
5981
5982 if (copy_to_user(argp, &status, sizeof(status)))
5983 return -EFAULT;
5984
5985
5986 break;
5987
5988 case SNDRV_HDSPM_IOCTL_GET_VERSION:
5989 memset(&hdspm_version, 0, sizeof(hdspm_version));
5990
5991 hdspm_version.card_type = hdspm->io_type;
5992 strncpy(hdspm_version.cardname, hdspm->card_name,
5993 sizeof(hdspm_version.cardname));
5994 hdspm_version.serial = hdspm->serial;
5995 hdspm_version.firmware_rev = hdspm->firmware_rev;
5996 hdspm_version.addons = 0;
5997 if (hdspm->tco)
5998 hdspm_version.addons |= HDSPM_ADDON_TCO;
5999
6000 if (copy_to_user(argp, &hdspm_version,
6001 sizeof(hdspm_version)))
6002 return -EFAULT;
6003 break;
6004
6005 case SNDRV_HDSPM_IOCTL_GET_MIXER:
6006 if (copy_from_user(&mixer, argp, sizeof(mixer)))
6007 return -EFAULT;
6008 if (copy_to_user((void __user *)mixer.mixer, hdspm->mixer,
6009 sizeof(struct hdspm_mixer)))
6010 return -EFAULT;
6011 break;
6012
6013 default:
6014 return -EINVAL;
6015 }
6016 return 0;
6017 }
6018
6019 static struct snd_pcm_ops snd_hdspm_playback_ops = {
6020 .open = snd_hdspm_playback_open,
6021 .close = snd_hdspm_playback_release,
6022 .ioctl = snd_hdspm_ioctl,
6023 .hw_params = snd_hdspm_hw_params,
6024 .hw_free = snd_hdspm_hw_free,
6025 .prepare = snd_hdspm_prepare,
6026 .trigger = snd_hdspm_trigger,
6027 .pointer = snd_hdspm_hw_pointer,
6028 .page = snd_pcm_sgbuf_ops_page,
6029 };
6030
6031 static struct snd_pcm_ops snd_hdspm_capture_ops = {
6032 .open = snd_hdspm_capture_open,
6033 .close = snd_hdspm_capture_release,
6034 .ioctl = snd_hdspm_ioctl,
6035 .hw_params = snd_hdspm_hw_params,
6036 .hw_free = snd_hdspm_hw_free,
6037 .prepare = snd_hdspm_prepare,
6038 .trigger = snd_hdspm_trigger,
6039 .pointer = snd_hdspm_hw_pointer,
6040 .page = snd_pcm_sgbuf_ops_page,
6041 };
6042
6043 static int snd_hdspm_create_hwdep(struct snd_card *card,
6044 struct hdspm *hdspm)
6045 {
6046 struct snd_hwdep *hw;
6047 int err;
6048
6049 err = snd_hwdep_new(card, "HDSPM hwdep", 0, &hw);
6050 if (err < 0)
6051 return err;
6052
6053 hdspm->hwdep = hw;
6054 hw->private_data = hdspm;
6055 strcpy(hw->name, "HDSPM hwdep interface");
6056
6057 hw->ops.open = snd_hdspm_hwdep_dummy_op;
6058 hw->ops.ioctl = snd_hdspm_hwdep_ioctl;
6059 hw->ops.ioctl_compat = snd_hdspm_hwdep_ioctl;
6060 hw->ops.release = snd_hdspm_hwdep_dummy_op;
6061
6062 return 0;
6063 }
6064
6065
6066 /*------------------------------------------------------------
6067 memory interface
6068 ------------------------------------------------------------*/
6069 static int snd_hdspm_preallocate_memory(struct hdspm *hdspm)
6070 {
6071 int err;
6072 struct snd_pcm *pcm;
6073 size_t wanted;
6074
6075 pcm = hdspm->pcm;
6076
6077 wanted = HDSPM_DMA_AREA_BYTES;
6078
6079 err =
6080 snd_pcm_lib_preallocate_pages_for_all(pcm,
6081 SNDRV_DMA_TYPE_DEV_SG,
6082 snd_dma_pci_data(hdspm->pci),
6083 wanted,
6084 wanted);
6085 if (err < 0) {
6086 snd_printdd("Could not preallocate %zd Bytes\n", wanted);
6087
6088 return err;
6089 } else
6090 snd_printdd(" Preallocated %zd Bytes\n", wanted);
6091
6092 return 0;
6093 }
6094
6095
6096 static void hdspm_set_sgbuf(struct hdspm *hdspm,
6097 struct snd_pcm_substream *substream,
6098 unsigned int reg, int channels)
6099 {
6100 int i;
6101
6102 /* continuous memory segment */
6103 for (i = 0; i < (channels * 16); i++)
6104 hdspm_write(hdspm, reg + 4 * i,
6105 snd_pcm_sgbuf_get_addr(substream, 4096 * i));
6106 }
6107
6108
6109 /* ------------- ALSA Devices ---------------------------- */
6110 static int snd_hdspm_create_pcm(struct snd_card *card,
6111 struct hdspm *hdspm)
6112 {
6113 struct snd_pcm *pcm;
6114 int err;
6115
6116 err = snd_pcm_new(card, hdspm->card_name, 0, 1, 1, &pcm);
6117 if (err < 0)
6118 return err;
6119
6120 hdspm->pcm = pcm;
6121 pcm->private_data = hdspm;
6122 strcpy(pcm->name, hdspm->card_name);
6123
6124 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
6125 &snd_hdspm_playback_ops);
6126 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
6127 &snd_hdspm_capture_ops);
6128
6129 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
6130
6131 err = snd_hdspm_preallocate_memory(hdspm);
6132 if (err < 0)
6133 return err;
6134
6135 return 0;
6136 }
6137
6138 static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm)
6139 {
6140 int i;
6141
6142 for (i = 0; i < hdspm->midiPorts; i++)
6143 snd_hdspm_flush_midi_input(hdspm, i);
6144 }
6145
6146 static int snd_hdspm_create_alsa_devices(struct snd_card *card,
6147 struct hdspm *hdspm)
6148 {
6149 int err, i;
6150
6151 snd_printdd("Create card...\n");
6152 err = snd_hdspm_create_pcm(card, hdspm);
6153 if (err < 0)
6154 return err;
6155
6156 i = 0;
6157 while (i < hdspm->midiPorts) {
6158 err = snd_hdspm_create_midi(card, hdspm, i);
6159 if (err < 0) {
6160 return err;
6161 }
6162 i++;
6163 }
6164
6165 err = snd_hdspm_create_controls(card, hdspm);
6166 if (err < 0)
6167 return err;
6168
6169 err = snd_hdspm_create_hwdep(card, hdspm);
6170 if (err < 0)
6171 return err;
6172
6173 snd_printdd("proc init...\n");
6174 snd_hdspm_proc_init(hdspm);
6175
6176 hdspm->system_sample_rate = -1;
6177 hdspm->last_external_sample_rate = -1;
6178 hdspm->last_internal_sample_rate = -1;
6179 hdspm->playback_pid = -1;
6180 hdspm->capture_pid = -1;
6181 hdspm->capture_substream = NULL;
6182 hdspm->playback_substream = NULL;
6183
6184 snd_printdd("Set defaults...\n");
6185 err = snd_hdspm_set_defaults(hdspm);
6186 if (err < 0)
6187 return err;
6188
6189 snd_printdd("Update mixer controls...\n");
6190 hdspm_update_simple_mixer_controls(hdspm);
6191
6192 snd_printdd("Initializeing complete ???\n");
6193
6194 err = snd_card_register(card);
6195 if (err < 0) {
6196 snd_printk(KERN_ERR "HDSPM: error registering card\n");
6197 return err;
6198 }
6199
6200 snd_printdd("... yes now\n");
6201
6202 return 0;
6203 }
6204
6205 static int snd_hdspm_create(struct snd_card *card,
6206 struct hdspm *hdspm)
6207 {
6208
6209 struct pci_dev *pci = hdspm->pci;
6210 int err;
6211 unsigned long io_extent;
6212
6213 hdspm->irq = -1;
6214 hdspm->card = card;
6215
6216 spin_lock_init(&hdspm->lock);
6217
6218 pci_read_config_word(hdspm->pci,
6219 PCI_CLASS_REVISION, &hdspm->firmware_rev);
6220
6221 strcpy(card->mixername, "Xilinx FPGA");
6222 strcpy(card->driver, "HDSPM");
6223
6224 switch (hdspm->firmware_rev) {
6225 case HDSPM_RAYDAT_REV:
6226 hdspm->io_type = RayDAT;
6227 hdspm->card_name = "RME RayDAT";
6228 hdspm->midiPorts = 2;
6229 break;
6230 case HDSPM_AIO_REV:
6231 hdspm->io_type = AIO;
6232 hdspm->card_name = "RME AIO";
6233 hdspm->midiPorts = 1;
6234 break;
6235 case HDSPM_MADIFACE_REV:
6236 hdspm->io_type = MADIface;
6237 hdspm->card_name = "RME MADIface";
6238 hdspm->midiPorts = 1;
6239 break;
6240 default:
6241 if ((hdspm->firmware_rev == 0xf0) ||
6242 ((hdspm->firmware_rev >= 0xe6) &&
6243 (hdspm->firmware_rev <= 0xea))) {
6244 hdspm->io_type = AES32;
6245 hdspm->card_name = "RME AES32";
6246 hdspm->midiPorts = 2;
6247 } else if ((hdspm->firmware_rev == 0xd2) ||
6248 ((hdspm->firmware_rev >= 0xc8) &&
6249 (hdspm->firmware_rev <= 0xcf))) {
6250 hdspm->io_type = MADI;
6251 hdspm->card_name = "RME MADI";
6252 hdspm->midiPorts = 3;
6253 } else {
6254 snd_printk(KERN_ERR
6255 "HDSPM: unknown firmware revision %x\n",
6256 hdspm->firmware_rev);
6257 return -ENODEV;
6258 }
6259 }
6260
6261 err = pci_enable_device(pci);
6262 if (err < 0)
6263 return err;
6264
6265 pci_set_master(hdspm->pci);
6266
6267 err = pci_request_regions(pci, "hdspm");
6268 if (err < 0)
6269 return err;
6270
6271 hdspm->port = pci_resource_start(pci, 0);
6272 io_extent = pci_resource_len(pci, 0);
6273
6274 snd_printdd("grabbed memory region 0x%lx-0x%lx\n",
6275 hdspm->port, hdspm->port + io_extent - 1);
6276
6277 hdspm->iobase = ioremap_nocache(hdspm->port, io_extent);
6278 if (!hdspm->iobase) {
6279 snd_printk(KERN_ERR "HDSPM: "
6280 "unable to remap region 0x%lx-0x%lx\n",
6281 hdspm->port, hdspm->port + io_extent - 1);
6282 return -EBUSY;
6283 }
6284 snd_printdd("remapped region (0x%lx) 0x%lx-0x%lx\n",
6285 (unsigned long)hdspm->iobase, hdspm->port,
6286 hdspm->port + io_extent - 1);
6287
6288 if (request_irq(pci->irq, snd_hdspm_interrupt,
6289 IRQF_SHARED, KBUILD_MODNAME, hdspm)) {
6290 snd_printk(KERN_ERR "HDSPM: unable to use IRQ %d\n", pci->irq);
6291 return -EBUSY;
6292 }
6293
6294 snd_printdd("use IRQ %d\n", pci->irq);
6295
6296 hdspm->irq = pci->irq;
6297
6298 snd_printdd("kmalloc Mixer memory of %zd Bytes\n",
6299 sizeof(struct hdspm_mixer));
6300 hdspm->mixer = kzalloc(sizeof(struct hdspm_mixer), GFP_KERNEL);
6301 if (!hdspm->mixer) {
6302 snd_printk(KERN_ERR "HDSPM: "
6303 "unable to kmalloc Mixer memory of %d Bytes\n",
6304 (int)sizeof(struct hdspm_mixer));
6305 return -ENOMEM;
6306 }
6307
6308 hdspm->port_names_in = NULL;
6309 hdspm->port_names_out = NULL;
6310
6311 switch (hdspm->io_type) {
6312 case AES32:
6313 hdspm->ss_in_channels = hdspm->ss_out_channels = AES32_CHANNELS;
6314 hdspm->ds_in_channels = hdspm->ds_out_channels = AES32_CHANNELS;
6315 hdspm->qs_in_channels = hdspm->qs_out_channels = AES32_CHANNELS;
6316
6317 hdspm->channel_map_in_ss = hdspm->channel_map_out_ss =
6318 channel_map_aes32;
6319 hdspm->channel_map_in_ds = hdspm->channel_map_out_ds =
6320 channel_map_aes32;
6321 hdspm->channel_map_in_qs = hdspm->channel_map_out_qs =
6322 channel_map_aes32;
6323 hdspm->port_names_in_ss = hdspm->port_names_out_ss =
6324 texts_ports_aes32;
6325 hdspm->port_names_in_ds = hdspm->port_names_out_ds =
6326 texts_ports_aes32;
6327 hdspm->port_names_in_qs = hdspm->port_names_out_qs =
6328 texts_ports_aes32;
6329
6330 hdspm->max_channels_out = hdspm->max_channels_in =
6331 AES32_CHANNELS;
6332 hdspm->port_names_in = hdspm->port_names_out =
6333 texts_ports_aes32;
6334 hdspm->channel_map_in = hdspm->channel_map_out =
6335 channel_map_aes32;
6336
6337 break;
6338
6339 case MADI:
6340 case MADIface:
6341 hdspm->ss_in_channels = hdspm->ss_out_channels =
6342 MADI_SS_CHANNELS;
6343 hdspm->ds_in_channels = hdspm->ds_out_channels =
6344 MADI_DS_CHANNELS;
6345 hdspm->qs_in_channels = hdspm->qs_out_channels =
6346 MADI_QS_CHANNELS;
6347
6348 hdspm->channel_map_in_ss = hdspm->channel_map_out_ss =
6349 channel_map_unity_ss;
6350 hdspm->channel_map_in_ds = hdspm->channel_map_out_ds =
6351 channel_map_unity_ss;
6352 hdspm->channel_map_in_qs = hdspm->channel_map_out_qs =
6353 channel_map_unity_ss;
6354
6355 hdspm->port_names_in_ss = hdspm->port_names_out_ss =
6356 texts_ports_madi;
6357 hdspm->port_names_in_ds = hdspm->port_names_out_ds =
6358 texts_ports_madi;
6359 hdspm->port_names_in_qs = hdspm->port_names_out_qs =
6360 texts_ports_madi;
6361 break;
6362
6363 case AIO:
6364 if (0 == (hdspm_read(hdspm, HDSPM_statusRegister2) & HDSPM_s2_AEBI_D)) {
6365 snd_printk(KERN_INFO "HDSPM: AEB input board found, but not supported\n");
6366 }
6367
6368 hdspm->ss_in_channels = AIO_IN_SS_CHANNELS;
6369 hdspm->ds_in_channels = AIO_IN_DS_CHANNELS;
6370 hdspm->qs_in_channels = AIO_IN_QS_CHANNELS;
6371 hdspm->ss_out_channels = AIO_OUT_SS_CHANNELS;
6372 hdspm->ds_out_channels = AIO_OUT_DS_CHANNELS;
6373 hdspm->qs_out_channels = AIO_OUT_QS_CHANNELS;
6374
6375 hdspm->channel_map_out_ss = channel_map_aio_out_ss;
6376 hdspm->channel_map_out_ds = channel_map_aio_out_ds;
6377 hdspm->channel_map_out_qs = channel_map_aio_out_qs;
6378
6379 hdspm->channel_map_in_ss = channel_map_aio_in_ss;
6380 hdspm->channel_map_in_ds = channel_map_aio_in_ds;
6381 hdspm->channel_map_in_qs = channel_map_aio_in_qs;
6382
6383 hdspm->port_names_in_ss = texts_ports_aio_in_ss;
6384 hdspm->port_names_out_ss = texts_ports_aio_out_ss;
6385 hdspm->port_names_in_ds = texts_ports_aio_in_ds;
6386 hdspm->port_names_out_ds = texts_ports_aio_out_ds;
6387 hdspm->port_names_in_qs = texts_ports_aio_in_qs;
6388 hdspm->port_names_out_qs = texts_ports_aio_out_qs;
6389
6390 break;
6391
6392 case RayDAT:
6393 hdspm->ss_in_channels = hdspm->ss_out_channels =
6394 RAYDAT_SS_CHANNELS;
6395 hdspm->ds_in_channels = hdspm->ds_out_channels =
6396 RAYDAT_DS_CHANNELS;
6397 hdspm->qs_in_channels = hdspm->qs_out_channels =
6398 RAYDAT_QS_CHANNELS;
6399
6400 hdspm->max_channels_in = RAYDAT_SS_CHANNELS;
6401 hdspm->max_channels_out = RAYDAT_SS_CHANNELS;
6402
6403 hdspm->channel_map_in_ss = hdspm->channel_map_out_ss =
6404 channel_map_raydat_ss;
6405 hdspm->channel_map_in_ds = hdspm->channel_map_out_ds =
6406 channel_map_raydat_ds;
6407 hdspm->channel_map_in_qs = hdspm->channel_map_out_qs =
6408 channel_map_raydat_qs;
6409 hdspm->channel_map_in = hdspm->channel_map_out =
6410 channel_map_raydat_ss;
6411
6412 hdspm->port_names_in_ss = hdspm->port_names_out_ss =
6413 texts_ports_raydat_ss;
6414 hdspm->port_names_in_ds = hdspm->port_names_out_ds =
6415 texts_ports_raydat_ds;
6416 hdspm->port_names_in_qs = hdspm->port_names_out_qs =
6417 texts_ports_raydat_qs;
6418
6419
6420 break;
6421
6422 }
6423
6424 /* TCO detection */
6425 switch (hdspm->io_type) {
6426 case AIO:
6427 case RayDAT:
6428 if (hdspm_read(hdspm, HDSPM_statusRegister2) &
6429 HDSPM_s2_tco_detect) {
6430 hdspm->midiPorts++;
6431 hdspm->tco = kzalloc(sizeof(struct hdspm_tco),
6432 GFP_KERNEL);
6433 if (NULL != hdspm->tco) {
6434 hdspm_tco_write(hdspm);
6435 }
6436 snd_printk(KERN_INFO "HDSPM: AIO/RayDAT TCO module found\n");
6437 } else {
6438 hdspm->tco = NULL;
6439 }
6440 break;
6441
6442 case MADI:
6443 if (hdspm_read(hdspm, HDSPM_statusRegister) & HDSPM_tco_detect) {
6444 hdspm->midiPorts++;
6445 hdspm->tco = kzalloc(sizeof(struct hdspm_tco),
6446 GFP_KERNEL);
6447 if (NULL != hdspm->tco) {
6448 hdspm_tco_write(hdspm);
6449 }
6450 snd_printk(KERN_INFO "HDSPM: MADI TCO module found\n");
6451 } else {
6452 hdspm->tco = NULL;
6453 }
6454 break;
6455
6456 default:
6457 hdspm->tco = NULL;
6458 }
6459
6460 /* texts */
6461 switch (hdspm->io_type) {
6462 case AES32:
6463 if (hdspm->tco) {
6464 hdspm->texts_autosync = texts_autosync_aes_tco;
6465 hdspm->texts_autosync_items = 10;
6466 } else {
6467 hdspm->texts_autosync = texts_autosync_aes;
6468 hdspm->texts_autosync_items = 9;
6469 }
6470 break;
6471
6472 case MADI:
6473 if (hdspm->tco) {
6474 hdspm->texts_autosync = texts_autosync_madi_tco;
6475 hdspm->texts_autosync_items = 4;
6476 } else {
6477 hdspm->texts_autosync = texts_autosync_madi;
6478 hdspm->texts_autosync_items = 3;
6479 }
6480 break;
6481
6482 case MADIface:
6483
6484 break;
6485
6486 case RayDAT:
6487 if (hdspm->tco) {
6488 hdspm->texts_autosync = texts_autosync_raydat_tco;
6489 hdspm->texts_autosync_items = 9;
6490 } else {
6491 hdspm->texts_autosync = texts_autosync_raydat;
6492 hdspm->texts_autosync_items = 8;
6493 }
6494 break;
6495
6496 case AIO:
6497 if (hdspm->tco) {
6498 hdspm->texts_autosync = texts_autosync_aio_tco;
6499 hdspm->texts_autosync_items = 6;
6500 } else {
6501 hdspm->texts_autosync = texts_autosync_aio;
6502 hdspm->texts_autosync_items = 5;
6503 }
6504 break;
6505
6506 }
6507
6508 tasklet_init(&hdspm->midi_tasklet,
6509 hdspm_midi_tasklet, (unsigned long) hdspm);
6510
6511
6512 if (hdspm->io_type != MADIface) {
6513 hdspm->serial = (hdspm_read(hdspm,
6514 HDSPM_midiStatusIn0)>>8) & 0xFFFFFF;
6515 /* id contains either a user-provided value or the default
6516 * NULL. If it's the default, we're safe to
6517 * fill card->id with the serial number.
6518 *
6519 * If the serial number is 0xFFFFFF, then we're dealing with
6520 * an old PCI revision that comes without a sane number. In
6521 * this case, we don't set card->id to avoid collisions
6522 * when running with multiple cards.
6523 */
6524 if (NULL == id[hdspm->dev] && hdspm->serial != 0xFFFFFF) {
6525 sprintf(card->id, "HDSPMx%06x", hdspm->serial);
6526 snd_card_set_id(card, card->id);
6527 }
6528 }
6529
6530 snd_printdd("create alsa devices.\n");
6531 err = snd_hdspm_create_alsa_devices(card, hdspm);
6532 if (err < 0)
6533 return err;
6534
6535 snd_hdspm_initialize_midi_flush(hdspm);
6536
6537 return 0;
6538 }
6539
6540
6541 static int snd_hdspm_free(struct hdspm * hdspm)
6542 {
6543
6544 if (hdspm->port) {
6545
6546 /* stop th audio, and cancel all interrupts */
6547 hdspm->control_register &=
6548 ~(HDSPM_Start | HDSPM_AudioInterruptEnable |
6549 HDSPM_Midi0InterruptEnable | HDSPM_Midi1InterruptEnable |
6550 HDSPM_Midi2InterruptEnable | HDSPM_Midi3InterruptEnable);
6551 hdspm_write(hdspm, HDSPM_controlRegister,
6552 hdspm->control_register);
6553 }
6554
6555 if (hdspm->irq >= 0)
6556 free_irq(hdspm->irq, (void *) hdspm);
6557
6558 kfree(hdspm->mixer);
6559
6560 if (hdspm->iobase)
6561 iounmap(hdspm->iobase);
6562
6563 if (hdspm->port)
6564 pci_release_regions(hdspm->pci);
6565
6566 pci_disable_device(hdspm->pci);
6567 return 0;
6568 }
6569
6570
6571 static void snd_hdspm_card_free(struct snd_card *card)
6572 {
6573 struct hdspm *hdspm = card->private_data;
6574
6575 if (hdspm)
6576 snd_hdspm_free(hdspm);
6577 }
6578
6579
6580 static int snd_hdspm_probe(struct pci_dev *pci,
6581 const struct pci_device_id *pci_id)
6582 {
6583 static int dev;
6584 struct hdspm *hdspm;
6585 struct snd_card *card;
6586 int err;
6587
6588 if (dev >= SNDRV_CARDS)
6589 return -ENODEV;
6590 if (!enable[dev]) {
6591 dev++;
6592 return -ENOENT;
6593 }
6594
6595 err = snd_card_create(index[dev], id[dev],
6596 THIS_MODULE, sizeof(struct hdspm), &card);
6597 if (err < 0)
6598 return err;
6599
6600 hdspm = card->private_data;
6601 card->private_free = snd_hdspm_card_free;
6602 hdspm->dev = dev;
6603 hdspm->pci = pci;
6604
6605 snd_card_set_dev(card, &pci->dev);
6606
6607 err = snd_hdspm_create(card, hdspm);
6608 if (err < 0) {
6609 snd_card_free(card);
6610 return err;
6611 }
6612
6613 if (hdspm->io_type != MADIface) {
6614 sprintf(card->shortname, "%s_%x",
6615 hdspm->card_name,
6616 hdspm->serial);
6617 sprintf(card->longname, "%s S/N 0x%x at 0x%lx, irq %d",
6618 hdspm->card_name,
6619 hdspm->serial,
6620 hdspm->port, hdspm->irq);
6621 } else {
6622 sprintf(card->shortname, "%s", hdspm->card_name);
6623 sprintf(card->longname, "%s at 0x%lx, irq %d",
6624 hdspm->card_name, hdspm->port, hdspm->irq);
6625 }
6626
6627 err = snd_card_register(card);
6628 if (err < 0) {
6629 snd_card_free(card);
6630 return err;
6631 }
6632
6633 pci_set_drvdata(pci, card);
6634
6635 dev++;
6636 return 0;
6637 }
6638
6639 static void snd_hdspm_remove(struct pci_dev *pci)
6640 {
6641 snd_card_free(pci_get_drvdata(pci));
6642 pci_set_drvdata(pci, NULL);
6643 }
6644
6645 static struct pci_driver hdspm_driver = {
6646 .name = KBUILD_MODNAME,
6647 .id_table = snd_hdspm_ids,
6648 .probe = snd_hdspm_probe,
6649 .remove = snd_hdspm_remove,
6650 };
6651
6652 module_pci_driver(hdspm_driver);
CRIS linux kernel tree