?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / sound / pci / rme9652 / rme9652.c
bloba123f0e6ba23386213738dfdb835c7fa5a55353b
1 /*
2 * ALSA driver for RME Digi9652 audio interfaces
3 *
4 * Copyright (c) 1999 IEM - Winfried Ritsch
5 * Copyright (c) 1999-2001 Paul Davis
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22
23 #include <linux/delay.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/pci.h>
27 #include <linux/slab.h>
28 #include <linux/moduleparam.h>
29
30 #include <sound/core.h>
31 #include <sound/control.h>
32 #include <sound/pcm.h>
33 #include <sound/info.h>
34 #include <sound/asoundef.h>
35 #include <sound/initval.h>
36
37 #include <asm/current.h>
38 #include <asm/io.h>
39
40 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
41 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
42 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
43 static int precise_ptr[SNDRV_CARDS]; /* Enable precise pointer */
44
45 module_param_array(index, int, NULL, 0444);
46 MODULE_PARM_DESC(index, "Index value for RME Digi9652 (Hammerfall) soundcard.");
47 module_param_array(id, charp, NULL, 0444);
48 MODULE_PARM_DESC(id, "ID string for RME Digi9652 (Hammerfall) soundcard.");
49 module_param_array(enable, bool, NULL, 0444);
50 MODULE_PARM_DESC(enable, "Enable/disable specific RME96{52,36} soundcards.");
51 module_param_array(precise_ptr, bool, NULL, 0444);
52 MODULE_PARM_DESC(precise_ptr, "Enable precise pointer (doesn't work reliably).");
53 MODULE_AUTHOR("Paul Davis <pbd@op.net>, Winfried Ritsch");
54 MODULE_DESCRIPTION("RME Digi9652/Digi9636");
55 MODULE_LICENSE("GPL");
56 MODULE_SUPPORTED_DEVICE("{{RME,Hammerfall},"
57 "{RME,Hammerfall-Light}}");
58
59 /* The Hammerfall has two sets of 24 ADAT + 2 S/PDIF channels, one for
60 capture, one for playback. Both the ADAT and S/PDIF channels appear
61 to the host CPU in the same block of memory. There is no functional
62 difference between them in terms of access.
63
64 The Hammerfall Light is identical to the Hammerfall, except that it
65 has 2 sets 18 channels (16 ADAT + 2 S/PDIF) for capture and playback.
66 */
67
68 #define RME9652_NCHANNELS 26
69 #define RME9636_NCHANNELS 18
70
71 /* Preferred sync source choices - used by "sync_pref" control switch */
72
73 #define RME9652_SYNC_FROM_SPDIF 0
74 #define RME9652_SYNC_FROM_ADAT1 1
75 #define RME9652_SYNC_FROM_ADAT2 2
76 #define RME9652_SYNC_FROM_ADAT3 3
77
78 /* Possible sources of S/PDIF input */
79
80 #define RME9652_SPDIFIN_OPTICAL 0 /* optical (ADAT1) */
81 #define RME9652_SPDIFIN_COAXIAL 1 /* coaxial (RCA) */
82 #define RME9652_SPDIFIN_INTERN 2 /* internal (CDROM) */
83
84 /* ------------- Status-Register bits --------------------- */
85
86 #define RME9652_IRQ (1<<0) /* IRQ is High if not reset by irq_clear */
87 #define RME9652_lock_2 (1<<1) /* ADAT 3-PLL: 1=locked, 0=unlocked */
88 #define RME9652_lock_1 (1<<2) /* ADAT 2-PLL: 1=locked, 0=unlocked */
89 #define RME9652_lock_0 (1<<3) /* ADAT 1-PLL: 1=locked, 0=unlocked */
90 #define RME9652_fs48 (1<<4) /* sample rate is 0=44.1/88.2,1=48/96 Khz */
91 #define RME9652_wsel_rd (1<<5) /* if Word-Clock is used and valid then 1 */
92 /* bits 6-15 encode h/w buffer pointer position */
93 #define RME9652_sync_2 (1<<16) /* if ADAT-IN 3 in sync to system clock */
94 #define RME9652_sync_1 (1<<17) /* if ADAT-IN 2 in sync to system clock */
95 #define RME9652_sync_0 (1<<18) /* if ADAT-IN 1 in sync to system clock */
96 #define RME9652_DS_rd (1<<19) /* 1=Double Speed Mode, 0=Normal Speed */
97 #define RME9652_tc_busy (1<<20) /* 1=time-code copy in progress (960ms) */
98 #define RME9652_tc_out (1<<21) /* time-code out bit */
99 #define RME9652_F_0 (1<<22) /* 000=64kHz, 100=88.2kHz, 011=96kHz */
100 #define RME9652_F_1 (1<<23) /* 111=32kHz, 110=44.1kHz, 101=48kHz, */
101 #define RME9652_F_2 (1<<24) /* external Crystal Chip if ERF=1 */
102 #define RME9652_ERF (1<<25) /* Error-Flag of SDPIF Receiver (1=No Lock) */
103 #define RME9652_buffer_id (1<<26) /* toggles by each interrupt on rec/play */
104 #define RME9652_tc_valid (1<<27) /* 1 = a signal is detected on time-code input */
105 #define RME9652_SPDIF_READ (1<<28) /* byte available from Rev 1.5+ S/PDIF interface */
106
107 #define RME9652_sync (RME9652_sync_0|RME9652_sync_1|RME9652_sync_2)
108 #define RME9652_lock (RME9652_lock_0|RME9652_lock_1|RME9652_lock_2)
109 #define RME9652_F (RME9652_F_0|RME9652_F_1|RME9652_F_2)
110 #define rme9652_decode_spdif_rate(x) ((x)>>22)
111
112 /* Bit 6..15 : h/w buffer pointer */
113
114 #define RME9652_buf_pos 0x000FFC0
115
116 /* Bits 31,30,29 are bits 5,4,3 of h/w pointer position on later
117 Rev G EEPROMS and Rev 1.5 cards or later.
118 */
119
120 #define RME9652_REV15_buf_pos(x) ((((x)&0xE0000000)>>26)|((x)&RME9652_buf_pos))
121
122 /* amount of io space we remap for register access. i'm not sure we
123 even need this much, but 1K is nice round number :)
124 */
125
126 #define RME9652_IO_EXTENT 1024
127
128 #define RME9652_init_buffer 0
129 #define RME9652_play_buffer 32 /* holds ptr to 26x64kBit host RAM */
130 #define RME9652_rec_buffer 36 /* holds ptr to 26x64kBit host RAM */
131 #define RME9652_control_register 64
132 #define RME9652_irq_clear 96
133 #define RME9652_time_code 100 /* useful if used with alesis adat */
134 #define RME9652_thru_base 128 /* 132...228 Thru for 26 channels */
135
136 /* Read-only registers */
137
138 /* Writing to any of the register locations writes to the status
139 register. We'll use the first location as our point of access.
140 */
141
142 #define RME9652_status_register 0
143
144 /* --------- Control-Register Bits ---------------- */
145
146
147 #define RME9652_start_bit (1<<0) /* start record/play */
148 /* bits 1-3 encode buffersize/latency */
149 #define RME9652_Master (1<<4) /* Clock Mode Master=1,Slave/Auto=0 */
150 #define RME9652_IE (1<<5) /* Interrupt Enable */
151 #define RME9652_freq (1<<6) /* samplerate 0=44.1/88.2, 1=48/96 kHz */
152 #define RME9652_freq1 (1<<7) /* if 0, 32kHz, else always 1 */
153 #define RME9652_DS (1<<8) /* Doule Speed 0=44.1/48, 1=88.2/96 Khz */
154 #define RME9652_PRO (1<<9) /* S/PDIF out: 0=consumer, 1=professional */
155 #define RME9652_EMP (1<<10) /* Emphasis 0=None, 1=ON */
156 #define RME9652_Dolby (1<<11) /* Non-audio bit 1=set, 0=unset */
157 #define RME9652_opt_out (1<<12) /* Use 1st optical OUT as SPDIF: 1=yes,0=no */
158 #define RME9652_wsel (1<<13) /* use Wordclock as sync (overwrites master) */
159 #define RME9652_inp_0 (1<<14) /* SPDIF-IN: 00=optical (ADAT1), */
160 #define RME9652_inp_1 (1<<15) /* 01=koaxial (Cinch), 10=Internal CDROM */
161 #define RME9652_SyncPref_ADAT2 (1<<16)
162 #define RME9652_SyncPref_ADAT3 (1<<17)
163 #define RME9652_SPDIF_RESET (1<<18) /* Rev 1.5+: h/w S/PDIF receiver */
164 #define RME9652_SPDIF_SELECT (1<<19)
165 #define RME9652_SPDIF_CLOCK (1<<20)
166 #define RME9652_SPDIF_WRITE (1<<21)
167 #define RME9652_ADAT1_INTERNAL (1<<22) /* Rev 1.5+: if set, internal CD connector carries ADAT */
168
169 /* buffersize = 512Bytes * 2^n, where n is made from Bit2 ... Bit0 */
170
171 #define RME9652_latency 0x0e
172 #define rme9652_encode_latency(x) (((x)&0x7)<<1)
173 #define rme9652_decode_latency(x) (((x)>>1)&0x7)
174 #define rme9652_running_double_speed(s) ((s)->control_register & RME9652_DS)
175 #define RME9652_inp (RME9652_inp_0|RME9652_inp_1)
176 #define rme9652_encode_spdif_in(x) (((x)&0x3)<<14)
177 #define rme9652_decode_spdif_in(x) (((x)>>14)&0x3)
178
179 #define RME9652_SyncPref_Mask (RME9652_SyncPref_ADAT2|RME9652_SyncPref_ADAT3)
180 #define RME9652_SyncPref_ADAT1 0
181 #define RME9652_SyncPref_SPDIF (RME9652_SyncPref_ADAT2|RME9652_SyncPref_ADAT3)
182
183 /* the size of a substream (1 mono data stream) */
184
185 #define RME9652_CHANNEL_BUFFER_SAMPLES (16*1024)
186 #define RME9652_CHANNEL_BUFFER_BYTES (4*RME9652_CHANNEL_BUFFER_SAMPLES)
187
188 /* the size of the area we need to allocate for DMA transfers. the
189 size is the same regardless of the number of channels - the
190 9636 still uses the same memory area.
191
192 Note that we allocate 1 more channel than is apparently needed
193 because the h/w seems to write 1 byte beyond the end of the last
194 page. Sigh.
195 */
196
197 #define RME9652_DMA_AREA_BYTES ((RME9652_NCHANNELS+1) * RME9652_CHANNEL_BUFFER_BYTES)
198 #define RME9652_DMA_AREA_KILOBYTES (RME9652_DMA_AREA_BYTES/1024)
199
200 struct snd_rme9652 {
201 int dev;
202
203 spinlock_t lock;
204 int irq;
205 unsigned long port;
206 void __iomem *iobase;
207
208 int precise_ptr;
209
210 u32 control_register; /* cached value */
211 u32 thru_bits; /* thru 1=on, 0=off channel 1=Bit1... channel 26= Bit26 */
212
213 u32 creg_spdif;
214 u32 creg_spdif_stream;
215
216 char *card_name; /* hammerfall or hammerfall light names */
217
218 size_t hw_offsetmask; /* &-with status register to get real hw_offset */
219 size_t prev_hw_offset; /* previous hw offset */
220 size_t max_jitter; /* maximum jitter in frames for
221 hw pointer */
222 size_t period_bytes; /* guess what this is */
223
224 unsigned char ds_channels;
225 unsigned char ss_channels; /* different for hammerfall/hammerfall-light */
226
227 struct snd_dma_buffer playback_dma_buf;
228 struct snd_dma_buffer capture_dma_buf;
229
230 unsigned char *capture_buffer; /* suitably aligned address */
231 unsigned char *playback_buffer; /* suitably aligned address */
232
233 pid_t capture_pid;
234 pid_t playback_pid;
235
236 struct snd_pcm_substream *capture_substream;
237 struct snd_pcm_substream *playback_substream;
238 int running;
239
240 int passthru; /* non-zero if doing pass-thru */
241 int hw_rev; /* h/w rev * 10 (i.e. 1.5 has hw_rev = 15) */
242
243 int last_spdif_sample_rate; /* so that we can catch externally ... */
244 int last_adat_sample_rate; /* ... induced rate changes */
245
246 char *channel_map;
247
248 struct snd_card *card;
249 struct snd_pcm *pcm;
250 struct pci_dev *pci;
251 struct snd_kcontrol *spdif_ctl;
252
253 };
254
255 /* These tables map the ALSA channels 1..N to the channels that we
256 need to use in order to find the relevant channel buffer. RME
257 refer to this kind of mapping as between "the ADAT channel and
258 the DMA channel." We index it using the logical audio channel,
259 and the value is the DMA channel (i.e. channel buffer number)
260 where the data for that channel can be read/written from/to.
261 */
262
263 static char channel_map_9652_ss[26] = {
264 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
265 18, 19, 20, 21, 22, 23, 24, 25
266 };
267
268 static char channel_map_9636_ss[26] = {
269 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
270 /* channels 16 and 17 are S/PDIF */
271 24, 25,
272 /* channels 18-25 don't exist */
273 -1, -1, -1, -1, -1, -1, -1, -1
274 };
275
276 static char channel_map_9652_ds[26] = {
277 /* ADAT channels are remapped */
278 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
279 /* channels 12 and 13 are S/PDIF */
280 24, 25,
281 /* others don't exist */
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
283 };
284
285 static char channel_map_9636_ds[26] = {
286 /* ADAT channels are remapped */
287 1, 3, 5, 7, 9, 11, 13, 15,
288 /* channels 8 and 9 are S/PDIF */
289 24, 25
290 /* others don't exist */
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
292 };
293
294 static int snd_hammerfall_get_buffer(struct pci_dev *pci, struct snd_dma_buffer *dmab, size_t size)
295 {
296 dmab->dev.type = SNDRV_DMA_TYPE_DEV;
297 dmab->dev.dev = snd_dma_pci_data(pci);
298 if (snd_dma_get_reserved_buf(dmab, snd_dma_pci_buf_id(pci))) {
299 if (dmab->bytes >= size)
300 return 0;
301 }
302 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
303 size, dmab) < 0)
304 return -ENOMEM;
305 return 0;
306 }
307
308 static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_dev *pci)
309 {
310 if (dmab->area) {
311 dmab->dev.dev = NULL; /* make it anonymous */
312 snd_dma_reserve_buf(dmab, snd_dma_pci_buf_id(pci));
313 }
314 }
315
316
317 static struct pci_device_id snd_rme9652_ids[] = {
318 {
319 .vendor = 0x10ee,
320 .device = 0x3fc4,
321 .subvendor = PCI_ANY_ID,
322 .subdevice = PCI_ANY_ID,
323 }, /* RME Digi9652 */
324 { 0, },
325 };
326
327 MODULE_DEVICE_TABLE(pci, snd_rme9652_ids);
328
329 static inline void rme9652_write(struct snd_rme9652 *rme9652, int reg, int val)
330 {
331 writel(val, rme9652->iobase + reg);
332 }
333
334 static inline unsigned int rme9652_read(struct snd_rme9652 *rme9652, int reg)
335 {
336 return readl(rme9652->iobase + reg);
337 }
338
339 static inline int snd_rme9652_use_is_exclusive(struct snd_rme9652 *rme9652)
340 {
341 unsigned long flags;
342 int ret = 1;
343
344 spin_lock_irqsave(&rme9652->lock, flags);
345 if ((rme9652->playback_pid != rme9652->capture_pid) &&
346 (rme9652->playback_pid >= 0) && (rme9652->capture_pid >= 0)) {
347 ret = 0;
348 }
349 spin_unlock_irqrestore(&rme9652->lock, flags);
350 return ret;
351 }
352
353 static inline int rme9652_adat_sample_rate(struct snd_rme9652 *rme9652)
354 {
355 if (rme9652_running_double_speed(rme9652)) {
356 return (rme9652_read(rme9652, RME9652_status_register) &
357 RME9652_fs48) ? 96000 : 88200;
358 } else {
359 return (rme9652_read(rme9652, RME9652_status_register) &
360 RME9652_fs48) ? 48000 : 44100;
361 }
362 }
363
364 static inline void rme9652_compute_period_size(struct snd_rme9652 *rme9652)
365 {
366 unsigned int i;
367
368 i = rme9652->control_register & RME9652_latency;
369 rme9652->period_bytes = 1 << ((rme9652_decode_latency(i) + 8));
370 rme9652->hw_offsetmask =
371 (rme9652->period_bytes * 2 - 1) & RME9652_buf_pos;
372 rme9652->max_jitter = 80;
373 }
374
375 static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652)
376 {
377 int status;
378 unsigned int offset, frag;
379 snd_pcm_uframes_t period_size = rme9652->period_bytes / 4;
380 snd_pcm_sframes_t delta;
381
382 status = rme9652_read(rme9652, RME9652_status_register);
383 if (!rme9652->precise_ptr)
384 return (status & RME9652_buffer_id) ? period_size : 0;
385 offset = status & RME9652_buf_pos;
386
387 /* The hardware may give a backward movement for up to 80 frames
388 Martin Kirst <martin.kirst@freenet.de> knows the details.
389 */
390
391 delta = rme9652->prev_hw_offset - offset;
392 delta &= 0xffff;
393 if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4)
394 offset = rme9652->prev_hw_offset;
395 else
396 rme9652->prev_hw_offset = offset;
397 offset &= rme9652->hw_offsetmask;
398 offset /= 4;
399 frag = status & RME9652_buffer_id;
400
401 if (offset < period_size) {
402 if (offset > rme9652->max_jitter) {
403 if (frag)
404 printk(KERN_ERR "Unexpected hw_pointer position (bufid == 0): status: %x offset: %d\n", status, offset);
405 } else if (!frag)
406 return 0;
407 offset -= rme9652->max_jitter;
408 if ((int)offset < 0)
409 offset += period_size * 2;
410 } else {
411 if (offset > period_size + rme9652->max_jitter) {
412 if (!frag)
413 printk(KERN_ERR "Unexpected hw_pointer position (bufid == 1): status: %x offset: %d\n", status, offset);
414 } else if (frag)
415 return period_size;
416 offset -= rme9652->max_jitter;
417 }
418
419 return offset;
420 }
421
422 static inline void rme9652_reset_hw_pointer(struct snd_rme9652 *rme9652)
423 {
424 int i;
425
426 /* reset the FIFO pointer to zero. We do this by writing to 8
427 registers, each of which is a 32bit wide register, and set
428 them all to zero. Note that s->iobase is a pointer to
429 int32, not pointer to char.
430 */
431
432 for (i = 0; i < 8; i++) {
433 rme9652_write(rme9652, i * 4, 0);
434 udelay(10);
435 }
436 rme9652->prev_hw_offset = 0;
437 }
438
439 static inline void rme9652_start(struct snd_rme9652 *s)
440 {
441 s->control_register |= (RME9652_IE | RME9652_start_bit);
442 rme9652_write(s, RME9652_control_register, s->control_register);
443 }
444
445 static inline void rme9652_stop(struct snd_rme9652 *s)
446 {
447 s->control_register &= ~(RME9652_start_bit | RME9652_IE);
448 rme9652_write(s, RME9652_control_register, s->control_register);
449 }
450
451 static int rme9652_set_interrupt_interval(struct snd_rme9652 *s,
452 unsigned int frames)
453 {
454 int restart = 0;
455 int n;
456
457 spin_lock_irq(&s->lock);
458
459 if ((restart = s->running)) {
460 rme9652_stop(s);
461 }
462
463 frames >>= 7;
464 n = 0;
465 while (frames) {
466 n++;
467 frames >>= 1;
468 }
469
470 s->control_register &= ~RME9652_latency;
471 s->control_register |= rme9652_encode_latency(n);
472
473 rme9652_write(s, RME9652_control_register, s->control_register);
474
475 rme9652_compute_period_size(s);
476
477 if (restart)
478 rme9652_start(s);
479
480 spin_unlock_irq(&s->lock);
481
482 return 0;
483 }
484
485 static int rme9652_set_rate(struct snd_rme9652 *rme9652, int rate)
486 {
487 int restart;
488 int reject_if_open = 0;
489 int xrate;
490
491 if (!snd_rme9652_use_is_exclusive (rme9652)) {
492 return -EBUSY;
493 }
494
495 /* Changing from a "single speed" to a "double speed" rate is
496 not allowed if any substreams are open. This is because
497 such a change causes a shift in the location of
498 the DMA buffers and a reduction in the number of available
499 buffers.
500
501 Note that a similar but essentially insoluble problem
502 exists for externally-driven rate changes. All we can do
503 is to flag rate changes in the read/write routines.
504 */
505
506 spin_lock_irq(&rme9652->lock);
507 xrate = rme9652_adat_sample_rate(rme9652);
508
509 switch (rate) {
510 case 44100:
511 if (xrate > 48000) {
512 reject_if_open = 1;
513 }
514 rate = 0;
515 break;
516 case 48000:
517 if (xrate > 48000) {
518 reject_if_open = 1;
519 }
520 rate = RME9652_freq;
521 break;
522 case 88200:
523 if (xrate < 48000) {
524 reject_if_open = 1;
525 }
526 rate = RME9652_DS;
527 break;
528 case 96000:
529 if (xrate < 48000) {
530 reject_if_open = 1;
531 }
532 rate = RME9652_DS | RME9652_freq;
533 break;
534 default:
535 spin_unlock_irq(&rme9652->lock);
536 return -EINVAL;
537 }
538
539 if (reject_if_open && (rme9652->capture_pid >= 0 || rme9652->playback_pid >= 0)) {
540 spin_unlock_irq(&rme9652->lock);
541 return -EBUSY;
542 }
543
544 if ((restart = rme9652->running)) {
545 rme9652_stop(rme9652);
546 }
547 rme9652->control_register &= ~(RME9652_freq | RME9652_DS);
548 rme9652->control_register |= rate;
549 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
550
551 if (restart) {
552 rme9652_start(rme9652);
553 }
554
555 if (rate & RME9652_DS) {
556 if (rme9652->ss_channels == RME9652_NCHANNELS) {
557 rme9652->channel_map = channel_map_9652_ds;
558 } else {
559 rme9652->channel_map = channel_map_9636_ds;
560 }
561 } else {
562 if (rme9652->ss_channels == RME9652_NCHANNELS) {
563 rme9652->channel_map = channel_map_9652_ss;
564 } else {
565 rme9652->channel_map = channel_map_9636_ss;
566 }
567 }
568
569 spin_unlock_irq(&rme9652->lock);
570 return 0;
571 }
572
573 static void rme9652_set_thru(struct snd_rme9652 *rme9652, int channel, int enable)
574 {
575 int i;
576
577 rme9652->passthru = 0;
578
579 if (channel < 0) {
580
581 /* set thru for all channels */
582
583 if (enable) {
584 for (i = 0; i < RME9652_NCHANNELS; i++) {
585 rme9652->thru_bits |= (1 << i);
586 rme9652_write(rme9652, RME9652_thru_base + i * 4, 1);
587 }
588 } else {
589 for (i = 0; i < RME9652_NCHANNELS; i++) {
590 rme9652->thru_bits &= ~(1 << i);
591 rme9652_write(rme9652, RME9652_thru_base + i * 4, 0);
592 }
593 }
594
595 } else {
596 int mapped_channel;
597
598 snd_assert(channel == RME9652_NCHANNELS, return);
599
600 mapped_channel = rme9652->channel_map[channel];
601
602 if (enable) {
603 rme9652->thru_bits |= (1 << mapped_channel);
604 } else {
605 rme9652->thru_bits &= ~(1 << mapped_channel);
606 }
607
608 rme9652_write(rme9652,
609 RME9652_thru_base + mapped_channel * 4,
610 enable ? 1 : 0);
611 }
612 }
613
614 static int rme9652_set_passthru(struct snd_rme9652 *rme9652, int onoff)
615 {
616 if (onoff) {
617 rme9652_set_thru(rme9652, -1, 1);
618
619 /* we don't want interrupts, so do a
620 custom version of rme9652_start().
621 */
622
623 rme9652->control_register =
624 RME9652_inp_0 |
625 rme9652_encode_latency(7) |
626 RME9652_start_bit;
627
628 rme9652_reset_hw_pointer(rme9652);
629
630 rme9652_write(rme9652, RME9652_control_register,
631 rme9652->control_register);
632 rme9652->passthru = 1;
633 } else {
634 rme9652_set_thru(rme9652, -1, 0);
635 rme9652_stop(rme9652);
636 rme9652->passthru = 0;
637 }
638
639 return 0;
640 }
641
642 static void rme9652_spdif_set_bit (struct snd_rme9652 *rme9652, int mask, int onoff)
643 {
644 if (onoff)
645 rme9652->control_register |= mask;
646 else
647 rme9652->control_register &= ~mask;
648
649 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
650 }
651
652 static void rme9652_spdif_write_byte (struct snd_rme9652 *rme9652, const int val)
653 {
654 long mask;
655 long i;
656
657 for (i = 0, mask = 0x80; i < 8; i++, mask >>= 1) {
658 if (val & mask)
659 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_WRITE, 1);
660 else
661 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_WRITE, 0);
662
663 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 1);
664 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 0);
665 }
666 }
667
668 static int rme9652_spdif_read_byte (struct snd_rme9652 *rme9652)
669 {
670 long mask;
671 long val;
672 long i;
673
674 val = 0;
675
676 for (i = 0, mask = 0x80; i < 8; i++, mask >>= 1) {
677 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 1);
678 if (rme9652_read (rme9652, RME9652_status_register) & RME9652_SPDIF_READ)
679 val |= mask;
680 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 0);
681 }
682
683 return val;
684 }
685
686 static void rme9652_write_spdif_codec (struct snd_rme9652 *rme9652, const int address, const int data)
687 {
688 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
689 rme9652_spdif_write_byte (rme9652, 0x20);
690 rme9652_spdif_write_byte (rme9652, address);
691 rme9652_spdif_write_byte (rme9652, data);
692 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
693 }
694
695
696 static int rme9652_spdif_read_codec (struct snd_rme9652 *rme9652, const int address)
697 {
698 int ret;
699
700 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
701 rme9652_spdif_write_byte (rme9652, 0x20);
702 rme9652_spdif_write_byte (rme9652, address);
703 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
704 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
705
706 rme9652_spdif_write_byte (rme9652, 0x21);
707 ret = rme9652_spdif_read_byte (rme9652);
708 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
709
710 return ret;
711 }
712
713 static void rme9652_initialize_spdif_receiver (struct snd_rme9652 *rme9652)
714 {
715 /* XXX what unsets this ? */
716
717 rme9652->control_register |= RME9652_SPDIF_RESET;
718
719 rme9652_write_spdif_codec (rme9652, 4, 0x40);
720 rme9652_write_spdif_codec (rme9652, 17, 0x13);
721 rme9652_write_spdif_codec (rme9652, 6, 0x02);
722 }
723
724 static inline int rme9652_spdif_sample_rate(struct snd_rme9652 *s)
725 {
726 unsigned int rate_bits;
727
728 if (rme9652_read(s, RME9652_status_register) & RME9652_ERF) {
729 return -1; /* error condition */
730 }
731
732 if (s->hw_rev == 15) {
733
734 int x, y, ret;
735
736 x = rme9652_spdif_read_codec (s, 30);
737
738 if (x != 0)
739 y = 48000 * 64 / x;
740 else
741 y = 0;
742
743 if (y > 30400 && y < 33600) ret = 32000;
744 else if (y > 41900 && y < 46000) ret = 44100;
745 else if (y > 46000 && y < 50400) ret = 48000;
746 else if (y > 60800 && y < 67200) ret = 64000;
747 else if (y > 83700 && y < 92000) ret = 88200;
748 else if (y > 92000 && y < 100000) ret = 96000;
749 else ret = 0;
750 return ret;
751 }
752
753 rate_bits = rme9652_read(s, RME9652_status_register) & RME9652_F;
754
755 switch (rme9652_decode_spdif_rate(rate_bits)) {
756 case 0x7:
757 return 32000;
758 break;
759
760 case 0x6:
761 return 44100;
762 break;
763
764 case 0x5:
765 return 48000;
766 break;
767
768 case 0x4:
769 return 88200;
770 break;
771
772 case 0x3:
773 return 96000;
774 break;
775
776 case 0x0:
777 return 64000;
778 break;
779
780 default:
781 snd_printk(KERN_ERR "%s: unknown S/PDIF input rate (bits = 0x%x)\n",
782 s->card_name, rate_bits);
783 return 0;
784 break;
785 }
786 }
787
788 /*-----------------------------------------------------------------------------
789 Control Interface
790 ----------------------------------------------------------------------------*/
791
792 static u32 snd_rme9652_convert_from_aes(struct snd_aes_iec958 *aes)
793 {
794 u32 val = 0;
795 val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME9652_PRO : 0;
796 val |= (aes->status[0] & IEC958_AES0_NONAUDIO) ? RME9652_Dolby : 0;
797 if (val & RME9652_PRO)
798 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? RME9652_EMP : 0;
799 else
800 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? RME9652_EMP : 0;
801 return val;
802 }
803
804 static void snd_rme9652_convert_to_aes(struct snd_aes_iec958 *aes, u32 val)
805 {
806 aes->status[0] = ((val & RME9652_PRO) ? IEC958_AES0_PROFESSIONAL : 0) |
807 ((val & RME9652_Dolby) ? IEC958_AES0_NONAUDIO : 0);
808 if (val & RME9652_PRO)
809 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0;
810 else
811 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0;
812 }
813
814 static int snd_rme9652_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
815 {
816 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
817 uinfo->count = 1;
818 return 0;
819 }
820
821 static int snd_rme9652_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
822 {
823 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
824
825 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif);
826 return 0;
827 }
828
829 static int snd_rme9652_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
830 {
831 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
832 int change;
833 u32 val;
834
835 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958);
836 spin_lock_irq(&rme9652->lock);
837 change = val != rme9652->creg_spdif;
838 rme9652->creg_spdif = val;
839 spin_unlock_irq(&rme9652->lock);
840 return change;
841 }
842
843 static int snd_rme9652_control_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
844 {
845 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
846 uinfo->count = 1;
847 return 0;
848 }
849
850 static int snd_rme9652_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
851 {
852 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
853
854 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif_stream);
855 return 0;
856 }
857
858 static int snd_rme9652_control_spdif_stream_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
859 {
860 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
861 int change;
862 u32 val;
863
864 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958);
865 spin_lock_irq(&rme9652->lock);
866 change = val != rme9652->creg_spdif_stream;
867 rme9652->creg_spdif_stream = val;
868 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
869 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= val);
870 spin_unlock_irq(&rme9652->lock);
871 return change;
872 }
873
874 static int snd_rme9652_control_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
875 {
876 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
877 uinfo->count = 1;
878 return 0;
879 }
880
881 static int snd_rme9652_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
882 {
883 ucontrol->value.iec958.status[0] = kcontrol->private_value;
884 return 0;
885 }
886
887 #define RME9652_ADAT1_IN(xname, xindex) \
888 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
889 .info = snd_rme9652_info_adat1_in, \
890 .get = snd_rme9652_get_adat1_in, \
891 .put = snd_rme9652_put_adat1_in }
892
893 static unsigned int rme9652_adat1_in(struct snd_rme9652 *rme9652)
894 {
895 if (rme9652->control_register & RME9652_ADAT1_INTERNAL)
896 return 1;
897 return 0;
898 }
899
900 static int rme9652_set_adat1_input(struct snd_rme9652 *rme9652, int internal)
901 {
902 int restart = 0;
903
904 if (internal) {
905 rme9652->control_register |= RME9652_ADAT1_INTERNAL;
906 } else {
907 rme9652->control_register &= ~RME9652_ADAT1_INTERNAL;
908 }
909
910 /* XXX do we actually need to stop the card when we do this ? */
911
912 if ((restart = rme9652->running)) {
913 rme9652_stop(rme9652);
914 }
915
916 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
917
918 if (restart) {
919 rme9652_start(rme9652);
920 }
921
922 return 0;
923 }
924
925 static int snd_rme9652_info_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
926 {
927 static char *texts[2] = {"ADAT1", "Internal"};
928
929 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
930 uinfo->count = 1;
931 uinfo->value.enumerated.items = 2;
932 if (uinfo->value.enumerated.item > 1)
933 uinfo->value.enumerated.item = 1;
934 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
935 return 0;
936 }
937
938 static int snd_rme9652_get_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
939 {
940 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
941
942 spin_lock_irq(&rme9652->lock);
943 ucontrol->value.enumerated.item[0] = rme9652_adat1_in(rme9652);
944 spin_unlock_irq(&rme9652->lock);
945 return 0;
946 }
947
948 static int snd_rme9652_put_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
949 {
950 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
951 int change;
952 unsigned int val;
953
954 if (!snd_rme9652_use_is_exclusive(rme9652))
955 return -EBUSY;
956 val = ucontrol->value.enumerated.item[0] % 2;
957 spin_lock_irq(&rme9652->lock);
958 change = val != rme9652_adat1_in(rme9652);
959 if (change)
960 rme9652_set_adat1_input(rme9652, val);
961 spin_unlock_irq(&rme9652->lock);
962 return change;
963 }
964
965 #define RME9652_SPDIF_IN(xname, xindex) \
966 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
967 .info = snd_rme9652_info_spdif_in, \
968 .get = snd_rme9652_get_spdif_in, .put = snd_rme9652_put_spdif_in }
969
970 static unsigned int rme9652_spdif_in(struct snd_rme9652 *rme9652)
971 {
972 return rme9652_decode_spdif_in(rme9652->control_register &
973 RME9652_inp);
974 }
975
976 static int rme9652_set_spdif_input(struct snd_rme9652 *rme9652, int in)
977 {
978 int restart = 0;
979
980 rme9652->control_register &= ~RME9652_inp;
981 rme9652->control_register |= rme9652_encode_spdif_in(in);
982
983 if ((restart = rme9652->running)) {
984 rme9652_stop(rme9652);
985 }
986
987 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
988
989 if (restart) {
990 rme9652_start(rme9652);
991 }
992
993 return 0;
994 }
995
996 static int snd_rme9652_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
997 {
998 static char *texts[3] = {"ADAT1", "Coaxial", "Internal"};
999
1000 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1001 uinfo->count = 1;
1002 uinfo->value.enumerated.items = 3;
1003 if (uinfo->value.enumerated.item > 2)
1004 uinfo->value.enumerated.item = 2;
1005 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1006 return 0;
1007 }
1008
1009 static int snd_rme9652_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1010 {
1011 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1012
1013 spin_lock_irq(&rme9652->lock);
1014 ucontrol->value.enumerated.item[0] = rme9652_spdif_in(rme9652);
1015 spin_unlock_irq(&rme9652->lock);
1016 return 0;
1017 }
1018
1019 static int snd_rme9652_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1020 {
1021 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1022 int change;
1023 unsigned int val;
1024
1025 if (!snd_rme9652_use_is_exclusive(rme9652))
1026 return -EBUSY;
1027 val = ucontrol->value.enumerated.item[0] % 3;
1028 spin_lock_irq(&rme9652->lock);
1029 change = val != rme9652_spdif_in(rme9652);
1030 if (change)
1031 rme9652_set_spdif_input(rme9652, val);
1032 spin_unlock_irq(&rme9652->lock);
1033 return change;
1034 }
1035
1036 #define RME9652_SPDIF_OUT(xname, xindex) \
1037 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1038 .info = snd_rme9652_info_spdif_out, \
1039 .get = snd_rme9652_get_spdif_out, .put = snd_rme9652_put_spdif_out }
1040
1041 static int rme9652_spdif_out(struct snd_rme9652 *rme9652)
1042 {
1043 return (rme9652->control_register & RME9652_opt_out) ? 1 : 0;
1044 }
1045
1046 static int rme9652_set_spdif_output(struct snd_rme9652 *rme9652, int out)
1047 {
1048 int restart = 0;
1049
1050 if (out) {
1051 rme9652->control_register |= RME9652_opt_out;
1052 } else {
1053 rme9652->control_register &= ~RME9652_opt_out;
1054 }
1055
1056 if ((restart = rme9652->running)) {
1057 rme9652_stop(rme9652);
1058 }
1059
1060 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1061
1062 if (restart) {
1063 rme9652_start(rme9652);
1064 }
1065
1066 return 0;
1067 }
1068
1069 #define snd_rme9652_info_spdif_out snd_ctl_boolean_mono_info
1070
1071 static int snd_rme9652_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1072 {
1073 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1074
1075 spin_lock_irq(&rme9652->lock);
1076 ucontrol->value.integer.value[0] = rme9652_spdif_out(rme9652);
1077 spin_unlock_irq(&rme9652->lock);
1078 return 0;
1079 }
1080
1081 static int snd_rme9652_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1082 {
1083 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1084 int change;
1085 unsigned int val;
1086
1087 if (!snd_rme9652_use_is_exclusive(rme9652))
1088 return -EBUSY;
1089 val = ucontrol->value.integer.value[0] & 1;
1090 spin_lock_irq(&rme9652->lock);
1091 change = (int)val != rme9652_spdif_out(rme9652);
1092 rme9652_set_spdif_output(rme9652, val);
1093 spin_unlock_irq(&rme9652->lock);
1094 return change;
1095 }
1096
1097 #define RME9652_SYNC_MODE(xname, xindex) \
1098 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1099 .info = snd_rme9652_info_sync_mode, \
1100 .get = snd_rme9652_get_sync_mode, .put = snd_rme9652_put_sync_mode }
1101
1102 static int rme9652_sync_mode(struct snd_rme9652 *rme9652)
1103 {
1104 if (rme9652->control_register & RME9652_wsel) {
1105 return 2;
1106 } else if (rme9652->control_register & RME9652_Master) {
1107 return 1;
1108 } else {
1109 return 0;
1110 }
1111 }
1112
1113 static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode)
1114 {
1115 int restart = 0;
1116
1117 switch (mode) {
1118 case 0:
1119 rme9652->control_register &=
1120 ~(RME9652_Master | RME9652_wsel);
1121 break;
1122 case 1:
1123 rme9652->control_register =
1124 (rme9652->control_register & ~RME9652_wsel) | RME9652_Master;
1125 break;
1126 case 2:
1127 rme9652->control_register |=
1128 (RME9652_Master | RME9652_wsel);
1129 break;
1130 }
1131
1132 if ((restart = rme9652->running)) {
1133 rme9652_stop(rme9652);
1134 }
1135
1136 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1137
1138 if (restart) {
1139 rme9652_start(rme9652);
1140 }
1141
1142 return 0;
1143 }
1144
1145 static int snd_rme9652_info_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1146 {
1147 static char *texts[3] = {"AutoSync", "Master", "Word Clock"};
1148
1149 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1150 uinfo->count = 1;
1151 uinfo->value.enumerated.items = 3;
1152 if (uinfo->value.enumerated.item > 2)
1153 uinfo->value.enumerated.item = 2;
1154 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1155 return 0;
1156 }
1157
1158 static int snd_rme9652_get_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1159 {
1160 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1161
1162 spin_lock_irq(&rme9652->lock);
1163 ucontrol->value.enumerated.item[0] = rme9652_sync_mode(rme9652);
1164 spin_unlock_irq(&rme9652->lock);
1165 return 0;
1166 }
1167
1168 static int snd_rme9652_put_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1169 {
1170 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1171 int change;
1172 unsigned int val;
1173
1174 val = ucontrol->value.enumerated.item[0] % 3;
1175 spin_lock_irq(&rme9652->lock);
1176 change = (int)val != rme9652_sync_mode(rme9652);
1177 rme9652_set_sync_mode(rme9652, val);
1178 spin_unlock_irq(&rme9652->lock);
1179 return change;
1180 }
1181
1182 #define RME9652_SYNC_PREF(xname, xindex) \
1183 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1184 .info = snd_rme9652_info_sync_pref, \
1185 .get = snd_rme9652_get_sync_pref, .put = snd_rme9652_put_sync_pref }
1186
1187 static int rme9652_sync_pref(struct snd_rme9652 *rme9652)
1188 {
1189 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1190 case RME9652_SyncPref_ADAT1:
1191 return RME9652_SYNC_FROM_ADAT1;
1192 case RME9652_SyncPref_ADAT2:
1193 return RME9652_SYNC_FROM_ADAT2;
1194 case RME9652_SyncPref_ADAT3:
1195 return RME9652_SYNC_FROM_ADAT3;
1196 case RME9652_SyncPref_SPDIF:
1197 return RME9652_SYNC_FROM_SPDIF;
1198 }
1199 /* Not reachable */
1200 return 0;
1201 }
1202
1203 static int rme9652_set_sync_pref(struct snd_rme9652 *rme9652, int pref)
1204 {
1205 int restart;
1206
1207 rme9652->control_register &= ~RME9652_SyncPref_Mask;
1208 switch (pref) {
1209 case RME9652_SYNC_FROM_ADAT1:
1210 rme9652->control_register |= RME9652_SyncPref_ADAT1;
1211 break;
1212 case RME9652_SYNC_FROM_ADAT2:
1213 rme9652->control_register |= RME9652_SyncPref_ADAT2;
1214 break;
1215 case RME9652_SYNC_FROM_ADAT3:
1216 rme9652->control_register |= RME9652_SyncPref_ADAT3;
1217 break;
1218 case RME9652_SYNC_FROM_SPDIF:
1219 rme9652->control_register |= RME9652_SyncPref_SPDIF;
1220 break;
1221 }
1222
1223 if ((restart = rme9652->running)) {
1224 rme9652_stop(rme9652);
1225 }
1226
1227 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1228
1229 if (restart) {
1230 rme9652_start(rme9652);
1231 }
1232
1233 return 0;
1234 }
1235
1236 static int snd_rme9652_info_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1237 {
1238 static char *texts[4] = {"IEC958 In", "ADAT1 In", "ADAT2 In", "ADAT3 In"};
1239 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1240
1241 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1242 uinfo->count = 1;
1243 uinfo->value.enumerated.items = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3;
1244 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1245 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1246 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1247 return 0;
1248 }
1249
1250 static int snd_rme9652_get_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1251 {
1252 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1253
1254 spin_lock_irq(&rme9652->lock);
1255 ucontrol->value.enumerated.item[0] = rme9652_sync_pref(rme9652);
1256 spin_unlock_irq(&rme9652->lock);
1257 return 0;
1258 }
1259
1260 static int snd_rme9652_put_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1261 {
1262 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1263 int change, max;
1264 unsigned int val;
1265
1266 if (!snd_rme9652_use_is_exclusive(rme9652))
1267 return -EBUSY;
1268 max = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3;
1269 val = ucontrol->value.enumerated.item[0] % max;
1270 spin_lock_irq(&rme9652->lock);
1271 change = (int)val != rme9652_sync_pref(rme9652);
1272 rme9652_set_sync_pref(rme9652, val);
1273 spin_unlock_irq(&rme9652->lock);
1274 return change;
1275 }
1276
1277 static int snd_rme9652_info_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1278 {
1279 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1280 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1281 uinfo->count = rme9652->ss_channels;
1282 uinfo->value.integer.min = 0;
1283 uinfo->value.integer.max = 1;
1284 return 0;
1285 }
1286
1287 static int snd_rme9652_get_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1288 {
1289 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1290 unsigned int k;
1291 u32 thru_bits = rme9652->thru_bits;
1292
1293 for (k = 0; k < rme9652->ss_channels; ++k) {
1294 ucontrol->value.integer.value[k] = !!(thru_bits & (1 << k));
1295 }
1296 return 0;
1297 }
1298
1299 static int snd_rme9652_put_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1300 {
1301 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1302 int change;
1303 unsigned int chn;
1304 u32 thru_bits = 0;
1305
1306 if (!snd_rme9652_use_is_exclusive(rme9652))
1307 return -EBUSY;
1308
1309 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1310 if (ucontrol->value.integer.value[chn])
1311 thru_bits |= 1 << chn;
1312 }
1313
1314 spin_lock_irq(&rme9652->lock);
1315 change = thru_bits ^ rme9652->thru_bits;
1316 if (change) {
1317 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1318 if (!(change & (1 << chn)))
1319 continue;
1320 rme9652_set_thru(rme9652,chn,thru_bits&(1<<chn));
1321 }
1322 }
1323 spin_unlock_irq(&rme9652->lock);
1324 return !!change;
1325 }
1326
1327 #define RME9652_PASSTHRU(xname, xindex) \
1328 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1329 .info = snd_rme9652_info_passthru, \
1330 .put = snd_rme9652_put_passthru, \
1331 .get = snd_rme9652_get_passthru }
1332
1333 #define snd_rme9652_info_passthru snd_ctl_boolean_mono_info
1334
1335 static int snd_rme9652_get_passthru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1336 {
1337 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1338
1339 spin_lock_irq(&rme9652->lock);
1340 ucontrol->value.integer.value[0] = rme9652->passthru;
1341 spin_unlock_irq(&rme9652->lock);
1342 return 0;
1343 }
1344
1345 static int snd_rme9652_put_passthru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1346 {
1347 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1348 int change;
1349 unsigned int val;
1350 int err = 0;
1351
1352 if (!snd_rme9652_use_is_exclusive(rme9652))
1353 return -EBUSY;
1354
1355 val = ucontrol->value.integer.value[0] & 1;
1356 spin_lock_irq(&rme9652->lock);
1357 change = (ucontrol->value.integer.value[0] != rme9652->passthru);
1358 if (change)
1359 err = rme9652_set_passthru(rme9652, val);
1360 spin_unlock_irq(&rme9652->lock);
1361 return err ? err : change;
1362 }
1363
1364 /* Read-only switches */
1365
1366 #define RME9652_SPDIF_RATE(xname, xindex) \
1367 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1368 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
1369 .info = snd_rme9652_info_spdif_rate, \
1370 .get = snd_rme9652_get_spdif_rate }
1371
1372 static int snd_rme9652_info_spdif_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1373 {
1374 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1375 uinfo->count = 1;
1376 uinfo->value.integer.min = 0;
1377 uinfo->value.integer.max = 96000;
1378 return 0;
1379 }
1380
1381 static int snd_rme9652_get_spdif_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1382 {
1383 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1384
1385 spin_lock_irq(&rme9652->lock);
1386 ucontrol->value.integer.value[0] = rme9652_spdif_sample_rate(rme9652);
1387 spin_unlock_irq(&rme9652->lock);
1388 return 0;
1389 }
1390
1391 #define RME9652_ADAT_SYNC(xname, xindex, xidx) \
1392 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1393 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
1394 .info = snd_rme9652_info_adat_sync, \
1395 .get = snd_rme9652_get_adat_sync, .private_value = xidx }
1396
1397 static int snd_rme9652_info_adat_sync(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1398 {
1399 static char *texts[4] = {"No Lock", "Lock", "No Lock Sync", "Lock Sync"};
1400
1401 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1402 uinfo->count = 1;
1403 uinfo->value.enumerated.items = 4;
1404 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1405 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1406 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1407 return 0;
1408 }
1409
1410 static int snd_rme9652_get_adat_sync(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1411 {
1412 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1413 unsigned int mask1, mask2, val;
1414
1415 switch (kcontrol->private_value) {
1416 case 0: mask1 = RME9652_lock_0; mask2 = RME9652_sync_0; break;
1417 case 1: mask1 = RME9652_lock_1; mask2 = RME9652_sync_1; break;
1418 case 2: mask1 = RME9652_lock_2; mask2 = RME9652_sync_2; break;
1419 default: return -EINVAL;
1420 }
1421 val = rme9652_read(rme9652, RME9652_status_register);
1422 ucontrol->value.enumerated.item[0] = (val & mask1) ? 1 : 0;
1423 ucontrol->value.enumerated.item[0] |= (val & mask2) ? 2 : 0;
1424 return 0;
1425 }
1426
1427 #define RME9652_TC_VALID(xname, xindex) \
1428 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1429 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
1430 .info = snd_rme9652_info_tc_valid, \
1431 .get = snd_rme9652_get_tc_valid }
1432
1433 #define snd_rme9652_info_tc_valid snd_ctl_boolean_mono_info
1434
1435 static int snd_rme9652_get_tc_valid(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1436 {
1437 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1438
1439 ucontrol->value.integer.value[0] =
1440 (rme9652_read(rme9652, RME9652_status_register) & RME9652_tc_valid) ? 1 : 0;
1441 return 0;
1442 }
1443
1444 #ifdef ALSA_HAS_STANDARD_WAY_OF_RETURNING_TIMECODE
1445
1446 /* FIXME: this routine needs a port to the new control API --jk */
1447
1448 static int snd_rme9652_get_tc_value(void *private_data,
1449 snd_kswitch_t *kswitch,
1450 snd_switch_t *uswitch)
1451 {
1452 struct snd_rme9652 *s = (struct snd_rme9652 *) private_data;
1453 u32 value;
1454 int i;
1455
1456 uswitch->type = SNDRV_SW_TYPE_DWORD;
1457
1458 if ((rme9652_read(s, RME9652_status_register) &
1459 RME9652_tc_valid) == 0) {
1460 uswitch->value.data32[0] = 0;
1461 return 0;
1462 }
1463
1464 /* timecode request */
1465
1466 rme9652_write(s, RME9652_time_code, 0);
1467
1468 /* XXX bug alert: loop-based timing !!!! */
1469
1470 for (i = 0; i < 50; i++) {
1471 if (!(rme9652_read(s, i * 4) & RME9652_tc_busy))
1472 break;
1473 }
1474
1475 if (!(rme9652_read(s, i * 4) & RME9652_tc_busy)) {
1476 return -EIO;
1477 }
1478
1479 value = 0;
1480
1481 for (i = 0; i < 32; i++) {
1482 value >>= 1;
1483
1484 if (rme9652_read(s, i * 4) & RME9652_tc_out)
1485 value |= 0x80000000;
1486 }
1487
1488 if (value > 2 * 60 * 48000) {
1489 value -= 2 * 60 * 48000;
1490 } else {
1491 value = 0;
1492 }
1493
1494 uswitch->value.data32[0] = value;
1495
1496 return 0;
1497 }
1498
1499 #endif /* ALSA_HAS_STANDARD_WAY_OF_RETURNING_TIMECODE */
1500
1501 static struct snd_kcontrol_new snd_rme9652_controls[] = {
1502 {
1503 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1504 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1505 .info = snd_rme9652_control_spdif_info,
1506 .get = snd_rme9652_control_spdif_get,
1507 .put = snd_rme9652_control_spdif_put,
1508 },
1509 {
1510 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1511 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1512 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
1513 .info = snd_rme9652_control_spdif_stream_info,
1514 .get = snd_rme9652_control_spdif_stream_get,
1515 .put = snd_rme9652_control_spdif_stream_put,
1516 },
1517 {
1518 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1519 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1520 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1521 .info = snd_rme9652_control_spdif_mask_info,
1522 .get = snd_rme9652_control_spdif_mask_get,
1523 .private_value = IEC958_AES0_NONAUDIO |
1524 IEC958_AES0_PROFESSIONAL |
1525 IEC958_AES0_CON_EMPHASIS,
1526 },
1527 {
1528 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1529 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1530 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1531 .info = snd_rme9652_control_spdif_mask_info,
1532 .get = snd_rme9652_control_spdif_mask_get,
1533 .private_value = IEC958_AES0_NONAUDIO |
1534 IEC958_AES0_PROFESSIONAL |
1535 IEC958_AES0_PRO_EMPHASIS,
1536 },
1537 RME9652_SPDIF_IN("IEC958 Input Connector", 0),
1538 RME9652_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
1539 RME9652_SYNC_MODE("Sync Mode", 0),
1540 RME9652_SYNC_PREF("Preferred Sync Source", 0),
1541 {
1542 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1543 .name = "Channels Thru",
1544 .index = 0,
1545 .info = snd_rme9652_info_thru,
1546 .get = snd_rme9652_get_thru,
1547 .put = snd_rme9652_put_thru,
1548 },
1549 RME9652_SPDIF_RATE("IEC958 Sample Rate", 0),
1550 RME9652_ADAT_SYNC("ADAT1 Sync Check", 0, 0),
1551 RME9652_ADAT_SYNC("ADAT2 Sync Check", 0, 1),
1552 RME9652_TC_VALID("Timecode Valid", 0),
1553 RME9652_PASSTHRU("Passthru", 0)
1554 };
1555
1556 static struct snd_kcontrol_new snd_rme9652_adat3_check =
1557 RME9652_ADAT_SYNC("ADAT3 Sync Check", 0, 2);
1558
1559 static struct snd_kcontrol_new snd_rme9652_adat1_input =
1560 RME9652_ADAT1_IN("ADAT1 Input Source", 0);
1561
1562 static int snd_rme9652_create_controls(struct snd_card *card, struct snd_rme9652 *rme9652)
1563 {
1564 unsigned int idx;
1565 int err;
1566 struct snd_kcontrol *kctl;
1567
1568 for (idx = 0; idx < ARRAY_SIZE(snd_rme9652_controls); idx++) {
1569 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_controls[idx], rme9652))) < 0)
1570 return err;
1571 if (idx == 1) /* IEC958 (S/PDIF) Stream */
1572 rme9652->spdif_ctl = kctl;
1573 }
1574
1575 if (rme9652->ss_channels == RME9652_NCHANNELS)
1576 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_adat3_check, rme9652))) < 0)
1577 return err;
1578
1579 if (rme9652->hw_rev >= 15)
1580 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_adat1_input, rme9652))) < 0)
1581 return err;
1582
1583 return 0;
1584 }
1585
1586 /*------------------------------------------------------------
1587 /proc interface
1588 ------------------------------------------------------------*/
1589
1590 static void
1591 snd_rme9652_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
1592 {
1593 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data;
1594 u32 thru_bits = rme9652->thru_bits;
1595 int show_auto_sync_source = 0;
1596 int i;
1597 unsigned int status;
1598 int x;
1599
1600 status = rme9652_read(rme9652, RME9652_status_register);
1601
1602 snd_iprintf(buffer, "%s (Card #%d)\n", rme9652->card_name, rme9652->card->number + 1);
1603 snd_iprintf(buffer, "Buffers: capture %p playback %p\n",
1604 rme9652->capture_buffer, rme9652->playback_buffer);
1605 snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
1606 rme9652->irq, rme9652->port, (unsigned long)rme9652->iobase);
1607 snd_iprintf(buffer, "Control register: %x\n", rme9652->control_register);
1608
1609 snd_iprintf(buffer, "\n");
1610
1611 x = 1 << (6 + rme9652_decode_latency(rme9652->control_register &
1612 RME9652_latency));
1613
1614 snd_iprintf(buffer, "Latency: %d samples (2 periods of %lu bytes)\n",
1615 x, (unsigned long) rme9652->period_bytes);
1616 snd_iprintf(buffer, "Hardware pointer (frames): %ld\n",
1617 rme9652_hw_pointer(rme9652));
1618 snd_iprintf(buffer, "Passthru: %s\n",
1619 rme9652->passthru ? "yes" : "no");
1620
1621 if ((rme9652->control_register & (RME9652_Master | RME9652_wsel)) == 0) {
1622 snd_iprintf(buffer, "Clock mode: autosync\n");
1623 show_auto_sync_source = 1;
1624 } else if (rme9652->control_register & RME9652_wsel) {
1625 if (status & RME9652_wsel_rd) {
1626 snd_iprintf(buffer, "Clock mode: word clock\n");
1627 } else {
1628 snd_iprintf(buffer, "Clock mode: word clock (no signal)\n");
1629 }
1630 } else {
1631 snd_iprintf(buffer, "Clock mode: master\n");
1632 }
1633
1634 if (show_auto_sync_source) {
1635 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1636 case RME9652_SyncPref_ADAT1:
1637 snd_iprintf(buffer, "Pref. sync source: ADAT1\n");
1638 break;
1639 case RME9652_SyncPref_ADAT2:
1640 snd_iprintf(buffer, "Pref. sync source: ADAT2\n");
1641 break;
1642 case RME9652_SyncPref_ADAT3:
1643 snd_iprintf(buffer, "Pref. sync source: ADAT3\n");
1644 break;
1645 case RME9652_SyncPref_SPDIF:
1646 snd_iprintf(buffer, "Pref. sync source: IEC958\n");
1647 break;
1648 default:
1649 snd_iprintf(buffer, "Pref. sync source: ???\n");
1650 }
1651 }
1652
1653 if (rme9652->hw_rev >= 15)
1654 snd_iprintf(buffer, "\nADAT1 Input source: %s\n",
1655 (rme9652->control_register & RME9652_ADAT1_INTERNAL) ?
1656 "Internal" : "ADAT1 optical");
1657
1658 snd_iprintf(buffer, "\n");
1659
1660 switch (rme9652_decode_spdif_in(rme9652->control_register &
1661 RME9652_inp)) {
1662 case RME9652_SPDIFIN_OPTICAL:
1663 snd_iprintf(buffer, "IEC958 input: ADAT1\n");
1664 break;
1665 case RME9652_SPDIFIN_COAXIAL:
1666 snd_iprintf(buffer, "IEC958 input: Coaxial\n");
1667 break;
1668 case RME9652_SPDIFIN_INTERN:
1669 snd_iprintf(buffer, "IEC958 input: Internal\n");
1670 break;
1671 default:
1672 snd_iprintf(buffer, "IEC958 input: ???\n");
1673 break;
1674 }
1675
1676 if (rme9652->control_register & RME9652_opt_out) {
1677 snd_iprintf(buffer, "IEC958 output: Coaxial & ADAT1\n");
1678 } else {
1679 snd_iprintf(buffer, "IEC958 output: Coaxial only\n");
1680 }
1681
1682 if (rme9652->control_register & RME9652_PRO) {
1683 snd_iprintf(buffer, "IEC958 quality: Professional\n");
1684 } else {
1685 snd_iprintf(buffer, "IEC958 quality: Consumer\n");
1686 }
1687
1688 if (rme9652->control_register & RME9652_EMP) {
1689 snd_iprintf(buffer, "IEC958 emphasis: on\n");
1690 } else {
1691 snd_iprintf(buffer, "IEC958 emphasis: off\n");
1692 }
1693
1694 if (rme9652->control_register & RME9652_Dolby) {
1695 snd_iprintf(buffer, "IEC958 Dolby: on\n");
1696 } else {
1697 snd_iprintf(buffer, "IEC958 Dolby: off\n");
1698 }
1699
1700 i = rme9652_spdif_sample_rate(rme9652);
1701
1702 if (i < 0) {
1703 snd_iprintf(buffer,
1704 "IEC958 sample rate: error flag set\n");
1705 } else if (i == 0) {
1706 snd_iprintf(buffer, "IEC958 sample rate: undetermined\n");
1707 } else {
1708 snd_iprintf(buffer, "IEC958 sample rate: %d\n", i);
1709 }
1710
1711 snd_iprintf(buffer, "\n");
1712
1713 snd_iprintf(buffer, "ADAT Sample rate: %dHz\n",
1714 rme9652_adat_sample_rate(rme9652));
1715
1716 /* Sync Check */
1717
1718 x = status & RME9652_sync_0;
1719 if (status & RME9652_lock_0) {
1720 snd_iprintf(buffer, "ADAT1: %s\n", x ? "Sync" : "Lock");
1721 } else {
1722 snd_iprintf(buffer, "ADAT1: No Lock\n");
1723 }
1724
1725 x = status & RME9652_sync_1;
1726 if (status & RME9652_lock_1) {
1727 snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
1728 } else {
1729 snd_iprintf(buffer, "ADAT2: No Lock\n");
1730 }
1731
1732 x = status & RME9652_sync_2;
1733 if (status & RME9652_lock_2) {
1734 snd_iprintf(buffer, "ADAT3: %s\n", x ? "Sync" : "Lock");
1735 } else {
1736 snd_iprintf(buffer, "ADAT3: No Lock\n");
1737 }
1738
1739 snd_iprintf(buffer, "\n");
1740
1741 snd_iprintf(buffer, "Timecode signal: %s\n",
1742 (status & RME9652_tc_valid) ? "yes" : "no");
1743
1744 /* thru modes */
1745
1746 snd_iprintf(buffer, "Punch Status:\n\n");
1747
1748 for (i = 0; i < rme9652->ss_channels; i++) {
1749 if (thru_bits & (1 << i)) {
1750 snd_iprintf(buffer, "%2d: on ", i + 1);
1751 } else {
1752 snd_iprintf(buffer, "%2d: off ", i + 1);
1753 }
1754
1755 if (((i + 1) % 8) == 0) {
1756 snd_iprintf(buffer, "\n");
1757 }
1758 }
1759
1760 snd_iprintf(buffer, "\n");
1761 }
1762
1763 static void __devinit snd_rme9652_proc_init(struct snd_rme9652 *rme9652)
1764 {
1765 struct snd_info_entry *entry;
1766
1767 if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
1768 snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
1769 }
1770
1771 static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652)
1772 {
1773 snd_hammerfall_free_buffer(&rme9652->capture_dma_buf, rme9652->pci);
1774 snd_hammerfall_free_buffer(&rme9652->playback_dma_buf, rme9652->pci);
1775 }
1776
1777 static int snd_rme9652_free(struct snd_rme9652 *rme9652)
1778 {
1779 if (rme9652->irq >= 0)
1780 rme9652_stop(rme9652);
1781 snd_rme9652_free_buffers(rme9652);
1782
1783 if (rme9652->irq >= 0)
1784 free_irq(rme9652->irq, (void *)rme9652);
1785 if (rme9652->iobase)
1786 iounmap(rme9652->iobase);
1787 if (rme9652->port)
1788 pci_release_regions(rme9652->pci);
1789
1790 pci_disable_device(rme9652->pci);
1791 return 0;
1792 }
1793
1794 static int __devinit snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)
1795 {
1796 unsigned long pb_bus, cb_bus;
1797
1798 if (snd_hammerfall_get_buffer(rme9652->pci, &rme9652->capture_dma_buf, RME9652_DMA_AREA_BYTES) < 0 ||
1799 snd_hammerfall_get_buffer(rme9652->pci, &rme9652->playback_dma_buf, RME9652_DMA_AREA_BYTES) < 0) {
1800 if (rme9652->capture_dma_buf.area)
1801 snd_dma_free_pages(&rme9652->capture_dma_buf);
1802 printk(KERN_ERR "%s: no buffers available\n", rme9652->card_name);
1803 return -ENOMEM;
1804 }
1805
1806 /* Align to bus-space 64K boundary */
1807
1808 cb_bus = ALIGN(rme9652->capture_dma_buf.addr, 0x10000ul);
1809 pb_bus = ALIGN(rme9652->playback_dma_buf.addr, 0x10000ul);
1810
1811 /* Tell the card where it is */
1812
1813 rme9652_write(rme9652, RME9652_rec_buffer, cb_bus);
1814 rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
1815
1816 rme9652->capture_buffer = rme9652->capture_dma_buf.area + (cb_bus - rme9652->capture_dma_buf.addr);
1817 rme9652->playback_buffer = rme9652->playback_dma_buf.area + (pb_bus - rme9652->playback_dma_buf.addr);
1818
1819 return 0;
1820 }
1821
1822 static void snd_rme9652_set_defaults(struct snd_rme9652 *rme9652)
1823 {
1824 unsigned int k;
1825
1826 /* ASSUMPTION: rme9652->lock is either held, or
1827 there is no need to hold it (e.g. during module
1828 initialization).
1829 */
1830
1831 /* set defaults:
1832
1833 SPDIF Input via Coax
1834 autosync clock mode
1835 maximum latency (7 = 8192 samples, 64Kbyte buffer,
1836 which implies 2 4096 sample, 32Kbyte periods).
1837
1838 if rev 1.5, initialize the S/PDIF receiver.
1839
1840 */
1841
1842 rme9652->control_register =
1843 RME9652_inp_0 | rme9652_encode_latency(7);
1844
1845 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1846
1847 rme9652_reset_hw_pointer(rme9652);
1848 rme9652_compute_period_size(rme9652);
1849
1850 /* default: thru off for all channels */
1851
1852 for (k = 0; k < RME9652_NCHANNELS; ++k)
1853 rme9652_write(rme9652, RME9652_thru_base + k * 4, 0);
1854
1855 rme9652->thru_bits = 0;
1856 rme9652->passthru = 0;
1857
1858 /* set a default rate so that the channel map is set up */
1859
1860 rme9652_set_rate(rme9652, 48000);
1861 }
1862
1863 static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id)
1864 {
1865 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) dev_id;
1866
1867 if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) {
1868 return IRQ_NONE;
1869 }
1870
1871 rme9652_write(rme9652, RME9652_irq_clear, 0);
1872
1873 if (rme9652->capture_substream) {
1874 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
1875 }
1876
1877 if (rme9652->playback_substream) {
1878 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
1879 }
1880 return IRQ_HANDLED;
1881 }
1882
1883 static snd_pcm_uframes_t snd_rme9652_hw_pointer(struct snd_pcm_substream *substream)
1884 {
1885 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1886 return rme9652_hw_pointer(rme9652);
1887 }
1888
1889 static char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652,
1890 int stream,
1891 int channel)
1892
1893 {
1894 int mapped_channel;
1895
1896 snd_assert(channel >= 0 || channel < RME9652_NCHANNELS, return NULL);
1897
1898 if ((mapped_channel = rme9652->channel_map[channel]) < 0) {
1899 return NULL;
1900 }
1901
1902 if (stream == SNDRV_PCM_STREAM_CAPTURE) {
1903 return rme9652->capture_buffer +
1904 (mapped_channel * RME9652_CHANNEL_BUFFER_BYTES);
1905 } else {
1906 return rme9652->playback_buffer +
1907 (mapped_channel * RME9652_CHANNEL_BUFFER_BYTES);
1908 }
1909 }
1910
1911 static int snd_rme9652_playback_copy(struct snd_pcm_substream *substream, int channel,
1912 snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count)
1913 {
1914 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1915 char *channel_buf;
1916
1917 snd_assert(pos + count <= RME9652_CHANNEL_BUFFER_BYTES / 4, return -EINVAL);
1918
1919 channel_buf = rme9652_channel_buffer_location (rme9652,
1920 substream->pstr->stream,
1921 channel);
1922 snd_assert(channel_buf != NULL, return -EIO);
1923 if (copy_from_user(channel_buf + pos * 4, src, count * 4))
1924 return -EFAULT;
1925 return count;
1926 }
1927
1928 static int snd_rme9652_capture_copy(struct snd_pcm_substream *substream, int channel,
1929 snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count)
1930 {
1931 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1932 char *channel_buf;
1933
1934 snd_assert(pos + count <= RME9652_CHANNEL_BUFFER_BYTES / 4, return -EINVAL);
1935
1936 channel_buf = rme9652_channel_buffer_location (rme9652,
1937 substream->pstr->stream,
1938 channel);
1939 snd_assert(channel_buf != NULL, return -EIO);
1940 if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
1941 return -EFAULT;
1942 return count;
1943 }
1944
1945 static int snd_rme9652_hw_silence(struct snd_pcm_substream *substream, int channel,
1946 snd_pcm_uframes_t pos, snd_pcm_uframes_t count)
1947 {
1948 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1949 char *channel_buf;
1950
1951 channel_buf = rme9652_channel_buffer_location (rme9652,
1952 substream->pstr->stream,
1953 channel);
1954 snd_assert(channel_buf != NULL, return -EIO);
1955 memset(channel_buf + pos * 4, 0, count * 4);
1956 return count;
1957 }
1958
1959 static int snd_rme9652_reset(struct snd_pcm_substream *substream)
1960 {
1961 struct snd_pcm_runtime *runtime = substream->runtime;
1962 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1963 struct snd_pcm_substream *other;
1964 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1965 other = rme9652->capture_substream;
1966 else
1967 other = rme9652->playback_substream;
1968 if (rme9652->running)
1969 runtime->status->hw_ptr = rme9652_hw_pointer(rme9652);
1970 else
1971 runtime->status->hw_ptr = 0;
1972 if (other) {
1973 struct snd_pcm_substream *s;
1974 struct snd_pcm_runtime *oruntime = other->runtime;
1975 snd_pcm_group_for_each_entry(s, substream) {
1976 if (s == other) {
1977 oruntime->status->hw_ptr = runtime->status->hw_ptr;
1978 break;
1979 }
1980 }
1981 }
1982 return 0;
1983 }
1984
1985 static int snd_rme9652_hw_params(struct snd_pcm_substream *substream,
1986 struct snd_pcm_hw_params *params)
1987 {
1988 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1989 int err;
1990 pid_t this_pid;
1991 pid_t other_pid;
1992
1993 spin_lock_irq(&rme9652->lock);
1994
1995 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1996 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
1997 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= rme9652->creg_spdif_stream);
1998 this_pid = rme9652->playback_pid;
1999 other_pid = rme9652->capture_pid;
2000 } else {
2001 this_pid = rme9652->capture_pid;
2002 other_pid = rme9652->playback_pid;
2003 }
2004
2005 if ((other_pid > 0) && (this_pid != other_pid)) {
2006
2007 /* The other stream is open, and not by the same
2008 task as this one. Make sure that the parameters
2009 that matter are the same.
2010 */
2011
2012 if ((int)params_rate(params) !=
2013 rme9652_adat_sample_rate(rme9652)) {
2014 spin_unlock_irq(&rme9652->lock);
2015 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
2016 return -EBUSY;
2017 }
2018
2019 if (params_period_size(params) != rme9652->period_bytes / 4) {
2020 spin_unlock_irq(&rme9652->lock);
2021 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2022 return -EBUSY;
2023 }
2024
2025 /* We're fine. */
2026
2027 spin_unlock_irq(&rme9652->lock);
2028 return 0;
2029
2030 } else {
2031 spin_unlock_irq(&rme9652->lock);
2032 }
2033
2034 /* how to make sure that the rate matches an externally-set one ?
2035 */
2036
2037 if ((err = rme9652_set_rate(rme9652, params_rate(params))) < 0) {
2038 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
2039 return err;
2040 }
2041
2042 if ((err = rme9652_set_interrupt_interval(rme9652, params_period_size(params))) < 0) {
2043 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2044 return err;
2045 }
2046
2047 return 0;
2048 }
2049
2050 static int snd_rme9652_channel_info(struct snd_pcm_substream *substream,
2051 struct snd_pcm_channel_info *info)
2052 {
2053 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2054 int chn;
2055
2056 snd_assert(info->channel < RME9652_NCHANNELS, return -EINVAL);
2057
2058 if ((chn = rme9652->channel_map[info->channel]) < 0) {
2059 return -EINVAL;
2060 }
2061
2062 info->offset = chn * RME9652_CHANNEL_BUFFER_BYTES;
2063 info->first = 0;
2064 info->step = 32;
2065 return 0;
2066 }
2067
2068 static int snd_rme9652_ioctl(struct snd_pcm_substream *substream,
2069 unsigned int cmd, void *arg)
2070 {
2071 switch (cmd) {
2072 case SNDRV_PCM_IOCTL1_RESET:
2073 {
2074 return snd_rme9652_reset(substream);
2075 }
2076 case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
2077 {
2078 struct snd_pcm_channel_info *info = arg;
2079 return snd_rme9652_channel_info(substream, info);
2080 }
2081 default:
2082 break;
2083 }
2084
2085 return snd_pcm_lib_ioctl(substream, cmd, arg);
2086 }
2087
2088 static void rme9652_silence_playback(struct snd_rme9652 *rme9652)
2089 {
2090 memset(rme9652->playback_buffer, 0, RME9652_DMA_AREA_BYTES);
2091 }
2092
2093 static int snd_rme9652_trigger(struct snd_pcm_substream *substream,
2094 int cmd)
2095 {
2096 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2097 struct snd_pcm_substream *other;
2098 int running;
2099 spin_lock(&rme9652->lock);
2100 running = rme9652->running;
2101 switch (cmd) {
2102 case SNDRV_PCM_TRIGGER_START:
2103 running |= 1 << substream->stream;
2104 break;
2105 case SNDRV_PCM_TRIGGER_STOP:
2106 running &= ~(1 << substream->stream);
2107 break;
2108 default:
2109 snd_BUG();
2110 spin_unlock(&rme9652->lock);
2111 return -EINVAL;
2112 }
2113 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2114 other = rme9652->capture_substream;
2115 else
2116 other = rme9652->playback_substream;
2117
2118 if (other) {
2119 struct snd_pcm_substream *s;
2120 snd_pcm_group_for_each_entry(s, substream) {
2121 if (s == other) {
2122 snd_pcm_trigger_done(s, substream);
2123 if (cmd == SNDRV_PCM_TRIGGER_START)
2124 running |= 1 << s->stream;
2125 else
2126 running &= ~(1 << s->stream);
2127 goto _ok;
2128 }
2129 }
2130 if (cmd == SNDRV_PCM_TRIGGER_START) {
2131 if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
2132 substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2133 rme9652_silence_playback(rme9652);
2134 } else {
2135 if (running &&
2136 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2137 rme9652_silence_playback(rme9652);
2138 }
2139 } else {
2140 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2141 rme9652_silence_playback(rme9652);
2142 }
2143 _ok:
2144 snd_pcm_trigger_done(substream, substream);
2145 if (!rme9652->running && running)
2146 rme9652_start(rme9652);
2147 else if (rme9652->running && !running)
2148 rme9652_stop(rme9652);
2149 rme9652->running = running;
2150 spin_unlock(&rme9652->lock);
2151
2152 return 0;
2153 }
2154
2155 static int snd_rme9652_prepare(struct snd_pcm_substream *substream)
2156 {
2157 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2158 unsigned long flags;
2159 int result = 0;
2160
2161 spin_lock_irqsave(&rme9652->lock, flags);
2162 if (!rme9652->running)
2163 rme9652_reset_hw_pointer(rme9652);
2164 spin_unlock_irqrestore(&rme9652->lock, flags);
2165 return result;
2166 }
2167
2168 static struct snd_pcm_hardware snd_rme9652_playback_subinfo =
2169 {
2170 .info = (SNDRV_PCM_INFO_MMAP |
2171 SNDRV_PCM_INFO_MMAP_VALID |
2172 SNDRV_PCM_INFO_NONINTERLEAVED |
2173 SNDRV_PCM_INFO_SYNC_START |
2174 SNDRV_PCM_INFO_DOUBLE),
2175 .formats = SNDRV_PCM_FMTBIT_S32_LE,
2176 .rates = (SNDRV_PCM_RATE_44100 |
2177 SNDRV_PCM_RATE_48000 |
2178 SNDRV_PCM_RATE_88200 |
2179 SNDRV_PCM_RATE_96000),
2180 .rate_min = 44100,
2181 .rate_max = 96000,
2182 .channels_min = 10,
2183 .channels_max = 26,
2184 .buffer_bytes_max = RME9652_CHANNEL_BUFFER_BYTES * 26,
2185 .period_bytes_min = (64 * 4) * 10,
2186 .period_bytes_max = (8192 * 4) * 26,
2187 .periods_min = 2,
2188 .periods_max = 2,
2189 .fifo_size = 0,
2190 };
2191
2192 static struct snd_pcm_hardware snd_rme9652_capture_subinfo =
2193 {
2194 .info = (SNDRV_PCM_INFO_MMAP |
2195 SNDRV_PCM_INFO_MMAP_VALID |
2196 SNDRV_PCM_INFO_NONINTERLEAVED |
2197 SNDRV_PCM_INFO_SYNC_START),
2198 .formats = SNDRV_PCM_FMTBIT_S32_LE,
2199 .rates = (SNDRV_PCM_RATE_44100 |
2200 SNDRV_PCM_RATE_48000 |
2201 SNDRV_PCM_RATE_88200 |
2202 SNDRV_PCM_RATE_96000),
2203 .rate_min = 44100,
2204 .rate_max = 96000,
2205 .channels_min = 10,
2206 .channels_max = 26,
2207 .buffer_bytes_max = RME9652_CHANNEL_BUFFER_BYTES *26,
2208 .period_bytes_min = (64 * 4) * 10,
2209 .period_bytes_max = (8192 * 4) * 26,
2210 .periods_min = 2,
2211 .periods_max = 2,
2212 .fifo_size = 0,
2213 };
2214
2215 static unsigned int period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 };
2216
2217 static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = {
2218 .count = ARRAY_SIZE(period_sizes),
2219 .list = period_sizes,
2220 .mask = 0
2221 };
2222
2223 static int snd_rme9652_hw_rule_channels(struct snd_pcm_hw_params *params,
2224 struct snd_pcm_hw_rule *rule)
2225 {
2226 struct snd_rme9652 *rme9652 = rule->private;
2227 struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
2228 unsigned int list[2] = { rme9652->ds_channels, rme9652->ss_channels };
2229 return snd_interval_list(c, 2, list, 0);
2230 }
2231
2232 static int snd_rme9652_hw_rule_channels_rate(struct snd_pcm_hw_params *params,
2233 struct snd_pcm_hw_rule *rule)
2234 {
2235 struct snd_rme9652 *rme9652 = rule->private;
2236 struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
2237 struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
2238 if (r->min > 48000) {
2239 struct snd_interval t = {
2240 .min = rme9652->ds_channels,
2241 .max = rme9652->ds_channels,
2242 .integer = 1,
2243 };
2244 return snd_interval_refine(c, &t);
2245 } else if (r->max < 88200) {
2246 struct snd_interval t = {
2247 .min = rme9652->ss_channels,
2248 .max = rme9652->ss_channels,
2249 .integer = 1,
2250 };
2251 return snd_interval_refine(c, &t);
2252 }
2253 return 0;
2254 }
2255
2256 static int snd_rme9652_hw_rule_rate_channels(struct snd_pcm_hw_params *params,
2257 struct snd_pcm_hw_rule *rule)
2258 {
2259 struct snd_rme9652 *rme9652 = rule->private;
2260 struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
2261 struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
2262 if (c->min >= rme9652->ss_channels) {
2263 struct snd_interval t = {
2264 .min = 44100,
2265 .max = 48000,
2266 .integer = 1,
2267 };
2268 return snd_interval_refine(r, &t);
2269 } else if (c->max <= rme9652->ds_channels) {
2270 struct snd_interval t = {
2271 .min = 88200,
2272 .max = 96000,
2273 .integer = 1,
2274 };
2275 return snd_interval_refine(r, &t);
2276 }
2277 return 0;
2278 }
2279
2280 static int snd_rme9652_playback_open(struct snd_pcm_substream *substream)
2281 {
2282 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2283 struct snd_pcm_runtime *runtime = substream->runtime;
2284
2285 spin_lock_irq(&rme9652->lock);
2286
2287 snd_pcm_set_sync(substream);
2288
2289 runtime->hw = snd_rme9652_playback_subinfo;
2290 runtime->dma_area = rme9652->playback_buffer;
2291 runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
2292
2293 if (rme9652->capture_substream == NULL) {
2294 rme9652_stop(rme9652);
2295 rme9652_set_thru(rme9652, -1, 0);
2296 }
2297
2298 rme9652->playback_pid = current->pid;
2299 rme9652->playback_substream = substream;
2300
2301 spin_unlock_irq(&rme9652->lock);
2302
2303 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
2304 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_period_sizes);
2305 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
2306 snd_rme9652_hw_rule_channels, rme9652,
2307 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2308 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
2309 snd_rme9652_hw_rule_channels_rate, rme9652,
2310 SNDRV_PCM_HW_PARAM_RATE, -1);
2311 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2312 snd_rme9652_hw_rule_rate_channels, rme9652,
2313 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2314
2315 rme9652->creg_spdif_stream = rme9652->creg_spdif;
2316 rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2317 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2318 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2319 return 0;
2320 }
2321
2322 static int snd_rme9652_playback_release(struct snd_pcm_substream *substream)
2323 {
2324 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2325
2326 spin_lock_irq(&rme9652->lock);
2327
2328 rme9652->playback_pid = -1;
2329 rme9652->playback_substream = NULL;
2330
2331 spin_unlock_irq(&rme9652->lock);
2332
2333 rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2334 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2335 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2336 return 0;
2337 }
2338
2339
2340 static int snd_rme9652_capture_open(struct snd_pcm_substream *substream)
2341 {
2342 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2343 struct snd_pcm_runtime *runtime = substream->runtime;
2344
2345 spin_lock_irq(&rme9652->lock);
2346
2347 snd_pcm_set_sync(substream);
2348
2349 runtime->hw = snd_rme9652_capture_subinfo;
2350 runtime->dma_area = rme9652->capture_buffer;
2351 runtime->dma_bytes = RME9652_DMA_AREA_BYTES;
2352
2353 if (rme9652->playback_substream == NULL) {
2354 rme9652_stop(rme9652);
2355 rme9652_set_thru(rme9652, -1, 0);
2356 }
2357
2358 rme9652->capture_pid = current->pid;
2359 rme9652->capture_substream = substream;
2360
2361 spin_unlock_irq(&rme9652->lock);
2362
2363 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
2364 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_period_sizes);
2365 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
2366 snd_rme9652_hw_rule_channels, rme9652,
2367 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2368 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
2369 snd_rme9652_hw_rule_channels_rate, rme9652,
2370 SNDRV_PCM_HW_PARAM_RATE, -1);
2371 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2372 snd_rme9652_hw_rule_rate_channels, rme9652,
2373 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2374 return 0;
2375 }
2376
2377 static int snd_rme9652_capture_release(struct snd_pcm_substream *substream)
2378 {
2379 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2380
2381 spin_lock_irq(&rme9652->lock);
2382
2383 rme9652->capture_pid = -1;
2384 rme9652->capture_substream = NULL;
2385
2386 spin_unlock_irq(&rme9652->lock);
2387 return 0;
2388 }
2389
2390 static struct snd_pcm_ops snd_rme9652_playback_ops = {
2391 .open = snd_rme9652_playback_open,
2392 .close = snd_rme9652_playback_release,
2393 .ioctl = snd_rme9652_ioctl,
2394 .hw_params = snd_rme9652_hw_params,
2395 .prepare = snd_rme9652_prepare,
2396 .trigger = snd_rme9652_trigger,
2397 .pointer = snd_rme9652_hw_pointer,
2398 .copy = snd_rme9652_playback_copy,
2399 .silence = snd_rme9652_hw_silence,
2400 };
2401
2402 static struct snd_pcm_ops snd_rme9652_capture_ops = {
2403 .open = snd_rme9652_capture_open,
2404 .close = snd_rme9652_capture_release,
2405 .ioctl = snd_rme9652_ioctl,
2406 .hw_params = snd_rme9652_hw_params,
2407 .prepare = snd_rme9652_prepare,
2408 .trigger = snd_rme9652_trigger,
2409 .pointer = snd_rme9652_hw_pointer,
2410 .copy = snd_rme9652_capture_copy,
2411 };
2412
2413 static int __devinit snd_rme9652_create_pcm(struct snd_card *card,
2414 struct snd_rme9652 *rme9652)
2415 {
2416 struct snd_pcm *pcm;
2417 int err;
2418
2419 if ((err = snd_pcm_new(card,
2420 rme9652->card_name,
2421 0, 1, 1, &pcm)) < 0) {
2422 return err;
2423 }
2424
2425 rme9652->pcm = pcm;
2426 pcm->private_data = rme9652;
2427 strcpy(pcm->name, rme9652->card_name);
2428
2429 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_rme9652_playback_ops);
2430 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_rme9652_capture_ops);
2431
2432 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
2433
2434 return 0;
2435 }
2436
2437 static int __devinit snd_rme9652_create(struct snd_card *card,
2438 struct snd_rme9652 *rme9652,
2439 int precise_ptr)
2440 {
2441 struct pci_dev *pci = rme9652->pci;
2442 int err;
2443 int status;
2444 unsigned short rev;
2445
2446 rme9652->irq = -1;
2447 rme9652->card = card;
2448
2449 pci_read_config_word(rme9652->pci, PCI_CLASS_REVISION, &rev);
2450
2451 switch (rev & 0xff) {
2452 case 3:
2453 case 4:
2454 case 8:
2455 case 9:
2456 break;
2457
2458 default:
2459 /* who knows? */
2460 return -ENODEV;
2461 }
2462
2463 if ((err = pci_enable_device(pci)) < 0)
2464 return err;
2465
2466 spin_lock_init(&rme9652->lock);
2467
2468 if ((err = pci_request_regions(pci, "rme9652")) < 0)
2469 return err;
2470 rme9652->port = pci_resource_start(pci, 0);
2471 rme9652->iobase = ioremap_nocache(rme9652->port, RME9652_IO_EXTENT);
2472 if (rme9652->iobase == NULL) {
2473 snd_printk(KERN_ERR "unable to remap region 0x%lx-0x%lx\n", rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
2474 return -EBUSY;
2475 }
2476
2477 if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED,
2478 "rme9652", rme9652)) {
2479 snd_printk(KERN_ERR "unable to request IRQ %d\n", pci->irq);
2480 return -EBUSY;
2481 }
2482 rme9652->irq = pci->irq;
2483 rme9652->precise_ptr = precise_ptr;
2484
2485 /* Determine the h/w rev level of the card. This seems like
2486 a particularly kludgy way to encode it, but its what RME
2487 chose to do, so we follow them ...
2488 */
2489
2490 status = rme9652_read(rme9652, RME9652_status_register);
2491 if (rme9652_decode_spdif_rate(status&RME9652_F) == 1) {
2492 rme9652->hw_rev = 15;
2493 } else {
2494 rme9652->hw_rev = 11;
2495 }
2496
2497 /* Differentiate between the standard Hammerfall, and the
2498 "Light", which does not have the expansion board. This
2499 method comes from information received from Mathhias
2500 Clausen at RME. Display the EEPROM and h/w revID where
2501 relevant.
2502 */
2503
2504 switch (rev) {
2505 case 8: /* original eprom */
2506 strcpy(card->driver, "RME9636");
2507 if (rme9652->hw_rev == 15) {
2508 rme9652->card_name = "RME Digi9636 (Rev 1.5)";
2509 } else {
2510 rme9652->card_name = "RME Digi9636";
2511 }
2512 rme9652->ss_channels = RME9636_NCHANNELS;
2513 break;
2514 case 9: /* W36_G EPROM */
2515 strcpy(card->driver, "RME9636");
2516 rme9652->card_name = "RME Digi9636 (Rev G)";
2517 rme9652->ss_channels = RME9636_NCHANNELS;
2518 break;
2519 case 4: /* W52_G EPROM */
2520 strcpy(card->driver, "RME9652");
2521 rme9652->card_name = "RME Digi9652 (Rev G)";
2522 rme9652->ss_channels = RME9652_NCHANNELS;
2523 break;
2524 case 3: /* original eprom */
2525 strcpy(card->driver, "RME9652");
2526 if (rme9652->hw_rev == 15) {
2527 rme9652->card_name = "RME Digi9652 (Rev 1.5)";
2528 } else {
2529 rme9652->card_name = "RME Digi9652";
2530 }
2531 rme9652->ss_channels = RME9652_NCHANNELS;
2532 break;
2533 }
2534
2535 rme9652->ds_channels = (rme9652->ss_channels - 2) / 2 + 2;
2536
2537 pci_set_master(rme9652->pci);
2538
2539 if ((err = snd_rme9652_initialize_memory(rme9652)) < 0) {
2540 return err;
2541 }
2542
2543 if ((err = snd_rme9652_create_pcm(card, rme9652)) < 0) {
2544 return err;
2545 }
2546
2547 if ((err = snd_rme9652_create_controls(card, rme9652)) < 0) {
2548 return err;
2549 }
2550
2551 snd_rme9652_proc_init(rme9652);
2552
2553 rme9652->last_spdif_sample_rate = -1;
2554 rme9652->last_adat_sample_rate = -1;
2555 rme9652->playback_pid = -1;
2556 rme9652->capture_pid = -1;
2557 rme9652->capture_substream = NULL;
2558 rme9652->playback_substream = NULL;
2559
2560 snd_rme9652_set_defaults(rme9652);
2561
2562 if (rme9652->hw_rev == 15) {
2563 rme9652_initialize_spdif_receiver (rme9652);
2564 }
2565
2566 return 0;
2567 }
2568
2569 static void snd_rme9652_card_free(struct snd_card *card)
2570 {
2571 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
2572
2573 if (rme9652)
2574 snd_rme9652_free(rme9652);
2575 }
2576
2577 static int __devinit snd_rme9652_probe(struct pci_dev *pci,
2578 const struct pci_device_id *pci_id)
2579 {
2580 static int dev;
2581 struct snd_rme9652 *rme9652;
2582 struct snd_card *card;
2583 int err;
2584
2585 if (dev >= SNDRV_CARDS)
2586 return -ENODEV;
2587 if (!enable[dev]) {
2588 dev++;
2589 return -ENOENT;
2590 }
2591
2592 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
2593 sizeof(struct snd_rme9652));
2594
2595 if (!card)
2596 return -ENOMEM;
2597
2598 rme9652 = (struct snd_rme9652 *) card->private_data;
2599 card->private_free = snd_rme9652_card_free;
2600 rme9652->dev = dev;
2601 rme9652->pci = pci;
2602 snd_card_set_dev(card, &pci->dev);
2603
2604 if ((err = snd_rme9652_create(card, rme9652, precise_ptr[dev])) < 0) {
2605 snd_card_free(card);
2606 return err;
2607 }
2608
2609 strcpy(card->shortname, rme9652->card_name);
2610
2611 sprintf(card->longname, "%s at 0x%lx, irq %d",
2612 card->shortname, rme9652->port, rme9652->irq);
2613
2614
2615 if ((err = snd_card_register(card)) < 0) {
2616 snd_card_free(card);
2617 return err;
2618 }
2619 pci_set_drvdata(pci, card);
2620 dev++;
2621 return 0;
2622 }
2623
2624 static void __devexit snd_rme9652_remove(struct pci_dev *pci)
2625 {
2626 snd_card_free(pci_get_drvdata(pci));
2627 pci_set_drvdata(pci, NULL);
2628 }
2629
2630 static struct pci_driver driver = {
2631 .name = "RME Digi9652 (Hammerfall)",
2632 .id_table = snd_rme9652_ids,
2633 .probe = snd_rme9652_probe,
2634 .remove = __devexit_p(snd_rme9652_remove),
2635 };
2636
2637 static int __init alsa_card_hammerfall_init(void)
2638 {
2639 return pci_register_driver(&driver);
2640 }
2641
2642 static void __exit alsa_card_hammerfall_exit(void)
2643 {
2644 pci_unregister_driver(&driver);
2645 }
2646
2647 module_init(alsa_card_hammerfall_init)
2648 module_exit(alsa_card_hammerfall_exit)
mah project overlay