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