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