Merge with rsync://rsync.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6.git
[linux-2.6] / sound / pci / rme32.c
1 /*
2  *   ALSA driver for RME Digi32, Digi32/8 and Digi32 PRO audio interfaces
3  *
4  *      Copyright (c) 2002-2004 Martin Langer <martin-langer@gmx.de>,
5  *                              Pilo Chambert <pilo.c@wanadoo.fr>
6  *
7  *      Thanks to :        Anders Torger <torger@ludd.luth.se>,
8  *                         Henk Hesselink <henk@anda.nl>
9  *                         for writing the digi96-driver 
10  *                         and RME for all informations.
11  *
12  *   This program is free software; you can redistribute it and/or modify
13  *   it under the terms of the GNU General Public License as published by
14  *   the Free Software Foundation; either version 2 of the License, or
15  *   (at your option) any later version.
16  *
17  *   This program is distributed in the hope that it will be useful,
18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *   GNU General Public License for more details.
21  *
22  *   You should have received a copy of the GNU General Public License
23  *   along with this program; if not, write to the Free Software
24  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  * 
26  * 
27  * ****************************************************************************
28  * 
29  * Note #1 "Sek'd models" ................................... martin 2002-12-07
30  * 
31  * Identical soundcards by Sek'd were labeled:
32  * RME Digi 32     = Sek'd Prodif 32
33  * RME Digi 32 Pro = Sek'd Prodif 96
34  * RME Digi 32/8   = Sek'd Prodif Gold
35  * 
36  * ****************************************************************************
37  * 
38  * Note #2 "full duplex mode" ............................... martin 2002-12-07
39  * 
40  * Full duplex doesn't work. All cards (32, 32/8, 32Pro) are working identical
41  * in this mode. Rec data and play data are using the same buffer therefore. At
42  * first you have got the playing bits in the buffer and then (after playing
43  * them) they were overwitten by the captured sound of the CS8412/14. Both 
44  * modes (play/record) are running harmonically hand in hand in the same buffer
45  * and you have only one start bit plus one interrupt bit to control this 
46  * paired action.
47  * This is opposite to the latter rme96 where playing and capturing is totally
48  * separated and so their full duplex mode is supported by alsa (using two 
49  * start bits and two interrupts for two different buffers). 
50  * But due to the wrong sequence of playing and capturing ALSA shows no solved
51  * full duplex support for the rme32 at the moment. That's bad, but I'm not
52  * able to solve it. Are you motivated enough to solve this problem now? Your
53  * patch would be welcome!
54  * 
55  * ****************************************************************************
56  *
57  * "The story after the long seeking" -- tiwai
58  *
59  * Ok, the situation regarding the full duplex is now improved a bit.
60  * In the fullduplex mode (given by the module parameter), the hardware buffer
61  * is split to halves for read and write directions at the DMA pointer.
62  * That is, the half above the current DMA pointer is used for write, and
63  * the half below is used for read.  To mangle this strange behavior, an
64  * software intermediate buffer is introduced.  This is, of course, not good
65  * from the viewpoint of the data transfer efficiency.  However, this allows
66  * you to use arbitrary buffer sizes, instead of the fixed I/O buffer size.
67  *
68  * ****************************************************************************
69  */
70
71
72 #include <sound/driver.h>
73 #include <linux/delay.h>
74 #include <linux/init.h>
75 #include <linux/interrupt.h>
76 #include <linux/pci.h>
77 #include <linux/slab.h>
78 #include <linux/moduleparam.h>
79
80 #include <sound/core.h>
81 #include <sound/info.h>
82 #include <sound/control.h>
83 #include <sound/pcm.h>
84 #include <sound/pcm_params.h>
85 #include <sound/pcm-indirect.h>
86 #include <sound/asoundef.h>
87 #include <sound/initval.h>
88
89 #include <asm/io.h>
90
91 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
92 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
93 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
94 static int fullduplex[SNDRV_CARDS]; // = {[0 ... (SNDRV_CARDS - 1)] = 1};
95
96 module_param_array(index, int, NULL, 0444);
97 MODULE_PARM_DESC(index, "Index value for RME Digi32 soundcard.");
98 module_param_array(id, charp, NULL, 0444);
99 MODULE_PARM_DESC(id, "ID string for RME Digi32 soundcard.");
100 module_param_array(enable, bool, NULL, 0444);
101 MODULE_PARM_DESC(enable, "Enable RME Digi32 soundcard.");
102 module_param_array(fullduplex, bool, NULL, 0444);
103 MODULE_PARM_DESC(fullduplex, "Support full-duplex mode.");
104 MODULE_AUTHOR("Martin Langer <martin-langer@gmx.de>, Pilo Chambert <pilo.c@wanadoo.fr>");
105 MODULE_DESCRIPTION("RME Digi32, Digi32/8, Digi32 PRO");
106 MODULE_LICENSE("GPL");
107 MODULE_SUPPORTED_DEVICE("{{RME,Digi32}," "{RME,Digi32/8}," "{RME,Digi32 PRO}}");
108
109 /* Defines for RME Digi32 series */
110 #define RME32_SPDIF_NCHANNELS 2
111
112 /* Playback and capture buffer size */
113 #define RME32_BUFFER_SIZE 0x20000
114
115 /* IO area size */
116 #define RME32_IO_SIZE 0x30000
117
118 /* IO area offsets */
119 #define RME32_IO_DATA_BUFFER        0x0
120 #define RME32_IO_CONTROL_REGISTER   0x20000
121 #define RME32_IO_GET_POS            0x20000
122 #define RME32_IO_CONFIRM_ACTION_IRQ 0x20004
123 #define RME32_IO_RESET_POS          0x20100
124
125 /* Write control register bits */
126 #define RME32_WCR_START     (1 << 0)    /* startbit */
127 #define RME32_WCR_MONO      (1 << 1)    /* 0=stereo, 1=mono
128                                            Setting the whole card to mono
129                                            doesn't seem to be very useful.
130                                            A software-solution can handle 
131                                            full-duplex with one direction in
132                                            stereo and the other way in mono. 
133                                            So, the hardware should work all 
134                                            the time in stereo! */
135 #define RME32_WCR_MODE24    (1 << 2)    /* 0=16bit, 1=32bit */
136 #define RME32_WCR_SEL       (1 << 3)    /* 0=input on output, 1=normal playback/capture */
137 #define RME32_WCR_FREQ_0    (1 << 4)    /* frequency (play) */
138 #define RME32_WCR_FREQ_1    (1 << 5)
139 #define RME32_WCR_INP_0     (1 << 6)    /* input switch */
140 #define RME32_WCR_INP_1     (1 << 7)
141 #define RME32_WCR_RESET     (1 << 8)    /* Reset address */
142 #define RME32_WCR_MUTE      (1 << 9)    /* digital mute for output */
143 #define RME32_WCR_PRO       (1 << 10)   /* 1=professional, 0=consumer */
144 #define RME32_WCR_DS_BM     (1 << 11)   /* 1=DoubleSpeed (only PRO-Version); 1=BlockMode (only Adat-Version) */
145 #define RME32_WCR_ADAT      (1 << 12)   /* Adat Mode (only Adat-Version) */
146 #define RME32_WCR_AUTOSYNC  (1 << 13)   /* AutoSync */
147 #define RME32_WCR_PD        (1 << 14)   /* DAC Reset (only PRO-Version) */
148 #define RME32_WCR_EMP       (1 << 15)   /* 1=Emphasis on (only PRO-Version) */
149
150 #define RME32_WCR_BITPOS_FREQ_0 4
151 #define RME32_WCR_BITPOS_FREQ_1 5
152 #define RME32_WCR_BITPOS_INP_0 6
153 #define RME32_WCR_BITPOS_INP_1 7
154
155 /* Read control register bits */
156 #define RME32_RCR_AUDIO_ADDR_MASK 0x1ffff
157 #define RME32_RCR_LOCK      (1 << 23)   /* 1=locked, 0=not locked */
158 #define RME32_RCR_ERF       (1 << 26)   /* 1=Error, 0=no Error */
159 #define RME32_RCR_FREQ_0    (1 << 27)   /* CS841x frequency (record) */
160 #define RME32_RCR_FREQ_1    (1 << 28)
161 #define RME32_RCR_FREQ_2    (1 << 29)
162 #define RME32_RCR_KMODE     (1 << 30)   /* card mode: 1=PLL, 0=quartz */
163 #define RME32_RCR_IRQ       (1 << 31)   /* interrupt */
164
165 #define RME32_RCR_BITPOS_F0 27
166 #define RME32_RCR_BITPOS_F1 28
167 #define RME32_RCR_BITPOS_F2 29
168
169 /* Input types */
170 #define RME32_INPUT_OPTICAL 0
171 #define RME32_INPUT_COAXIAL 1
172 #define RME32_INPUT_INTERNAL 2
173 #define RME32_INPUT_XLR 3
174
175 /* Clock modes */
176 #define RME32_CLOCKMODE_SLAVE 0
177 #define RME32_CLOCKMODE_MASTER_32 1
178 #define RME32_CLOCKMODE_MASTER_44 2
179 #define RME32_CLOCKMODE_MASTER_48 3
180
181 /* Block sizes in bytes */
182 #define RME32_BLOCK_SIZE 8192
183
184 /* Software intermediate buffer (max) size */
185 #define RME32_MID_BUFFER_SIZE (1024*1024)
186
187 /* Hardware revisions */
188 #define RME32_32_REVISION 192
189 #define RME32_328_REVISION_OLD 100
190 #define RME32_328_REVISION_NEW 101
191 #define RME32_PRO_REVISION_WITH_8412 192
192 #define RME32_PRO_REVISION_WITH_8414 150
193
194
195 /* PCI vendor/device ID's */
196 #ifndef PCI_VENDOR_ID_XILINX_RME
197 # define PCI_VENDOR_ID_XILINX_RME 0xea60
198 #endif
199 #ifndef PCI_DEVICE_ID_DIGI32
200 # define PCI_DEVICE_ID_DIGI32 0x9896
201 #endif
202 #ifndef PCI_DEVICE_ID_DIGI32_PRO
203 # define PCI_DEVICE_ID_DIGI32_PRO 0x9897
204 #endif
205 #ifndef PCI_DEVICE_ID_DIGI32_8
206 # define PCI_DEVICE_ID_DIGI32_8 0x9898
207 #endif
208
209 typedef struct snd_rme32 {
210         spinlock_t lock;
211         int irq;
212         unsigned long port;
213         void __iomem *iobase;
214
215         u32 wcreg;              /* cached write control register value */
216         u32 wcreg_spdif;        /* S/PDIF setup */
217         u32 wcreg_spdif_stream; /* S/PDIF setup (temporary) */
218         u32 rcreg;              /* cached read control register value */
219
220         u8 rev;                 /* card revision number */
221
222         snd_pcm_substream_t *playback_substream;
223         snd_pcm_substream_t *capture_substream;
224
225         int playback_frlog;     /* log2 of framesize */
226         int capture_frlog;
227
228         size_t playback_periodsize;     /* in bytes, zero if not used */
229         size_t capture_periodsize;      /* in bytes, zero if not used */
230
231         unsigned int fullduplex_mode;
232         int running;
233
234         snd_pcm_indirect_t playback_pcm;
235         snd_pcm_indirect_t capture_pcm;
236
237         snd_card_t *card;
238         snd_pcm_t *spdif_pcm;
239         snd_pcm_t *adat_pcm;
240         struct pci_dev *pci;
241         snd_kcontrol_t *spdif_ctl;
242 } rme32_t;
243
244 static struct pci_device_id snd_rme32_ids[] = {
245         {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_DIGI32,
246          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
247         {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_DIGI32_8,
248          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
249         {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_DIGI32_PRO,
250          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
251         {0,}
252 };
253
254 MODULE_DEVICE_TABLE(pci, snd_rme32_ids);
255
256 #define RME32_ISWORKING(rme32) ((rme32)->wcreg & RME32_WCR_START)
257 #define RME32_PRO_WITH_8414(rme32) ((rme32)->pci->device == PCI_DEVICE_ID_DIGI32_PRO && (rme32)->rev == RME32_PRO_REVISION_WITH_8414)
258
259 static int snd_rme32_playback_prepare(snd_pcm_substream_t * substream);
260
261 static int snd_rme32_capture_prepare(snd_pcm_substream_t * substream);
262
263 static int snd_rme32_pcm_trigger(snd_pcm_substream_t * substream, int cmd);
264
265 static void snd_rme32_proc_init(rme32_t * rme32);
266
267 static int snd_rme32_create_switches(snd_card_t * card, rme32_t * rme32);
268
269 static inline unsigned int snd_rme32_pcm_byteptr(rme32_t * rme32)
270 {
271         return (readl(rme32->iobase + RME32_IO_GET_POS)
272                 & RME32_RCR_AUDIO_ADDR_MASK);
273 }
274
275 static int snd_rme32_ratecode(int rate)
276 {
277         switch (rate) {
278         case 32000: return SNDRV_PCM_RATE_32000;
279         case 44100: return SNDRV_PCM_RATE_44100;
280         case 48000: return SNDRV_PCM_RATE_48000;
281         case 64000: return SNDRV_PCM_RATE_64000;
282         case 88200: return SNDRV_PCM_RATE_88200;
283         case 96000: return SNDRV_PCM_RATE_96000;
284         }
285         return 0;
286 }
287
288 /* silence callback for halfduplex mode */
289 static int snd_rme32_playback_silence(snd_pcm_substream_t * substream, int channel,     /* not used (interleaved data) */
290                                       snd_pcm_uframes_t pos,
291                                       snd_pcm_uframes_t count)
292 {
293         rme32_t *rme32 = snd_pcm_substream_chip(substream);
294         count <<= rme32->playback_frlog;
295         pos <<= rme32->playback_frlog;
296         memset_io(rme32->iobase + RME32_IO_DATA_BUFFER + pos, 0, count);
297         return 0;
298 }
299
300 /* copy callback for halfduplex mode */
301 static int snd_rme32_playback_copy(snd_pcm_substream_t * substream, int channel,        /* not used (interleaved data) */
302                                    snd_pcm_uframes_t pos,
303                                    void __user *src, snd_pcm_uframes_t count)
304 {
305         rme32_t *rme32 = snd_pcm_substream_chip(substream);
306         count <<= rme32->playback_frlog;
307         pos <<= rme32->playback_frlog;
308         if (copy_from_user_toio(rme32->iobase + RME32_IO_DATA_BUFFER + pos,
309                             src, count))
310                 return -EFAULT;
311         return 0;
312 }
313
314 /* copy callback for halfduplex mode */
315 static int snd_rme32_capture_copy(snd_pcm_substream_t * substream, int channel, /* not used (interleaved data) */
316                                   snd_pcm_uframes_t pos,
317                                   void __user *dst, snd_pcm_uframes_t count)
318 {
319         rme32_t *rme32 = snd_pcm_substream_chip(substream);
320         count <<= rme32->capture_frlog;
321         pos <<= rme32->capture_frlog;
322         if (copy_to_user_fromio(dst,
323                             rme32->iobase + RME32_IO_DATA_BUFFER + pos,
324                             count))
325                 return -EFAULT;
326         return 0;
327 }
328
329 /*
330  * SPDIF I/O capabilites (half-duplex mode)
331  */
332 static snd_pcm_hardware_t snd_rme32_spdif_info = {
333         .info =         (SNDRV_PCM_INFO_MMAP_IOMEM |
334                          SNDRV_PCM_INFO_MMAP_VALID |
335                          SNDRV_PCM_INFO_INTERLEAVED | 
336                          SNDRV_PCM_INFO_PAUSE |
337                          SNDRV_PCM_INFO_SYNC_START),
338         .formats =      (SNDRV_PCM_FMTBIT_S16_LE | 
339                          SNDRV_PCM_FMTBIT_S32_LE),
340         .rates =        (SNDRV_PCM_RATE_32000 |
341                          SNDRV_PCM_RATE_44100 | 
342                          SNDRV_PCM_RATE_48000),
343         .rate_min =     32000,
344         .rate_max =     48000,
345         .channels_min = 2,
346         .channels_max = 2,
347         .buffer_bytes_max = RME32_BUFFER_SIZE,
348         .period_bytes_min = RME32_BLOCK_SIZE,
349         .period_bytes_max = RME32_BLOCK_SIZE,
350         .periods_min =  RME32_BUFFER_SIZE / RME32_BLOCK_SIZE,
351         .periods_max =  RME32_BUFFER_SIZE / RME32_BLOCK_SIZE,
352         .fifo_size =    0,
353 };
354
355 /*
356  * ADAT I/O capabilites (half-duplex mode)
357  */
358 static snd_pcm_hardware_t snd_rme32_adat_info =
359 {
360         .info =              (SNDRV_PCM_INFO_MMAP_IOMEM |
361                               SNDRV_PCM_INFO_MMAP_VALID |
362                               SNDRV_PCM_INFO_INTERLEAVED |
363                               SNDRV_PCM_INFO_PAUSE |
364                               SNDRV_PCM_INFO_SYNC_START),
365         .formats=            SNDRV_PCM_FMTBIT_S16_LE,
366         .rates =             (SNDRV_PCM_RATE_44100 | 
367                               SNDRV_PCM_RATE_48000),
368         .rate_min =          44100,
369         .rate_max =          48000,
370         .channels_min =      8,
371         .channels_max =      8,
372         .buffer_bytes_max =  RME32_BUFFER_SIZE,
373         .period_bytes_min =  RME32_BLOCK_SIZE,
374         .period_bytes_max =  RME32_BLOCK_SIZE,
375         .periods_min =      RME32_BUFFER_SIZE / RME32_BLOCK_SIZE,
376         .periods_max =      RME32_BUFFER_SIZE / RME32_BLOCK_SIZE,
377         .fifo_size =        0,
378 };
379
380 /*
381  * SPDIF I/O capabilites (full-duplex mode)
382  */
383 static snd_pcm_hardware_t snd_rme32_spdif_fd_info = {
384         .info =         (SNDRV_PCM_INFO_MMAP |
385                          SNDRV_PCM_INFO_MMAP_VALID |
386                          SNDRV_PCM_INFO_INTERLEAVED | 
387                          SNDRV_PCM_INFO_PAUSE |
388                          SNDRV_PCM_INFO_SYNC_START),
389         .formats =      (SNDRV_PCM_FMTBIT_S16_LE | 
390                          SNDRV_PCM_FMTBIT_S32_LE),
391         .rates =        (SNDRV_PCM_RATE_32000 |
392                          SNDRV_PCM_RATE_44100 | 
393                          SNDRV_PCM_RATE_48000),
394         .rate_min =     32000,
395         .rate_max =     48000,
396         .channels_min = 2,
397         .channels_max = 2,
398         .buffer_bytes_max = RME32_MID_BUFFER_SIZE,
399         .period_bytes_min = RME32_BLOCK_SIZE,
400         .period_bytes_max = RME32_BLOCK_SIZE,
401         .periods_min =  2,
402         .periods_max =  RME32_MID_BUFFER_SIZE / RME32_BLOCK_SIZE,
403         .fifo_size =    0,
404 };
405
406 /*
407  * ADAT I/O capabilites (full-duplex mode)
408  */
409 static snd_pcm_hardware_t snd_rme32_adat_fd_info =
410 {
411         .info =              (SNDRV_PCM_INFO_MMAP |
412                               SNDRV_PCM_INFO_MMAP_VALID |
413                               SNDRV_PCM_INFO_INTERLEAVED |
414                               SNDRV_PCM_INFO_PAUSE |
415                               SNDRV_PCM_INFO_SYNC_START),
416         .formats=            SNDRV_PCM_FMTBIT_S16_LE,
417         .rates =             (SNDRV_PCM_RATE_44100 | 
418                               SNDRV_PCM_RATE_48000),
419         .rate_min =          44100,
420         .rate_max =          48000,
421         .channels_min =      8,
422         .channels_max =      8,
423         .buffer_bytes_max =  RME32_MID_BUFFER_SIZE,
424         .period_bytes_min =  RME32_BLOCK_SIZE,
425         .period_bytes_max =  RME32_BLOCK_SIZE,
426         .periods_min =      2,
427         .periods_max =      RME32_MID_BUFFER_SIZE / RME32_BLOCK_SIZE,
428         .fifo_size =        0,
429 };
430
431 static void snd_rme32_reset_dac(rme32_t *rme32)
432 {
433         writel(rme32->wcreg | RME32_WCR_PD,
434                rme32->iobase + RME32_IO_CONTROL_REGISTER);
435         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
436 }
437
438 static int snd_rme32_playback_getrate(rme32_t * rme32)
439 {
440         int rate;
441
442         rate = ((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_0) & 1) +
443                (((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_1) & 1) << 1);
444         switch (rate) {
445         case 1:
446                 rate = 32000;
447                 break;
448         case 2:
449                 rate = 44100;
450                 break;
451         case 3:
452                 rate = 48000;
453                 break;
454         default:
455                 return -1;
456         }
457         return (rme32->wcreg & RME32_WCR_DS_BM) ? rate << 1 : rate;
458 }
459
460 static int snd_rme32_capture_getrate(rme32_t * rme32, int *is_adat)
461 {
462         int n;
463
464         *is_adat = 0;
465         if (rme32->rcreg & RME32_RCR_LOCK) { 
466                 /* ADAT rate */
467                 *is_adat = 1;
468         }
469         if (rme32->rcreg & RME32_RCR_ERF) {
470                 return -1;
471         }
472
473         /* S/PDIF rate */
474         n = ((rme32->rcreg >> RME32_RCR_BITPOS_F0) & 1) +
475                 (((rme32->rcreg >> RME32_RCR_BITPOS_F1) & 1) << 1) +
476                 (((rme32->rcreg >> RME32_RCR_BITPOS_F2) & 1) << 2);
477
478         if (RME32_PRO_WITH_8414(rme32))
479                 switch (n) {    /* supporting the CS8414 */
480                 case 0:
481                 case 1:
482                 case 2:
483                         return -1;
484                 case 3:
485                         return 96000;
486                 case 4:
487                         return 88200;
488                 case 5:
489                         return 48000;
490                 case 6:
491                         return 44100;
492                 case 7:
493                         return 32000;
494                 default:
495                         return -1;
496                         break;
497                 } 
498         else
499                 switch (n) {    /* supporting the CS8412 */
500                 case 0:
501                         return -1;
502                 case 1:
503                         return 48000;
504                 case 2:
505                         return 44100;
506                 case 3:
507                         return 32000;
508                 case 4:
509                         return 48000;
510                 case 5:
511                         return 44100;
512                 case 6:
513                         return 44056;
514                 case 7:
515                         return 32000;
516                 default:
517                         break;
518                 }
519         return -1;
520 }
521
522 static int snd_rme32_playback_setrate(rme32_t * rme32, int rate)
523 {
524         int ds;
525
526         ds = rme32->wcreg & RME32_WCR_DS_BM;
527         switch (rate) {
528         case 32000:
529                 rme32->wcreg &= ~RME32_WCR_DS_BM;
530                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) & 
531                         ~RME32_WCR_FREQ_1;
532                 break;
533         case 44100:
534                 rme32->wcreg &= ~RME32_WCR_DS_BM;
535                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_1) & 
536                         ~RME32_WCR_FREQ_0;
537                 break;
538         case 48000:
539                 rme32->wcreg &= ~RME32_WCR_DS_BM;
540                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) | 
541                         RME32_WCR_FREQ_1;
542                 break;
543         case 64000:
544                 if (rme32->pci->device != PCI_DEVICE_ID_DIGI32_PRO)
545                         return -EINVAL;
546                 rme32->wcreg |= RME32_WCR_DS_BM;
547                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) & 
548                         ~RME32_WCR_FREQ_1;
549                 break;
550         case 88200:
551                 if (rme32->pci->device != PCI_DEVICE_ID_DIGI32_PRO)
552                         return -EINVAL;
553                 rme32->wcreg |= RME32_WCR_DS_BM;
554                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_1) & 
555                         ~RME32_WCR_FREQ_0;
556                 break;
557         case 96000:
558                 if (rme32->pci->device != PCI_DEVICE_ID_DIGI32_PRO)
559                         return -EINVAL;
560                 rme32->wcreg |= RME32_WCR_DS_BM;
561                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) | 
562                         RME32_WCR_FREQ_1;
563                 break;
564         default:
565                 return -EINVAL;
566         }
567         if ((!ds && rme32->wcreg & RME32_WCR_DS_BM) ||
568             (ds && !(rme32->wcreg & RME32_WCR_DS_BM)))
569         {
570                 /* change to/from double-speed: reset the DAC (if available) */
571                 snd_rme32_reset_dac(rme32);
572         } else {
573                 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
574         }
575         return 0;
576 }
577
578 static int snd_rme32_setclockmode(rme32_t * rme32, int mode)
579 {
580         switch (mode) {
581         case RME32_CLOCKMODE_SLAVE:
582                 /* AutoSync */
583                 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_FREQ_0) & 
584                         ~RME32_WCR_FREQ_1;
585                 break;
586         case RME32_CLOCKMODE_MASTER_32:
587                 /* Internal 32.0kHz */
588                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) & 
589                         ~RME32_WCR_FREQ_1;
590                 break;
591         case RME32_CLOCKMODE_MASTER_44:
592                 /* Internal 44.1kHz */
593                 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_FREQ_0) | 
594                         RME32_WCR_FREQ_1;
595                 break;
596         case RME32_CLOCKMODE_MASTER_48:
597                 /* Internal 48.0kHz */
598                 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) | 
599                         RME32_WCR_FREQ_1;
600                 break;
601         default:
602                 return -EINVAL;
603         }
604         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
605         return 0;
606 }
607
608 static int snd_rme32_getclockmode(rme32_t * rme32)
609 {
610         return ((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_0) & 1) +
611             (((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_1) & 1) << 1);
612 }
613
614 static int snd_rme32_setinputtype(rme32_t * rme32, int type)
615 {
616         switch (type) {
617         case RME32_INPUT_OPTICAL:
618                 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_INP_0) & 
619                         ~RME32_WCR_INP_1;
620                 break;
621         case RME32_INPUT_COAXIAL:
622                 rme32->wcreg = (rme32->wcreg | RME32_WCR_INP_0) & 
623                         ~RME32_WCR_INP_1;
624                 break;
625         case RME32_INPUT_INTERNAL:
626                 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_INP_0) | 
627                         RME32_WCR_INP_1;
628                 break;
629         case RME32_INPUT_XLR:
630                 rme32->wcreg = (rme32->wcreg | RME32_WCR_INP_0) | 
631                         RME32_WCR_INP_1;
632                 break;
633         default:
634                 return -EINVAL;
635         }
636         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
637         return 0;
638 }
639
640 static int snd_rme32_getinputtype(rme32_t * rme32)
641 {
642         return ((rme32->wcreg >> RME32_WCR_BITPOS_INP_0) & 1) +
643             (((rme32->wcreg >> RME32_WCR_BITPOS_INP_1) & 1) << 1);
644 }
645
646 static void
647 snd_rme32_setframelog(rme32_t * rme32, int n_channels, int is_playback)
648 {
649         int frlog;
650
651         if (n_channels == 2) {
652                 frlog = 1;
653         } else {
654                 /* assume 8 channels */
655                 frlog = 3;
656         }
657         if (is_playback) {
658                 frlog += (rme32->wcreg & RME32_WCR_MODE24) ? 2 : 1;
659                 rme32->playback_frlog = frlog;
660         } else {
661                 frlog += (rme32->wcreg & RME32_WCR_MODE24) ? 2 : 1;
662                 rme32->capture_frlog = frlog;
663         }
664 }
665
666 static int snd_rme32_setformat(rme32_t * rme32, int format)
667 {
668         switch (format) {
669         case SNDRV_PCM_FORMAT_S16_LE:
670                 rme32->wcreg &= ~RME32_WCR_MODE24;
671                 break;
672         case SNDRV_PCM_FORMAT_S32_LE:
673                 rme32->wcreg |= RME32_WCR_MODE24;
674                 break;
675         default:
676                 return -EINVAL;
677         }
678         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
679         return 0;
680 }
681
682 static int
683 snd_rme32_playback_hw_params(snd_pcm_substream_t * substream,
684                              snd_pcm_hw_params_t * params)
685 {
686         int err, rate, dummy;
687         rme32_t *rme32 = snd_pcm_substream_chip(substream);
688         snd_pcm_runtime_t *runtime = substream->runtime;
689
690         if (rme32->fullduplex_mode) {
691                 err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
692                 if (err < 0)
693                         return err;
694         } else {
695                 runtime->dma_area = (void *)(rme32->iobase + RME32_IO_DATA_BUFFER);
696                 runtime->dma_addr = rme32->port + RME32_IO_DATA_BUFFER;
697                 runtime->dma_bytes = RME32_BUFFER_SIZE;
698         }
699
700         spin_lock_irq(&rme32->lock);
701         if ((rme32->rcreg & RME32_RCR_KMODE) &&
702             (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
703                 /* AutoSync */
704                 if ((int)params_rate(params) != rate) {
705                         spin_unlock_irq(&rme32->lock);
706                         return -EIO;
707                 }
708         } else if ((err = snd_rme32_playback_setrate(rme32, params_rate(params))) < 0) {
709                 spin_unlock_irq(&rme32->lock);
710                 return err;
711         }
712         if ((err = snd_rme32_setformat(rme32, params_format(params))) < 0) {
713                 spin_unlock_irq(&rme32->lock);
714                 return err;
715         }
716
717         snd_rme32_setframelog(rme32, params_channels(params), 1);
718         if (rme32->capture_periodsize != 0) {
719                 if (params_period_size(params) << rme32->playback_frlog != rme32->capture_periodsize) {
720                         spin_unlock_irq(&rme32->lock);
721                         return -EBUSY;
722                 }
723         }
724         rme32->playback_periodsize = params_period_size(params) << rme32->playback_frlog;
725         /* S/PDIF setup */
726         if ((rme32->wcreg & RME32_WCR_ADAT) == 0) {
727                 rme32->wcreg &= ~(RME32_WCR_PRO | RME32_WCR_EMP);
728                 rme32->wcreg |= rme32->wcreg_spdif_stream;
729                 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
730         }
731         spin_unlock_irq(&rme32->lock);
732
733         return 0;
734 }
735
736 static int
737 snd_rme32_capture_hw_params(snd_pcm_substream_t * substream,
738                             snd_pcm_hw_params_t * params)
739 {
740         int err, isadat, rate;
741         rme32_t *rme32 = snd_pcm_substream_chip(substream);
742         snd_pcm_runtime_t *runtime = substream->runtime;
743
744         if (rme32->fullduplex_mode) {
745                 err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
746                 if (err < 0)
747                         return err;
748         } else {
749                 runtime->dma_area = (void *)rme32->iobase + RME32_IO_DATA_BUFFER;
750                 runtime->dma_addr = rme32->port + RME32_IO_DATA_BUFFER;
751                 runtime->dma_bytes = RME32_BUFFER_SIZE;
752         }
753
754         spin_lock_irq(&rme32->lock);
755         /* enable AutoSync for record-preparing */
756         rme32->wcreg |= RME32_WCR_AUTOSYNC;
757         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
758
759         if ((err = snd_rme32_setformat(rme32, params_format(params))) < 0) {
760                 spin_unlock_irq(&rme32->lock);
761                 return err;
762         }
763         if ((err = snd_rme32_playback_setrate(rme32, params_rate(params))) < 0) {
764                 spin_unlock_irq(&rme32->lock);
765                 return err;
766         }
767         if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
768                 if ((int)params_rate(params) != rate) {
769                         spin_unlock_irq(&rme32->lock);
770                         return -EIO;                    
771                 }
772                 if ((isadat && runtime->hw.channels_min == 2) ||
773                     (!isadat && runtime->hw.channels_min == 8)) {
774                         spin_unlock_irq(&rme32->lock);
775                         return -EIO;
776                 }
777         }
778         /* AutoSync off for recording */
779         rme32->wcreg &= ~RME32_WCR_AUTOSYNC;
780         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
781
782         snd_rme32_setframelog(rme32, params_channels(params), 0);
783         if (rme32->playback_periodsize != 0) {
784                 if (params_period_size(params) << rme32->capture_frlog !=
785                     rme32->playback_periodsize) {
786                         spin_unlock_irq(&rme32->lock);
787                         return -EBUSY;
788                 }
789         }
790         rme32->capture_periodsize =
791             params_period_size(params) << rme32->capture_frlog;
792         spin_unlock_irq(&rme32->lock);
793
794         return 0;
795 }
796
797 static int snd_rme32_pcm_hw_free(snd_pcm_substream_t * substream)
798 {
799         rme32_t *rme32 = snd_pcm_substream_chip(substream);
800         if (! rme32->fullduplex_mode)
801                 return 0;
802         return snd_pcm_lib_free_pages(substream);
803 }
804
805 static void snd_rme32_pcm_start(rme32_t * rme32, int from_pause)
806 {
807         if (!from_pause) {
808                 writel(0, rme32->iobase + RME32_IO_RESET_POS);
809         }
810
811         rme32->wcreg |= RME32_WCR_START;
812         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
813 }
814
815 static void snd_rme32_pcm_stop(rme32_t * rme32, int to_pause)
816 {
817         /*
818          * Check if there is an unconfirmed IRQ, if so confirm it, or else
819          * the hardware will not stop generating interrupts
820          */
821         rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
822         if (rme32->rcreg & RME32_RCR_IRQ) {
823                 writel(0, rme32->iobase + RME32_IO_CONFIRM_ACTION_IRQ);
824         }
825         rme32->wcreg &= ~RME32_WCR_START;
826         if (rme32->wcreg & RME32_WCR_SEL)
827                 rme32->wcreg |= RME32_WCR_MUTE;
828         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
829         if (! to_pause)
830                 writel(0, rme32->iobase + RME32_IO_RESET_POS);
831 }
832
833 static irqreturn_t
834 snd_rme32_interrupt(int irq, void *dev_id, struct pt_regs *regs)
835 {
836         rme32_t *rme32 = (rme32_t *) dev_id;
837
838         rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
839         if (!(rme32->rcreg & RME32_RCR_IRQ)) {
840                 return IRQ_NONE;
841         } else {
842                 if (rme32->capture_substream) {
843                         snd_pcm_period_elapsed(rme32->capture_substream);
844                 }
845                 if (rme32->playback_substream) {
846                         snd_pcm_period_elapsed(rme32->playback_substream);
847                 }
848                 writel(0, rme32->iobase + RME32_IO_CONFIRM_ACTION_IRQ);
849         }
850         return IRQ_HANDLED;
851 }
852
853 static unsigned int period_bytes[] = { RME32_BLOCK_SIZE };
854
855
856 static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = {
857         .count = ARRAY_SIZE(period_bytes),
858         .list = period_bytes,
859         .mask = 0
860 };
861
862 static void snd_rme32_set_buffer_constraint(rme32_t *rme32, snd_pcm_runtime_t *runtime)
863 {
864         if (! rme32->fullduplex_mode) {
865                 snd_pcm_hw_constraint_minmax(runtime,
866                                              SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
867                                              RME32_BUFFER_SIZE, RME32_BUFFER_SIZE);
868                 snd_pcm_hw_constraint_list(runtime, 0,
869                                            SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
870                                            &hw_constraints_period_bytes);
871         }
872 }
873
874 static int snd_rme32_playback_spdif_open(snd_pcm_substream_t * substream)
875 {
876         int rate, dummy;
877         rme32_t *rme32 = snd_pcm_substream_chip(substream);
878         snd_pcm_runtime_t *runtime = substream->runtime;
879
880         snd_pcm_set_sync(substream);
881
882         spin_lock_irq(&rme32->lock);
883         if (rme32->playback_substream != NULL) {
884                 spin_unlock_irq(&rme32->lock);
885                 return -EBUSY;
886         }
887         rme32->wcreg &= ~RME32_WCR_ADAT;
888         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
889         rme32->playback_substream = substream;
890         spin_unlock_irq(&rme32->lock);
891
892         if (rme32->fullduplex_mode)
893                 runtime->hw = snd_rme32_spdif_fd_info;
894         else
895                 runtime->hw = snd_rme32_spdif_info;
896         if (rme32->pci->device == PCI_DEVICE_ID_DIGI32_PRO) {
897                 runtime->hw.rates |= SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000;
898                 runtime->hw.rate_max = 96000;
899         }
900         if ((rme32->rcreg & RME32_RCR_KMODE) &&
901             (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
902                 /* AutoSync */
903                 runtime->hw.rates = snd_rme32_ratecode(rate);
904                 runtime->hw.rate_min = rate;
905                 runtime->hw.rate_max = rate;
906         }       
907
908         snd_rme32_set_buffer_constraint(rme32, runtime);
909
910         rme32->wcreg_spdif_stream = rme32->wcreg_spdif;
911         rme32->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
912         snd_ctl_notify(rme32->card, SNDRV_CTL_EVENT_MASK_VALUE |
913                        SNDRV_CTL_EVENT_MASK_INFO, &rme32->spdif_ctl->id);
914         return 0;
915 }
916
917 static int snd_rme32_capture_spdif_open(snd_pcm_substream_t * substream)
918 {
919         int isadat, rate;
920         rme32_t *rme32 = snd_pcm_substream_chip(substream);
921         snd_pcm_runtime_t *runtime = substream->runtime;
922
923         snd_pcm_set_sync(substream);
924
925         spin_lock_irq(&rme32->lock);
926         if (rme32->capture_substream != NULL) {
927                 spin_unlock_irq(&rme32->lock);
928                 return -EBUSY;
929         }
930         rme32->capture_substream = substream;
931         spin_unlock_irq(&rme32->lock);
932
933         if (rme32->fullduplex_mode)
934                 runtime->hw = snd_rme32_spdif_fd_info;
935         else
936                 runtime->hw = snd_rme32_spdif_info;
937         if (RME32_PRO_WITH_8414(rme32)) {
938                 runtime->hw.rates |= SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000;
939                 runtime->hw.rate_max = 96000;
940         }
941         if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
942                 if (isadat) {
943                         return -EIO;
944                 }
945                 runtime->hw.rates = snd_rme32_ratecode(rate);
946                 runtime->hw.rate_min = rate;
947                 runtime->hw.rate_max = rate;
948         }
949
950         snd_rme32_set_buffer_constraint(rme32, runtime);
951
952         return 0;
953 }
954
955 static int
956 snd_rme32_playback_adat_open(snd_pcm_substream_t *substream)
957 {
958         int rate, dummy;
959         rme32_t *rme32 = snd_pcm_substream_chip(substream);
960         snd_pcm_runtime_t *runtime = substream->runtime;
961         
962         snd_pcm_set_sync(substream);
963
964         spin_lock_irq(&rme32->lock);    
965         if (rme32->playback_substream != NULL) {
966                 spin_unlock_irq(&rme32->lock);
967                 return -EBUSY;
968         }
969         rme32->wcreg |= RME32_WCR_ADAT;
970         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
971         rme32->playback_substream = substream;
972         spin_unlock_irq(&rme32->lock);
973         
974         if (rme32->fullduplex_mode)
975                 runtime->hw = snd_rme32_adat_fd_info;
976         else
977                 runtime->hw = snd_rme32_adat_info;
978         if ((rme32->rcreg & RME32_RCR_KMODE) &&
979             (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
980                 /* AutoSync */
981                 runtime->hw.rates = snd_rme32_ratecode(rate);
982                 runtime->hw.rate_min = rate;
983                 runtime->hw.rate_max = rate;
984         }        
985
986         snd_rme32_set_buffer_constraint(rme32, runtime);
987         return 0;
988 }
989
990 static int
991 snd_rme32_capture_adat_open(snd_pcm_substream_t *substream)
992 {
993         int isadat, rate;
994         rme32_t *rme32 = snd_pcm_substream_chip(substream);
995         snd_pcm_runtime_t *runtime = substream->runtime;
996
997         if (rme32->fullduplex_mode)
998                 runtime->hw = snd_rme32_adat_fd_info;
999         else
1000                 runtime->hw = snd_rme32_adat_info;
1001         if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
1002                 if (!isadat) {
1003                         return -EIO;
1004                 }
1005                 runtime->hw.rates = snd_rme32_ratecode(rate);
1006                 runtime->hw.rate_min = rate;
1007                 runtime->hw.rate_max = rate;
1008         }
1009
1010         snd_pcm_set_sync(substream);
1011         
1012         spin_lock_irq(&rme32->lock);    
1013         if (rme32->capture_substream != NULL) {
1014                 spin_unlock_irq(&rme32->lock);
1015                 return -EBUSY;
1016         }
1017         rme32->capture_substream = substream;
1018         spin_unlock_irq(&rme32->lock);
1019
1020         snd_rme32_set_buffer_constraint(rme32, runtime);
1021         return 0;
1022 }
1023
1024 static int snd_rme32_playback_close(snd_pcm_substream_t * substream)
1025 {
1026         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1027         int spdif = 0;
1028
1029         spin_lock_irq(&rme32->lock);
1030         rme32->playback_substream = NULL;
1031         rme32->playback_periodsize = 0;
1032         spdif = (rme32->wcreg & RME32_WCR_ADAT) == 0;
1033         spin_unlock_irq(&rme32->lock);
1034         if (spdif) {
1035                 rme32->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1036                 snd_ctl_notify(rme32->card, SNDRV_CTL_EVENT_MASK_VALUE |
1037                                SNDRV_CTL_EVENT_MASK_INFO,
1038                                &rme32->spdif_ctl->id);
1039         }
1040         return 0;
1041 }
1042
1043 static int snd_rme32_capture_close(snd_pcm_substream_t * substream)
1044 {
1045         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1046
1047         spin_lock_irq(&rme32->lock);
1048         rme32->capture_substream = NULL;
1049         rme32->capture_periodsize = 0;
1050         spin_unlock(&rme32->lock);
1051         return 0;
1052 }
1053
1054 static int snd_rme32_playback_prepare(snd_pcm_substream_t * substream)
1055 {
1056         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1057
1058         spin_lock_irq(&rme32->lock);
1059         if (rme32->fullduplex_mode) {
1060                 memset(&rme32->playback_pcm, 0, sizeof(rme32->playback_pcm));
1061                 rme32->playback_pcm.hw_buffer_size = RME32_BUFFER_SIZE;
1062                 rme32->playback_pcm.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
1063         } else {
1064                 writel(0, rme32->iobase + RME32_IO_RESET_POS);
1065         }
1066         if (rme32->wcreg & RME32_WCR_SEL)
1067                 rme32->wcreg &= ~RME32_WCR_MUTE;
1068         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1069         spin_unlock_irq(&rme32->lock);
1070         return 0;
1071 }
1072
1073 static int snd_rme32_capture_prepare(snd_pcm_substream_t * substream)
1074 {
1075         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1076
1077         spin_lock_irq(&rme32->lock);
1078         if (rme32->fullduplex_mode) {
1079                 memset(&rme32->capture_pcm, 0, sizeof(rme32->capture_pcm));
1080                 rme32->capture_pcm.hw_buffer_size = RME32_BUFFER_SIZE;
1081                 rme32->capture_pcm.hw_queue_size = RME32_BUFFER_SIZE / 2;
1082                 rme32->capture_pcm.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
1083         } else {
1084                 writel(0, rme32->iobase + RME32_IO_RESET_POS);
1085         }
1086         spin_unlock_irq(&rme32->lock);
1087         return 0;
1088 }
1089
1090 static int
1091 snd_rme32_pcm_trigger(snd_pcm_substream_t * substream, int cmd)
1092 {
1093         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1094         struct list_head *pos;
1095         snd_pcm_substream_t *s;
1096
1097         spin_lock(&rme32->lock);
1098         snd_pcm_group_for_each(pos, substream) {
1099                 s = snd_pcm_group_substream_entry(pos);
1100                 if (s != rme32->playback_substream &&
1101                     s != rme32->capture_substream)
1102                         continue;
1103                 switch (cmd) {
1104                 case SNDRV_PCM_TRIGGER_START:
1105                         rme32->running |= (1 << s->stream);
1106                         if (rme32->fullduplex_mode) {
1107                                 /* remember the current DMA position */
1108                                 if (s == rme32->playback_substream) {
1109                                         rme32->playback_pcm.hw_io =
1110                                         rme32->playback_pcm.hw_data = snd_rme32_pcm_byteptr(rme32);
1111                                 } else {
1112                                         rme32->capture_pcm.hw_io =
1113                                         rme32->capture_pcm.hw_data = snd_rme32_pcm_byteptr(rme32);
1114                                 }
1115                         }
1116                         break;
1117                 case SNDRV_PCM_TRIGGER_STOP:
1118                         rme32->running &= ~(1 << s->stream);
1119                         break;
1120                 }
1121                 snd_pcm_trigger_done(s, substream);
1122         }
1123         
1124         /* prefill playback buffer */
1125         if (cmd == SNDRV_PCM_TRIGGER_START && rme32->fullduplex_mode) {
1126                 snd_pcm_group_for_each(pos, substream) {
1127                         s = snd_pcm_group_substream_entry(pos);
1128                         if (s == rme32->playback_substream) {
1129                                 s->ops->ack(s);
1130                                 break;
1131                         }
1132                 }
1133         }
1134
1135         switch (cmd) {
1136         case SNDRV_PCM_TRIGGER_START:
1137                 if (rme32->running && ! RME32_ISWORKING(rme32))
1138                         snd_rme32_pcm_start(rme32, 0);
1139                 break;
1140         case SNDRV_PCM_TRIGGER_STOP:
1141                 if (! rme32->running && RME32_ISWORKING(rme32))
1142                         snd_rme32_pcm_stop(rme32, 0);
1143                 break;
1144         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1145                 if (rme32->running && RME32_ISWORKING(rme32))
1146                         snd_rme32_pcm_stop(rme32, 1);
1147                 break;
1148         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1149                 if (rme32->running && ! RME32_ISWORKING(rme32))
1150                         snd_rme32_pcm_start(rme32, 1);
1151                 break;
1152         }
1153         spin_unlock(&rme32->lock);
1154         return 0;
1155 }
1156
1157 /* pointer callback for halfduplex mode */
1158 static snd_pcm_uframes_t
1159 snd_rme32_playback_pointer(snd_pcm_substream_t * substream)
1160 {
1161         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1162         return snd_rme32_pcm_byteptr(rme32) >> rme32->playback_frlog;
1163 }
1164
1165 static snd_pcm_uframes_t
1166 snd_rme32_capture_pointer(snd_pcm_substream_t * substream)
1167 {
1168         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1169         return snd_rme32_pcm_byteptr(rme32) >> rme32->capture_frlog;
1170 }
1171
1172
1173 /* ack and pointer callbacks for fullduplex mode */
1174 static void snd_rme32_pb_trans_copy(snd_pcm_substream_t *substream,
1175                                     snd_pcm_indirect_t *rec, size_t bytes)
1176 {
1177         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1178         memcpy_toio(rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data,
1179                     substream->runtime->dma_area + rec->sw_data, bytes);
1180 }
1181
1182 static int snd_rme32_playback_fd_ack(snd_pcm_substream_t *substream)
1183 {
1184         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1185         snd_pcm_indirect_t *rec, *cprec;
1186
1187         rec = &rme32->playback_pcm;
1188         cprec = &rme32->capture_pcm;
1189         spin_lock(&rme32->lock);
1190         rec->hw_queue_size = RME32_BUFFER_SIZE;
1191         if (rme32->running & (1 << SNDRV_PCM_STREAM_CAPTURE))
1192                 rec->hw_queue_size -= cprec->hw_ready;
1193         spin_unlock(&rme32->lock);
1194         snd_pcm_indirect_playback_transfer(substream, rec,
1195                                            snd_rme32_pb_trans_copy);
1196         return 0;
1197 }
1198
1199 static void snd_rme32_cp_trans_copy(snd_pcm_substream_t *substream,
1200                                     snd_pcm_indirect_t *rec, size_t bytes)
1201 {
1202         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1203         memcpy_fromio(substream->runtime->dma_area + rec->sw_data,
1204                       rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data,
1205                       bytes);
1206 }
1207
1208 static int snd_rme32_capture_fd_ack(snd_pcm_substream_t *substream)
1209 {
1210         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1211         snd_pcm_indirect_capture_transfer(substream, &rme32->capture_pcm,
1212                                           snd_rme32_cp_trans_copy);
1213         return 0;
1214 }
1215
1216 static snd_pcm_uframes_t
1217 snd_rme32_playback_fd_pointer(snd_pcm_substream_t * substream)
1218 {
1219         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1220         return snd_pcm_indirect_playback_pointer(substream, &rme32->playback_pcm,
1221                                                  snd_rme32_pcm_byteptr(rme32));
1222 }
1223
1224 static snd_pcm_uframes_t
1225 snd_rme32_capture_fd_pointer(snd_pcm_substream_t * substream)
1226 {
1227         rme32_t *rme32 = snd_pcm_substream_chip(substream);
1228         return snd_pcm_indirect_capture_pointer(substream, &rme32->capture_pcm,
1229                                                 snd_rme32_pcm_byteptr(rme32));
1230 }
1231
1232 /* for halfduplex mode */
1233 static snd_pcm_ops_t snd_rme32_playback_spdif_ops = {
1234         .open =         snd_rme32_playback_spdif_open,
1235         .close =        snd_rme32_playback_close,
1236         .ioctl =        snd_pcm_lib_ioctl,
1237         .hw_params =    snd_rme32_playback_hw_params,
1238         .hw_free =      snd_rme32_pcm_hw_free,
1239         .prepare =      snd_rme32_playback_prepare,
1240         .trigger =      snd_rme32_pcm_trigger,
1241         .pointer =      snd_rme32_playback_pointer,
1242         .copy =         snd_rme32_playback_copy,
1243         .silence =      snd_rme32_playback_silence,
1244         .mmap =         snd_pcm_lib_mmap_iomem,
1245 };
1246
1247 static snd_pcm_ops_t snd_rme32_capture_spdif_ops = {
1248         .open =         snd_rme32_capture_spdif_open,
1249         .close =        snd_rme32_capture_close,
1250         .ioctl =        snd_pcm_lib_ioctl,
1251         .hw_params =    snd_rme32_capture_hw_params,
1252         .hw_free =      snd_rme32_pcm_hw_free,
1253         .prepare =      snd_rme32_capture_prepare,
1254         .trigger =      snd_rme32_pcm_trigger,
1255         .pointer =      snd_rme32_capture_pointer,
1256         .copy =         snd_rme32_capture_copy,
1257         .mmap =         snd_pcm_lib_mmap_iomem,
1258 };
1259
1260 static snd_pcm_ops_t snd_rme32_playback_adat_ops = {
1261         .open =         snd_rme32_playback_adat_open,
1262         .close =        snd_rme32_playback_close,
1263         .ioctl =        snd_pcm_lib_ioctl,
1264         .hw_params =    snd_rme32_playback_hw_params,
1265         .prepare =      snd_rme32_playback_prepare,
1266         .trigger =      snd_rme32_pcm_trigger,
1267         .pointer =      snd_rme32_playback_pointer,
1268         .copy =         snd_rme32_playback_copy,
1269         .silence =      snd_rme32_playback_silence,
1270         .mmap =         snd_pcm_lib_mmap_iomem,
1271 };
1272
1273 static snd_pcm_ops_t snd_rme32_capture_adat_ops = {
1274         .open =         snd_rme32_capture_adat_open,
1275         .close =        snd_rme32_capture_close,
1276         .ioctl =        snd_pcm_lib_ioctl,
1277         .hw_params =    snd_rme32_capture_hw_params,
1278         .prepare =      snd_rme32_capture_prepare,
1279         .trigger =      snd_rme32_pcm_trigger,
1280         .pointer =      snd_rme32_capture_pointer,
1281         .copy =         snd_rme32_capture_copy,
1282         .mmap =         snd_pcm_lib_mmap_iomem,
1283 };
1284
1285 /* for fullduplex mode */
1286 static snd_pcm_ops_t snd_rme32_playback_spdif_fd_ops = {
1287         .open =         snd_rme32_playback_spdif_open,
1288         .close =        snd_rme32_playback_close,
1289         .ioctl =        snd_pcm_lib_ioctl,
1290         .hw_params =    snd_rme32_playback_hw_params,
1291         .hw_free =      snd_rme32_pcm_hw_free,
1292         .prepare =      snd_rme32_playback_prepare,
1293         .trigger =      snd_rme32_pcm_trigger,
1294         .pointer =      snd_rme32_playback_fd_pointer,
1295         .ack =          snd_rme32_playback_fd_ack,
1296 };
1297
1298 static snd_pcm_ops_t snd_rme32_capture_spdif_fd_ops = {
1299         .open =         snd_rme32_capture_spdif_open,
1300         .close =        snd_rme32_capture_close,
1301         .ioctl =        snd_pcm_lib_ioctl,
1302         .hw_params =    snd_rme32_capture_hw_params,
1303         .hw_free =      snd_rme32_pcm_hw_free,
1304         .prepare =      snd_rme32_capture_prepare,
1305         .trigger =      snd_rme32_pcm_trigger,
1306         .pointer =      snd_rme32_capture_fd_pointer,
1307         .ack =          snd_rme32_capture_fd_ack,
1308 };
1309
1310 static snd_pcm_ops_t snd_rme32_playback_adat_fd_ops = {
1311         .open =         snd_rme32_playback_adat_open,
1312         .close =        snd_rme32_playback_close,
1313         .ioctl =        snd_pcm_lib_ioctl,
1314         .hw_params =    snd_rme32_playback_hw_params,
1315         .prepare =      snd_rme32_playback_prepare,
1316         .trigger =      snd_rme32_pcm_trigger,
1317         .pointer =      snd_rme32_playback_fd_pointer,
1318         .ack =          snd_rme32_playback_fd_ack,
1319 };
1320
1321 static snd_pcm_ops_t snd_rme32_capture_adat_fd_ops = {
1322         .open =         snd_rme32_capture_adat_open,
1323         .close =        snd_rme32_capture_close,
1324         .ioctl =        snd_pcm_lib_ioctl,
1325         .hw_params =    snd_rme32_capture_hw_params,
1326         .prepare =      snd_rme32_capture_prepare,
1327         .trigger =      snd_rme32_pcm_trigger,
1328         .pointer =      snd_rme32_capture_fd_pointer,
1329         .ack =          snd_rme32_capture_fd_ack,
1330 };
1331
1332 static void snd_rme32_free(void *private_data)
1333 {
1334         rme32_t *rme32 = (rme32_t *) private_data;
1335
1336         if (rme32 == NULL) {
1337                 return;
1338         }
1339         if (rme32->irq >= 0) {
1340                 snd_rme32_pcm_stop(rme32, 0);
1341                 free_irq(rme32->irq, (void *) rme32);
1342                 rme32->irq = -1;
1343         }
1344         if (rme32->iobase) {
1345                 iounmap(rme32->iobase);
1346                 rme32->iobase = NULL;
1347         }
1348         if (rme32->port) {
1349                 pci_release_regions(rme32->pci);
1350                 rme32->port = 0;
1351         }
1352         pci_disable_device(rme32->pci);
1353 }
1354
1355 static void snd_rme32_free_spdif_pcm(snd_pcm_t * pcm)
1356 {
1357         rme32_t *rme32 = (rme32_t *) pcm->private_data;
1358         rme32->spdif_pcm = NULL;
1359 }
1360
1361 static void
1362 snd_rme32_free_adat_pcm(snd_pcm_t *pcm)
1363 {
1364         rme32_t *rme32 = (rme32_t *) pcm->private_data;
1365         rme32->adat_pcm = NULL;
1366 }
1367
1368 static int __devinit snd_rme32_create(rme32_t * rme32)
1369 {
1370         struct pci_dev *pci = rme32->pci;
1371         int err;
1372
1373         rme32->irq = -1;
1374         spin_lock_init(&rme32->lock);
1375
1376         if ((err = pci_enable_device(pci)) < 0)
1377                 return err;
1378
1379         if ((err = pci_request_regions(pci, "RME32")) < 0)
1380                 return err;
1381         rme32->port = pci_resource_start(rme32->pci, 0);
1382
1383         if (request_irq(pci->irq, snd_rme32_interrupt, SA_INTERRUPT | SA_SHIRQ, "RME32", (void *) rme32)) {
1384                 snd_printk("unable to grab IRQ %d\n", pci->irq);
1385                 return -EBUSY;
1386         }
1387         rme32->irq = pci->irq;
1388
1389         if ((rme32->iobase = ioremap_nocache(rme32->port, RME32_IO_SIZE)) == 0) {
1390                 snd_printk("unable to remap memory region 0x%lx-0x%lx\n",
1391                            rme32->port, rme32->port + RME32_IO_SIZE - 1);
1392                 return -ENOMEM;
1393         }
1394
1395         /* read the card's revision number */
1396         pci_read_config_byte(pci, 8, &rme32->rev);
1397
1398         /* set up ALSA pcm device for S/PDIF */
1399         if ((err = snd_pcm_new(rme32->card, "Digi32 IEC958", 0, 1, 1, &rme32->spdif_pcm)) < 0) {
1400                 return err;
1401         }
1402         rme32->spdif_pcm->private_data = rme32;
1403         rme32->spdif_pcm->private_free = snd_rme32_free_spdif_pcm;
1404         strcpy(rme32->spdif_pcm->name, "Digi32 IEC958");
1405         if (rme32->fullduplex_mode) {
1406                 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1407                                 &snd_rme32_playback_spdif_fd_ops);
1408                 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_CAPTURE,
1409                                 &snd_rme32_capture_spdif_fd_ops);
1410                 snd_pcm_lib_preallocate_pages_for_all(rme32->spdif_pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1411                                                       snd_dma_continuous_data(GFP_KERNEL),
1412                                                       0, RME32_MID_BUFFER_SIZE);
1413                 rme32->spdif_pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
1414         } else {
1415                 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1416                                 &snd_rme32_playback_spdif_ops);
1417                 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_CAPTURE,
1418                                 &snd_rme32_capture_spdif_ops);
1419                 rme32->spdif_pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
1420         }
1421
1422         /* set up ALSA pcm device for ADAT */
1423         if ((pci->device == PCI_DEVICE_ID_DIGI32) ||
1424             (pci->device == PCI_DEVICE_ID_DIGI32_PRO)) {
1425                 /* ADAT is not available on DIGI32 and DIGI32 Pro */
1426                 rme32->adat_pcm = NULL;
1427         }
1428         else {
1429                 if ((err = snd_pcm_new(rme32->card, "Digi32 ADAT", 1,
1430                                        1, 1, &rme32->adat_pcm)) < 0)
1431                 {
1432                         return err;
1433                 }               
1434                 rme32->adat_pcm->private_data = rme32;
1435                 rme32->adat_pcm->private_free = snd_rme32_free_adat_pcm;
1436                 strcpy(rme32->adat_pcm->name, "Digi32 ADAT");
1437                 if (rme32->fullduplex_mode) {
1438                         snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_PLAYBACK, 
1439                                         &snd_rme32_playback_adat_fd_ops);
1440                         snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_CAPTURE, 
1441                                         &snd_rme32_capture_adat_fd_ops);
1442                         snd_pcm_lib_preallocate_pages_for_all(rme32->adat_pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1443                                                               snd_dma_continuous_data(GFP_KERNEL),
1444                                                               0, RME32_MID_BUFFER_SIZE);
1445                         rme32->adat_pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
1446                 } else {
1447                         snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_PLAYBACK, 
1448                                         &snd_rme32_playback_adat_ops);
1449                         snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_CAPTURE, 
1450                                         &snd_rme32_capture_adat_ops);
1451                         rme32->adat_pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
1452                 }
1453         }
1454
1455
1456         rme32->playback_periodsize = 0;
1457         rme32->capture_periodsize = 0;
1458
1459         /* make sure playback/capture is stopped, if by some reason active */
1460         snd_rme32_pcm_stop(rme32, 0);
1461
1462         /* reset DAC */
1463         snd_rme32_reset_dac(rme32);
1464
1465         /* reset buffer pointer */
1466         writel(0, rme32->iobase + RME32_IO_RESET_POS);
1467
1468         /* set default values in registers */
1469         rme32->wcreg = RME32_WCR_SEL |   /* normal playback */
1470                 RME32_WCR_INP_0 | /* input select */
1471                 RME32_WCR_MUTE;  /* muting on */
1472         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1473
1474
1475         /* init switch interface */
1476         if ((err = snd_rme32_create_switches(rme32->card, rme32)) < 0) {
1477                 return err;
1478         }
1479
1480         /* init proc interface */
1481         snd_rme32_proc_init(rme32);
1482
1483         rme32->capture_substream = NULL;
1484         rme32->playback_substream = NULL;
1485
1486         return 0;
1487 }
1488
1489 /*
1490  * proc interface
1491  */
1492
1493 static void
1494 snd_rme32_proc_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer)
1495 {
1496         int n;
1497         rme32_t *rme32 = (rme32_t *) entry->private_data;
1498
1499         rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
1500
1501         snd_iprintf(buffer, rme32->card->longname);
1502         snd_iprintf(buffer, " (index #%d)\n", rme32->card->number + 1);
1503
1504         snd_iprintf(buffer, "\nGeneral settings\n");
1505         if (rme32->fullduplex_mode)
1506                 snd_iprintf(buffer, "  Full-duplex mode\n");
1507         else
1508                 snd_iprintf(buffer, "  Half-duplex mode\n");
1509         if (RME32_PRO_WITH_8414(rme32)) {
1510                 snd_iprintf(buffer, "  receiver: CS8414\n");
1511         } else {
1512                 snd_iprintf(buffer, "  receiver: CS8412\n");
1513         }
1514         if (rme32->wcreg & RME32_WCR_MODE24) {
1515                 snd_iprintf(buffer, "  format: 24 bit");
1516         } else {
1517                 snd_iprintf(buffer, "  format: 16 bit");
1518         }
1519         if (rme32->wcreg & RME32_WCR_MONO) {
1520                 snd_iprintf(buffer, ", Mono\n");
1521         } else {
1522                 snd_iprintf(buffer, ", Stereo\n");
1523         }
1524
1525         snd_iprintf(buffer, "\nInput settings\n");
1526         switch (snd_rme32_getinputtype(rme32)) {
1527         case RME32_INPUT_OPTICAL:
1528                 snd_iprintf(buffer, "  input: optical");
1529                 break;
1530         case RME32_INPUT_COAXIAL:
1531                 snd_iprintf(buffer, "  input: coaxial");
1532                 break;
1533         case RME32_INPUT_INTERNAL:
1534                 snd_iprintf(buffer, "  input: internal");
1535                 break;
1536         case RME32_INPUT_XLR:
1537                 snd_iprintf(buffer, "  input: XLR");
1538                 break;
1539         }
1540         if (snd_rme32_capture_getrate(rme32, &n) < 0) {
1541                 snd_iprintf(buffer, "\n  sample rate: no valid signal\n");
1542         } else {
1543                 if (n) {
1544                         snd_iprintf(buffer, " (8 channels)\n");
1545                 } else {
1546                         snd_iprintf(buffer, " (2 channels)\n");
1547                 }
1548                 snd_iprintf(buffer, "  sample rate: %d Hz\n",
1549                             snd_rme32_capture_getrate(rme32, &n));
1550         }
1551
1552         snd_iprintf(buffer, "\nOutput settings\n");
1553         if (rme32->wcreg & RME32_WCR_SEL) {
1554                 snd_iprintf(buffer, "  output signal: normal playback");
1555         } else {
1556                 snd_iprintf(buffer, "  output signal: same as input");
1557         }
1558         if (rme32->wcreg & RME32_WCR_MUTE) {
1559                 snd_iprintf(buffer, " (muted)\n");
1560         } else {
1561                 snd_iprintf(buffer, "\n");
1562         }
1563
1564         /* master output frequency */
1565         if (!
1566             ((!(rme32->wcreg & RME32_WCR_FREQ_0))
1567              && (!(rme32->wcreg & RME32_WCR_FREQ_1)))) {
1568                 snd_iprintf(buffer, "  sample rate: %d Hz\n",
1569                             snd_rme32_playback_getrate(rme32));
1570         }
1571         if (rme32->rcreg & RME32_RCR_KMODE) {
1572                 snd_iprintf(buffer, "  sample clock source: AutoSync\n");
1573         } else {
1574                 snd_iprintf(buffer, "  sample clock source: Internal\n");
1575         }
1576         if (rme32->wcreg & RME32_WCR_PRO) {
1577                 snd_iprintf(buffer, "  format: AES/EBU (professional)\n");
1578         } else {
1579                 snd_iprintf(buffer, "  format: IEC958 (consumer)\n");
1580         }
1581         if (rme32->wcreg & RME32_WCR_EMP) {
1582                 snd_iprintf(buffer, "  emphasis: on\n");
1583         } else {
1584                 snd_iprintf(buffer, "  emphasis: off\n");
1585         }
1586 }
1587
1588 static void __devinit snd_rme32_proc_init(rme32_t * rme32)
1589 {
1590         snd_info_entry_t *entry;
1591
1592         if (! snd_card_proc_new(rme32->card, "rme32", &entry))
1593                 snd_info_set_text_ops(entry, rme32, 1024, snd_rme32_proc_read);
1594 }
1595
1596 /*
1597  * control interface
1598  */
1599
1600 static int
1601 snd_rme32_info_loopback_control(snd_kcontrol_t * kcontrol,
1602                                 snd_ctl_elem_info_t * uinfo)
1603 {
1604         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1605         uinfo->count = 1;
1606         uinfo->value.integer.min = 0;
1607         uinfo->value.integer.max = 1;
1608         return 0;
1609 }
1610 static int
1611 snd_rme32_get_loopback_control(snd_kcontrol_t * kcontrol,
1612                                snd_ctl_elem_value_t * ucontrol)
1613 {
1614         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1615
1616         spin_lock_irq(&rme32->lock);
1617         ucontrol->value.integer.value[0] =
1618             rme32->wcreg & RME32_WCR_SEL ? 0 : 1;
1619         spin_unlock_irq(&rme32->lock);
1620         return 0;
1621 }
1622 static int
1623 snd_rme32_put_loopback_control(snd_kcontrol_t * kcontrol,
1624                                snd_ctl_elem_value_t * ucontrol)
1625 {
1626         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1627         unsigned int val;
1628         int change;
1629
1630         val = ucontrol->value.integer.value[0] ? 0 : RME32_WCR_SEL;
1631         spin_lock_irq(&rme32->lock);
1632         val = (rme32->wcreg & ~RME32_WCR_SEL) | val;
1633         change = val != rme32->wcreg;
1634         if (ucontrol->value.integer.value[0])
1635                 val &= ~RME32_WCR_MUTE;
1636         else
1637                 val |= RME32_WCR_MUTE;
1638         rme32->wcreg = val;
1639         writel(val, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1640         spin_unlock_irq(&rme32->lock);
1641         return change;
1642 }
1643
1644 static int
1645 snd_rme32_info_inputtype_control(snd_kcontrol_t * kcontrol,
1646                                  snd_ctl_elem_info_t * uinfo)
1647 {
1648         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1649         static char *texts[4] = { "Optical", "Coaxial", "Internal", "XLR" };
1650
1651         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1652         uinfo->count = 1;
1653         switch (rme32->pci->device) {
1654         case PCI_DEVICE_ID_DIGI32:
1655         case PCI_DEVICE_ID_DIGI32_8:
1656                 uinfo->value.enumerated.items = 3;
1657                 break;
1658         case PCI_DEVICE_ID_DIGI32_PRO:
1659                 uinfo->value.enumerated.items = 4;
1660                 break;
1661         default:
1662                 snd_BUG();
1663                 break;
1664         }
1665         if (uinfo->value.enumerated.item >
1666             uinfo->value.enumerated.items - 1) {
1667                 uinfo->value.enumerated.item =
1668                     uinfo->value.enumerated.items - 1;
1669         }
1670         strcpy(uinfo->value.enumerated.name,
1671                texts[uinfo->value.enumerated.item]);
1672         return 0;
1673 }
1674 static int
1675 snd_rme32_get_inputtype_control(snd_kcontrol_t * kcontrol,
1676                                 snd_ctl_elem_value_t * ucontrol)
1677 {
1678         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1679         unsigned int items = 3;
1680
1681         spin_lock_irq(&rme32->lock);
1682         ucontrol->value.enumerated.item[0] = snd_rme32_getinputtype(rme32);
1683
1684         switch (rme32->pci->device) {
1685         case PCI_DEVICE_ID_DIGI32:
1686         case PCI_DEVICE_ID_DIGI32_8:
1687                 items = 3;
1688                 break;
1689         case PCI_DEVICE_ID_DIGI32_PRO:
1690                 items = 4;
1691                 break;
1692         default:
1693                 snd_BUG();
1694                 break;
1695         }
1696         if (ucontrol->value.enumerated.item[0] >= items) {
1697                 ucontrol->value.enumerated.item[0] = items - 1;
1698         }
1699
1700         spin_unlock_irq(&rme32->lock);
1701         return 0;
1702 }
1703 static int
1704 snd_rme32_put_inputtype_control(snd_kcontrol_t * kcontrol,
1705                                 snd_ctl_elem_value_t * ucontrol)
1706 {
1707         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1708         unsigned int val;
1709         int change, items = 3;
1710
1711         switch (rme32->pci->device) {
1712         case PCI_DEVICE_ID_DIGI32:
1713         case PCI_DEVICE_ID_DIGI32_8:
1714                 items = 3;
1715                 break;
1716         case PCI_DEVICE_ID_DIGI32_PRO:
1717                 items = 4;
1718                 break;
1719         default:
1720                 snd_BUG();
1721                 break;
1722         }
1723         val = ucontrol->value.enumerated.item[0] % items;
1724
1725         spin_lock_irq(&rme32->lock);
1726         change = val != (unsigned int)snd_rme32_getinputtype(rme32);
1727         snd_rme32_setinputtype(rme32, val);
1728         spin_unlock_irq(&rme32->lock);
1729         return change;
1730 }
1731
1732 static int
1733 snd_rme32_info_clockmode_control(snd_kcontrol_t * kcontrol,
1734                                  snd_ctl_elem_info_t * uinfo)
1735 {
1736         static char *texts[4] = { "AutoSync", 
1737                                   "Internal 32.0kHz", 
1738                                   "Internal 44.1kHz", 
1739                                   "Internal 48.0kHz" };
1740
1741         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1742         uinfo->count = 1;
1743         uinfo->value.enumerated.items = 4;
1744         if (uinfo->value.enumerated.item > 3) {
1745                 uinfo->value.enumerated.item = 3;
1746         }
1747         strcpy(uinfo->value.enumerated.name,
1748                texts[uinfo->value.enumerated.item]);
1749         return 0;
1750 }
1751 static int
1752 snd_rme32_get_clockmode_control(snd_kcontrol_t * kcontrol,
1753                                 snd_ctl_elem_value_t * ucontrol)
1754 {
1755         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1756
1757         spin_lock_irq(&rme32->lock);
1758         ucontrol->value.enumerated.item[0] = snd_rme32_getclockmode(rme32);
1759         spin_unlock_irq(&rme32->lock);
1760         return 0;
1761 }
1762 static int
1763 snd_rme32_put_clockmode_control(snd_kcontrol_t * kcontrol,
1764                                 snd_ctl_elem_value_t * ucontrol)
1765 {
1766         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1767         unsigned int val;
1768         int change;
1769
1770         val = ucontrol->value.enumerated.item[0] % 3;
1771         spin_lock_irq(&rme32->lock);
1772         change = val != (unsigned int)snd_rme32_getclockmode(rme32);
1773         snd_rme32_setclockmode(rme32, val);
1774         spin_unlock_irq(&rme32->lock);
1775         return change;
1776 }
1777
1778 static u32 snd_rme32_convert_from_aes(snd_aes_iec958_t * aes)
1779 {
1780         u32 val = 0;
1781         val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME32_WCR_PRO : 0;
1782         if (val & RME32_WCR_PRO)
1783                 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? RME32_WCR_EMP : 0;
1784         else
1785                 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? RME32_WCR_EMP : 0;
1786         return val;
1787 }
1788
1789 static void snd_rme32_convert_to_aes(snd_aes_iec958_t * aes, u32 val)
1790 {
1791         aes->status[0] = ((val & RME32_WCR_PRO) ? IEC958_AES0_PROFESSIONAL : 0);
1792         if (val & RME32_WCR_PRO)
1793                 aes->status[0] |= (val & RME32_WCR_EMP) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0;
1794         else
1795                 aes->status[0] |= (val & RME32_WCR_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0;
1796 }
1797
1798 static int snd_rme32_control_spdif_info(snd_kcontrol_t * kcontrol,
1799                                         snd_ctl_elem_info_t * uinfo)
1800 {
1801         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1802         uinfo->count = 1;
1803         return 0;
1804 }
1805
1806 static int snd_rme32_control_spdif_get(snd_kcontrol_t * kcontrol,
1807                                        snd_ctl_elem_value_t * ucontrol)
1808 {
1809         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1810
1811         snd_rme32_convert_to_aes(&ucontrol->value.iec958,
1812                                  rme32->wcreg_spdif);
1813         return 0;
1814 }
1815
1816 static int snd_rme32_control_spdif_put(snd_kcontrol_t * kcontrol,
1817                                        snd_ctl_elem_value_t * ucontrol)
1818 {
1819         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1820         int change;
1821         u32 val;
1822
1823         val = snd_rme32_convert_from_aes(&ucontrol->value.iec958);
1824         spin_lock_irq(&rme32->lock);
1825         change = val != rme32->wcreg_spdif;
1826         rme32->wcreg_spdif = val;
1827         spin_unlock_irq(&rme32->lock);
1828         return change;
1829 }
1830
1831 static int snd_rme32_control_spdif_stream_info(snd_kcontrol_t * kcontrol,
1832                                                snd_ctl_elem_info_t * uinfo)
1833 {
1834         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1835         uinfo->count = 1;
1836         return 0;
1837 }
1838
1839 static int snd_rme32_control_spdif_stream_get(snd_kcontrol_t * kcontrol,
1840                                               snd_ctl_elem_value_t *
1841                                               ucontrol)
1842 {
1843         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1844
1845         snd_rme32_convert_to_aes(&ucontrol->value.iec958,
1846                                  rme32->wcreg_spdif_stream);
1847         return 0;
1848 }
1849
1850 static int snd_rme32_control_spdif_stream_put(snd_kcontrol_t * kcontrol,
1851                                               snd_ctl_elem_value_t *
1852                                               ucontrol)
1853 {
1854         rme32_t *rme32 = snd_kcontrol_chip(kcontrol);
1855         int change;
1856         u32 val;
1857
1858         val = snd_rme32_convert_from_aes(&ucontrol->value.iec958);
1859         spin_lock_irq(&rme32->lock);
1860         change = val != rme32->wcreg_spdif_stream;
1861         rme32->wcreg_spdif_stream = val;
1862         rme32->wcreg &= ~(RME32_WCR_PRO | RME32_WCR_EMP);
1863         rme32->wcreg |= val;
1864         writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1865         spin_unlock_irq(&rme32->lock);
1866         return change;
1867 }
1868
1869 static int snd_rme32_control_spdif_mask_info(snd_kcontrol_t * kcontrol,
1870                                              snd_ctl_elem_info_t * uinfo)
1871 {
1872         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1873         uinfo->count = 1;
1874         return 0;
1875 }
1876
1877 static int snd_rme32_control_spdif_mask_get(snd_kcontrol_t * kcontrol,
1878                                             snd_ctl_elem_value_t *
1879                                             ucontrol)
1880 {
1881         ucontrol->value.iec958.status[0] = kcontrol->private_value;
1882         return 0;
1883 }
1884
1885 static snd_kcontrol_new_t snd_rme32_controls[] = {
1886         {
1887                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1888                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1889                 .info = snd_rme32_control_spdif_info,
1890                 .get =  snd_rme32_control_spdif_get,
1891                 .put =  snd_rme32_control_spdif_put
1892         },
1893         {
1894                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1895                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1896                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
1897                 .info = snd_rme32_control_spdif_stream_info,
1898                 .get =  snd_rme32_control_spdif_stream_get,
1899                 .put =  snd_rme32_control_spdif_stream_put
1900         },
1901         {
1902                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1903                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1904                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1905                 .info = snd_rme32_control_spdif_mask_info,
1906                 .get =  snd_rme32_control_spdif_mask_get,
1907                 .private_value = IEC958_AES0_PROFESSIONAL | IEC958_AES0_CON_EMPHASIS
1908         },
1909         {
1910                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1911                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1912                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1913                 .info = snd_rme32_control_spdif_mask_info,
1914                 .get =  snd_rme32_control_spdif_mask_get,
1915                 .private_value = IEC958_AES0_PROFESSIONAL | IEC958_AES0_PRO_EMPHASIS
1916         },
1917         {
1918                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1919                 .name = "Input Connector",
1920                 .info = snd_rme32_info_inputtype_control,
1921                 .get =  snd_rme32_get_inputtype_control,
1922                 .put =  snd_rme32_put_inputtype_control
1923         },
1924         {
1925                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1926                 .name = "Loopback Input",
1927                 .info = snd_rme32_info_loopback_control,
1928                 .get =  snd_rme32_get_loopback_control,
1929                 .put =  snd_rme32_put_loopback_control
1930         },
1931         {
1932                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1933                 .name = "Sample Clock Source",
1934                 .info = snd_rme32_info_clockmode_control,
1935                 .get =  snd_rme32_get_clockmode_control,
1936                 .put =  snd_rme32_put_clockmode_control
1937         }
1938 };
1939
1940 static int snd_rme32_create_switches(snd_card_t * card, rme32_t * rme32)
1941 {
1942         int idx, err;
1943         snd_kcontrol_t *kctl;
1944
1945         for (idx = 0; idx < (int)ARRAY_SIZE(snd_rme32_controls); idx++) {
1946                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme32_controls[idx], rme32))) < 0)
1947                         return err;
1948                 if (idx == 1)   /* IEC958 (S/PDIF) Stream */
1949                         rme32->spdif_ctl = kctl;
1950         }
1951
1952         return 0;
1953 }
1954
1955 /*
1956  * Card initialisation
1957  */
1958
1959 static void snd_rme32_card_free(snd_card_t * card)
1960 {
1961         snd_rme32_free(card->private_data);
1962 }
1963
1964 static int __devinit
1965 snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
1966 {
1967         static int dev;
1968         rme32_t *rme32;
1969         snd_card_t *card;
1970         int err;
1971
1972         if (dev >= SNDRV_CARDS) {
1973                 return -ENODEV;
1974         }
1975         if (!enable[dev]) {
1976                 dev++;
1977                 return -ENOENT;
1978         }
1979
1980         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
1981                                  sizeof(rme32_t))) == NULL)
1982                 return -ENOMEM;
1983         card->private_free = snd_rme32_card_free;
1984         rme32 = (rme32_t *) card->private_data;
1985         rme32->card = card;
1986         rme32->pci = pci;
1987         snd_card_set_dev(card, &pci->dev);
1988         if (fullduplex[dev])
1989                 rme32->fullduplex_mode = 1;
1990         if ((err = snd_rme32_create(rme32)) < 0) {
1991                 snd_card_free(card);
1992                 return err;
1993         }
1994
1995         strcpy(card->driver, "Digi32");
1996         switch (rme32->pci->device) {
1997         case PCI_DEVICE_ID_DIGI32:
1998                 strcpy(card->shortname, "RME Digi32");
1999                 break;
2000         case PCI_DEVICE_ID_DIGI32_8:
2001                 strcpy(card->shortname, "RME Digi32/8");
2002                 break;
2003         case PCI_DEVICE_ID_DIGI32_PRO:
2004                 strcpy(card->shortname, "RME Digi32 PRO");
2005                 break;
2006         }
2007         sprintf(card->longname, "%s (Rev. %d) at 0x%lx, irq %d",
2008                 card->shortname, rme32->rev, rme32->port, rme32->irq);
2009
2010         if ((err = snd_card_register(card)) < 0) {
2011                 snd_card_free(card);
2012                 return err;
2013         }
2014         pci_set_drvdata(pci, card);
2015         dev++;
2016         return 0;
2017 }
2018
2019 static void __devexit snd_rme32_remove(struct pci_dev *pci)
2020 {
2021         snd_card_free(pci_get_drvdata(pci));
2022         pci_set_drvdata(pci, NULL);
2023 }
2024
2025 static struct pci_driver driver = {
2026         .name =         "RME Digi32",
2027         .id_table =     snd_rme32_ids,
2028         .probe =        snd_rme32_probe,
2029         .remove =       __devexit_p(snd_rme32_remove),
2030 };
2031
2032 static int __init alsa_card_rme32_init(void)
2033 {
2034         return pci_register_driver(&driver);
2035 }
2036
2037 static void __exit alsa_card_rme32_exit(void)
2038 {
2039         pci_unregister_driver(&driver);
2040 }
2041
2042 module_init(alsa_card_rme32_init)
2043 module_exit(alsa_card_rme32_exit)