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