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