Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/sound/pci/rme9652/rme9652.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us