Lines Matching +full:pcm +full:- +full:sync +full:- +full:mode
1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Copyright (c) 1999 IEM - Winfried Ritsch
6 * Copyright (c) 1999-2001 Paul Davis
19 #include <sound/pcm.h>
26 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
55 /* Preferred sync source choices - used by "sync_pref" control switch */
68 /* ------------- Status-Register bits --------------------- */
71 #define RME9652_lock_2 (1<<1) /* ADAT 3-PLL: 1=locked, 0=unlocked */
72 #define RME9652_lock_1 (1<<2) /* ADAT 2-PLL: 1=locked, 0=unlocked */
73 #define RME9652_lock_0 (1<<3) /* ADAT 1-PLL: 1=locked, 0=unlocked */
75 #define RME9652_wsel_rd (1<<5) /* if Word-Clock is used and valid then 1 */
76 /* bits 6-15 encode h/w buffer pointer position */
77 #define RME9652_sync_2 (1<<16) /* if ADAT-IN 3 in sync to system clock */
78 #define RME9652_sync_1 (1<<17) /* if ADAT-IN 2 in sync to system clock */
79 #define RME9652_sync_0 (1<<18) /* if ADAT-IN 1 in sync to system clock */
80 #define RME9652_DS_rd (1<<19) /* 1=Double Speed Mode, 0=Normal Speed */
81 #define RME9652_tc_busy (1<<20) /* 1=time-code copy in progress (960ms) */
82 #define RME9652_tc_out (1<<21) /* time-code out bit */
86 #define RME9652_ERF (1<<25) /* Error-Flag of SDPIF Receiver (1=No Lock) */
88 #define RME9652_tc_valid (1<<27) /* 1 = a signal is detected on time-code input */
120 /* Read-only registers */
128 /* --------- Control-Register Bits ---------------- */
132 /* bits 1-3 encode buffersize/latency */
133 #define RME9652_Master (1<<4) /* Clock Mode Master=1,Slave/Auto=0 */
140 #define RME9652_Dolby (1<<11) /* Non-audio bit 1=set, 0=unset */
142 #define RME9652_wsel (1<<13) /* use Wordclock as sync (overwrites master) */
143 #define RME9652_inp_0 (1<<14) /* SPDIF-IN: 00=optical (ADAT1), */
158 #define rme9652_running_double_speed(s) ((s)->control_register & RME9652_DS)
173 size is the same regardless of the number of channels - the
202 size_t hw_offsetmask; /* &-with status register to get real hw_offset */
209 unsigned char ss_channels; /* different for hammerfall/hammerfall-light */
227 int passthru; /* non-zero if doing pass-thru */
236 struct snd_pcm *pcm; member
259 /* channels 18-25 don't exist */
260 -1, -1, -1, -1, -1, -1, -1, -1
269 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
284 return snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, size); in snd_hammerfall_get_buffer()
301 writel(val, rme9652->iobase + reg); in rme9652_write()
306 return readl(rme9652->iobase + reg); in rme9652_read()
314 spin_lock_irqsave(&rme9652->lock, flags); in snd_rme9652_use_is_exclusive()
315 if ((rme9652->playback_pid != rme9652->capture_pid) && in snd_rme9652_use_is_exclusive()
316 (rme9652->playback_pid >= 0) && (rme9652->capture_pid >= 0)) { in snd_rme9652_use_is_exclusive()
319 spin_unlock_irqrestore(&rme9652->lock, flags); in snd_rme9652_use_is_exclusive()
338 i = rme9652->control_register & RME9652_latency; in rme9652_compute_period_size()
339 rme9652->period_bytes = 1 << ((rme9652_decode_latency(i) + 8)); in rme9652_compute_period_size()
340 rme9652->hw_offsetmask = in rme9652_compute_period_size()
341 (rme9652->period_bytes * 2 - 1) & RME9652_buf_pos; in rme9652_compute_period_size()
342 rme9652->max_jitter = 80; in rme9652_compute_period_size()
349 snd_pcm_uframes_t period_size = rme9652->period_bytes / 4; in rme9652_hw_pointer()
353 if (!rme9652->precise_ptr) in rme9652_hw_pointer()
361 delta = rme9652->prev_hw_offset - offset; in rme9652_hw_pointer()
363 if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4) in rme9652_hw_pointer()
364 offset = rme9652->prev_hw_offset; in rme9652_hw_pointer()
366 rme9652->prev_hw_offset = offset; in rme9652_hw_pointer()
367 offset &= rme9652->hw_offsetmask; in rme9652_hw_pointer()
372 if (offset > rme9652->max_jitter) { in rme9652_hw_pointer()
374 dev_err(rme9652->card->dev, in rme9652_hw_pointer()
379 offset -= rme9652->max_jitter; in rme9652_hw_pointer()
383 if (offset > period_size + rme9652->max_jitter) { in rme9652_hw_pointer()
385 dev_err(rme9652->card->dev, in rme9652_hw_pointer()
390 offset -= rme9652->max_jitter; in rme9652_hw_pointer()
402 them all to zero. Note that s->iobase is a pointer to in rme9652_reset_hw_pointer()
410 rme9652->prev_hw_offset = 0; in rme9652_reset_hw_pointer()
415 s->control_register |= (RME9652_IE | RME9652_start_bit); in rme9652_start()
416 rme9652_write(s, RME9652_control_register, s->control_register); in rme9652_start()
421 s->control_register &= ~(RME9652_start_bit | RME9652_IE); in rme9652_stop()
422 rme9652_write(s, RME9652_control_register, s->control_register); in rme9652_stop()
431 spin_lock_irq(&s->lock); in rme9652_set_interrupt_interval()
433 restart = s->running; in rme9652_set_interrupt_interval()
444 s->control_register &= ~RME9652_latency; in rme9652_set_interrupt_interval()
445 s->control_register |= rme9652_encode_latency(n); in rme9652_set_interrupt_interval()
447 rme9652_write(s, RME9652_control_register, s->control_register); in rme9652_set_interrupt_interval()
454 spin_unlock_irq(&s->lock); in rme9652_set_interrupt_interval()
466 return -EBUSY; in rme9652_set_rate()
476 exists for externally-driven rate changes. All we can do in rme9652_set_rate()
480 spin_lock_irq(&rme9652->lock); in rme9652_set_rate()
509 spin_unlock_irq(&rme9652->lock); in rme9652_set_rate()
510 return -EINVAL; in rme9652_set_rate()
513 if (reject_if_open && (rme9652->capture_pid >= 0 || rme9652->playback_pid >= 0)) { in rme9652_set_rate()
514 spin_unlock_irq(&rme9652->lock); in rme9652_set_rate()
515 return -EBUSY; in rme9652_set_rate()
518 restart = rme9652->running; in rme9652_set_rate()
521 rme9652->control_register &= ~(RME9652_freq | RME9652_DS); in rme9652_set_rate()
522 rme9652->control_register |= rate; in rme9652_set_rate()
523 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_rate()
529 if (rme9652->ss_channels == RME9652_NCHANNELS) { in rme9652_set_rate()
530 rme9652->channel_map = channel_map_9652_ds; in rme9652_set_rate()
532 rme9652->channel_map = channel_map_9636_ds; in rme9652_set_rate()
535 if (rme9652->ss_channels == RME9652_NCHANNELS) { in rme9652_set_rate()
536 rme9652->channel_map = channel_map_9652_ss; in rme9652_set_rate()
538 rme9652->channel_map = channel_map_9636_ss; in rme9652_set_rate()
542 spin_unlock_irq(&rme9652->lock); in rme9652_set_rate()
550 rme9652->passthru = 0; in rme9652_set_thru()
558 rme9652->thru_bits |= (1 << i); in rme9652_set_thru()
563 rme9652->thru_bits &= ~(1 << i); in rme9652_set_thru()
571 mapped_channel = rme9652->channel_map[channel]; in rme9652_set_thru()
574 rme9652->thru_bits |= (1 << mapped_channel); in rme9652_set_thru()
576 rme9652->thru_bits &= ~(1 << mapped_channel); in rme9652_set_thru()
588 rme9652_set_thru(rme9652, -1, 1); in rme9652_set_passthru()
594 rme9652->control_register = in rme9652_set_passthru()
602 rme9652->control_register); in rme9652_set_passthru()
603 rme9652->passthru = 1; in rme9652_set_passthru()
605 rme9652_set_thru(rme9652, -1, 0); in rme9652_set_passthru()
607 rme9652->passthru = 0; in rme9652_set_passthru()
616 rme9652->control_register |= mask; in rme9652_spdif_set_bit()
618 rme9652->control_register &= ~mask; in rme9652_spdif_set_bit()
620 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_spdif_set_bit()
688 rme9652->control_register |= RME9652_SPDIF_RESET; in rme9652_initialize_spdif_receiver()
700 return -1; /* error condition */ in rme9652_spdif_sample_rate()
703 if (s->hw_rev == 15) { in rme9652_spdif_sample_rate()
746 dev_err(s->card->dev, in rme9652_spdif_sample_rate()
748 s->card_name, rate_bits); in rme9652_spdif_sample_rate()
753 /*-----------------------------------------------------------------------------
755 ----------------------------------------------------------------------------*/
760 val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME9652_PRO : 0; in snd_rme9652_convert_from_aes()
761 val |= (aes->status[0] & IEC958_AES0_NONAUDIO) ? RME9652_Dolby : 0; in snd_rme9652_convert_from_aes()
763 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? RME9652_EMP : 0; in snd_rme9652_convert_from_aes()
765 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? RME9652_EMP : 0; in snd_rme9652_convert_from_aes()
771 aes->status[0] = ((val & RME9652_PRO) ? IEC958_AES0_PROFESSIONAL : 0) | in snd_rme9652_convert_to_aes()
774 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0; in snd_rme9652_convert_to_aes()
776 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0; in snd_rme9652_convert_to_aes()
781 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; in snd_rme9652_control_spdif_info()
782 uinfo->count = 1; in snd_rme9652_control_spdif_info()
790 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif); in snd_rme9652_control_spdif_get()
800 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958); in snd_rme9652_control_spdif_put()
801 spin_lock_irq(&rme9652->lock); in snd_rme9652_control_spdif_put()
802 change = val != rme9652->creg_spdif; in snd_rme9652_control_spdif_put()
803 rme9652->creg_spdif = val; in snd_rme9652_control_spdif_put()
804 spin_unlock_irq(&rme9652->lock); in snd_rme9652_control_spdif_put()
810 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; in snd_rme9652_control_spdif_stream_info()
811 uinfo->count = 1; in snd_rme9652_control_spdif_stream_info()
819 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif_stream); in snd_rme9652_control_spdif_stream_get()
829 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958); in snd_rme9652_control_spdif_stream_put()
830 spin_lock_irq(&rme9652->lock); in snd_rme9652_control_spdif_stream_put()
831 change = val != rme9652->creg_spdif_stream; in snd_rme9652_control_spdif_stream_put()
832 rme9652->creg_spdif_stream = val; in snd_rme9652_control_spdif_stream_put()
833 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP); in snd_rme9652_control_spdif_stream_put()
834 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= val); in snd_rme9652_control_spdif_stream_put()
835 spin_unlock_irq(&rme9652->lock); in snd_rme9652_control_spdif_stream_put()
841 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; in snd_rme9652_control_spdif_mask_info()
842 uinfo->count = 1; in snd_rme9652_control_spdif_mask_info()
848 ucontrol->value.iec958.status[0] = kcontrol->private_value; in snd_rme9652_control_spdif_mask_get()
860 if (rme9652->control_register & RME9652_ADAT1_INTERNAL) in rme9652_adat1_in()
870 rme9652->control_register |= RME9652_ADAT1_INTERNAL; in rme9652_set_adat1_input()
872 rme9652->control_register &= ~RME9652_ADAT1_INTERNAL; in rme9652_set_adat1_input()
877 restart = rme9652->running; in rme9652_set_adat1_input()
881 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_adat1_input()
900 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_adat1_in()
901 ucontrol->value.enumerated.item[0] = rme9652_adat1_in(rme9652); in snd_rme9652_get_adat1_in()
902 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_adat1_in()
913 return -EBUSY; in snd_rme9652_put_adat1_in()
914 val = ucontrol->value.enumerated.item[0] % 2; in snd_rme9652_put_adat1_in()
915 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_adat1_in()
919 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_adat1_in()
930 return rme9652_decode_spdif_in(rme9652->control_register & in rme9652_spdif_in()
938 rme9652->control_register &= ~RME9652_inp; in rme9652_set_spdif_input()
939 rme9652->control_register |= rme9652_encode_spdif_in(in); in rme9652_set_spdif_input()
941 restart = rme9652->running; in rme9652_set_spdif_input()
945 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_spdif_input()
964 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_spdif_in()
965 ucontrol->value.enumerated.item[0] = rme9652_spdif_in(rme9652); in snd_rme9652_get_spdif_in()
966 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_spdif_in()
977 return -EBUSY; in snd_rme9652_put_spdif_in()
978 val = ucontrol->value.enumerated.item[0] % 3; in snd_rme9652_put_spdif_in()
979 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_spdif_in()
983 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_spdif_in()
994 return (rme9652->control_register & RME9652_opt_out) ? 1 : 0; in rme9652_spdif_out()
1002 rme9652->control_register |= RME9652_opt_out; in rme9652_set_spdif_output()
1004 rme9652->control_register &= ~RME9652_opt_out; in rme9652_set_spdif_output()
1007 restart = rme9652->running; in rme9652_set_spdif_output()
1011 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_spdif_output()
1025 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_spdif_out()
1026 ucontrol->value.integer.value[0] = rme9652_spdif_out(rme9652); in snd_rme9652_get_spdif_out()
1027 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_spdif_out()
1038 return -EBUSY; in snd_rme9652_put_spdif_out()
1039 val = ucontrol->value.integer.value[0] & 1; in snd_rme9652_put_spdif_out()
1040 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_spdif_out()
1043 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_spdif_out()
1054 if (rme9652->control_register & RME9652_wsel) { in rme9652_sync_mode()
1056 } else if (rme9652->control_register & RME9652_Master) { in rme9652_sync_mode()
1063 static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode) in rme9652_set_sync_mode() argument
1067 switch (mode) { in rme9652_set_sync_mode()
1069 rme9652->control_register &= in rme9652_set_sync_mode()
1073 rme9652->control_register = in rme9652_set_sync_mode()
1074 (rme9652->control_register & ~RME9652_wsel) | RME9652_Master; in rme9652_set_sync_mode()
1077 rme9652->control_register |= in rme9652_set_sync_mode()
1082 restart = rme9652->running; in rme9652_set_sync_mode()
1086 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_sync_mode()
1107 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_sync_mode()
1108 ucontrol->value.enumerated.item[0] = rme9652_sync_mode(rme9652); in snd_rme9652_get_sync_mode()
1109 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_sync_mode()
1119 val = ucontrol->value.enumerated.item[0] % 3; in snd_rme9652_put_sync_mode()
1120 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_sync_mode()
1123 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_sync_mode()
1134 switch (rme9652->control_register & RME9652_SyncPref_Mask) { in rme9652_sync_pref()
1152 rme9652->control_register &= ~RME9652_SyncPref_Mask; in rme9652_set_sync_pref()
1155 rme9652->control_register |= RME9652_SyncPref_ADAT1; in rme9652_set_sync_pref()
1158 rme9652->control_register |= RME9652_SyncPref_ADAT2; in rme9652_set_sync_pref()
1161 rme9652->control_register |= RME9652_SyncPref_ADAT3; in rme9652_set_sync_pref()
1164 rme9652->control_register |= RME9652_SyncPref_SPDIF; in rme9652_set_sync_pref()
1168 restart = rme9652->running; in rme9652_set_sync_pref()
1172 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in rme9652_set_sync_pref()
1188 rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3, in snd_rme9652_info_sync_pref()
1196 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_sync_pref()
1197 ucontrol->value.enumerated.item[0] = rme9652_sync_pref(rme9652); in snd_rme9652_get_sync_pref()
1198 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_sync_pref()
1209 return -EBUSY; in snd_rme9652_put_sync_pref()
1210 max = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3; in snd_rme9652_put_sync_pref()
1211 val = ucontrol->value.enumerated.item[0] % max; in snd_rme9652_put_sync_pref()
1212 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_sync_pref()
1215 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_sync_pref()
1222 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; in snd_rme9652_info_thru()
1223 uinfo->count = rme9652->ss_channels; in snd_rme9652_info_thru()
1224 uinfo->value.integer.min = 0; in snd_rme9652_info_thru()
1225 uinfo->value.integer.max = 1; in snd_rme9652_info_thru()
1233 u32 thru_bits = rme9652->thru_bits; in snd_rme9652_get_thru()
1235 for (k = 0; k < rme9652->ss_channels; ++k) { in snd_rme9652_get_thru()
1236 ucontrol->value.integer.value[k] = !!(thru_bits & (1 << k)); in snd_rme9652_get_thru()
1249 return -EBUSY; in snd_rme9652_put_thru()
1251 for (chn = 0; chn < rme9652->ss_channels; ++chn) { in snd_rme9652_put_thru()
1252 if (ucontrol->value.integer.value[chn]) in snd_rme9652_put_thru()
1256 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_thru()
1257 change = thru_bits ^ rme9652->thru_bits; in snd_rme9652_put_thru()
1259 for (chn = 0; chn < rme9652->ss_channels; ++chn) { in snd_rme9652_put_thru()
1265 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_thru()
1281 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_passthru()
1282 ucontrol->value.integer.value[0] = rme9652->passthru; in snd_rme9652_get_passthru()
1283 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_passthru()
1295 return -EBUSY; in snd_rme9652_put_passthru()
1297 val = ucontrol->value.integer.value[0] & 1; in snd_rme9652_put_passthru()
1298 spin_lock_irq(&rme9652->lock); in snd_rme9652_put_passthru()
1299 change = (ucontrol->value.integer.value[0] != rme9652->passthru); in snd_rme9652_put_passthru()
1302 spin_unlock_irq(&rme9652->lock); in snd_rme9652_put_passthru()
1306 /* Read-only switches */
1316 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; in snd_rme9652_info_spdif_rate()
1317 uinfo->count = 1; in snd_rme9652_info_spdif_rate()
1318 uinfo->value.integer.min = 0; in snd_rme9652_info_spdif_rate()
1319 uinfo->value.integer.max = 96000; in snd_rme9652_info_spdif_rate()
1327 spin_lock_irq(&rme9652->lock); in snd_rme9652_get_spdif_rate()
1328 ucontrol->value.integer.value[0] = rme9652_spdif_sample_rate(rme9652); in snd_rme9652_get_spdif_rate()
1329 spin_unlock_irq(&rme9652->lock); in snd_rme9652_get_spdif_rate()
1342 "No Lock", "Lock", "No Lock Sync", "Lock Sync" in snd_rme9652_info_adat_sync()
1353 switch (kcontrol->private_value) { in snd_rme9652_get_adat_sync()
1357 default: return -EINVAL; in snd_rme9652_get_adat_sync()
1360 ucontrol->value.enumerated.item[0] = (val & mask1) ? 1 : 0; in snd_rme9652_get_adat_sync()
1361 ucontrol->value.enumerated.item[0] |= (val & mask2) ? 2 : 0; in snd_rme9652_get_adat_sync()
1377 ucontrol->value.integer.value[0] = in snd_rme9652_get_tc_valid()
1384 /* FIXME: this routine needs a port to the new control API --jk */
1394 uswitch->type = SNDRV_SW_TYPE_DWORD; in snd_rme9652_get_tc_value()
1398 uswitch->value.data32[0] = 0; in snd_rme9652_get_tc_value()
1406 /* XXX bug alert: loop-based timing !!!! */ in snd_rme9652_get_tc_value()
1414 return -EIO; in snd_rme9652_get_tc_value()
1427 value -= 2 * 60 * 48000; in snd_rme9652_get_tc_value()
1432 uswitch->value.data32[0] = value; in snd_rme9652_get_tc_value()
1477 RME9652_SYNC_MODE("Sync Mode", 0),
1478 RME9652_SYNC_PREF("Preferred Sync Source", 0),
1488 RME9652_ADAT_SYNC("ADAT1 Sync Check", 0, 0),
1489 RME9652_ADAT_SYNC("ADAT2 Sync Check", 0, 1),
1495 RME9652_ADAT_SYNC("ADAT3 Sync Check", 0, 2);
1512 rme9652->spdif_ctl = kctl; in snd_rme9652_create_controls()
1515 if (rme9652->ss_channels == RME9652_NCHANNELS) { in snd_rme9652_create_controls()
1522 if (rme9652->hw_rev >= 15) { in snd_rme9652_create_controls()
1532 /*------------------------------------------------------------
1534 ------------------------------------------------------------*/
1539 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data; in snd_rme9652_proc_read()
1540 u32 thru_bits = rme9652->thru_bits; in snd_rme9652_proc_read()
1548 snd_iprintf(buffer, "%s (Card #%d)\n", rme9652->card_name, rme9652->card->number + 1); in snd_rme9652_proc_read()
1550 rme9652->capture_buffer, rme9652->playback_buffer); in snd_rme9652_proc_read()
1552 rme9652->irq, rme9652->port, (unsigned long)rme9652->iobase); in snd_rme9652_proc_read()
1553 snd_iprintf(buffer, "Control register: %x\n", rme9652->control_register); in snd_rme9652_proc_read()
1557 x = 1 << (6 + rme9652_decode_latency(rme9652->control_register & in snd_rme9652_proc_read()
1561 x, (unsigned long) rme9652->period_bytes); in snd_rme9652_proc_read()
1564 snd_iprintf(buffer, "Passthru: %s\n", str_yes_no(rme9652->passthru)); in snd_rme9652_proc_read()
1566 if ((rme9652->control_register & (RME9652_Master | RME9652_wsel)) == 0) { in snd_rme9652_proc_read()
1567 snd_iprintf(buffer, "Clock mode: autosync\n"); in snd_rme9652_proc_read()
1569 } else if (rme9652->control_register & RME9652_wsel) { in snd_rme9652_proc_read()
1571 snd_iprintf(buffer, "Clock mode: word clock\n"); in snd_rme9652_proc_read()
1573 snd_iprintf(buffer, "Clock mode: word clock (no signal)\n"); in snd_rme9652_proc_read()
1576 snd_iprintf(buffer, "Clock mode: master\n"); in snd_rme9652_proc_read()
1580 switch (rme9652->control_register & RME9652_SyncPref_Mask) { in snd_rme9652_proc_read()
1582 snd_iprintf(buffer, "Pref. sync source: ADAT1\n"); in snd_rme9652_proc_read()
1585 snd_iprintf(buffer, "Pref. sync source: ADAT2\n"); in snd_rme9652_proc_read()
1588 snd_iprintf(buffer, "Pref. sync source: ADAT3\n"); in snd_rme9652_proc_read()
1591 snd_iprintf(buffer, "Pref. sync source: IEC958\n"); in snd_rme9652_proc_read()
1594 snd_iprintf(buffer, "Pref. sync source: ???\n"); in snd_rme9652_proc_read()
1598 if (rme9652->hw_rev >= 15) in snd_rme9652_proc_read()
1600 (rme9652->control_register & RME9652_ADAT1_INTERNAL) ? in snd_rme9652_proc_read()
1605 switch (rme9652_decode_spdif_in(rme9652->control_register & in snd_rme9652_proc_read()
1621 if (rme9652->control_register & RME9652_opt_out) { in snd_rme9652_proc_read()
1627 if (rme9652->control_register & RME9652_PRO) { in snd_rme9652_proc_read()
1633 if (rme9652->control_register & RME9652_EMP) { in snd_rme9652_proc_read()
1639 if (rme9652->control_register & RME9652_Dolby) { in snd_rme9652_proc_read()
1661 /* Sync Check */ in snd_rme9652_proc_read()
1665 snd_iprintf(buffer, "ADAT1: %s\n", x ? "Sync" : "Lock"); in snd_rme9652_proc_read()
1672 snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock"); in snd_rme9652_proc_read()
1679 snd_iprintf(buffer, "ADAT3: %s\n", x ? "Sync" : "Lock"); in snd_rme9652_proc_read()
1693 for (i = 0; i < rme9652->ss_channels; i++) { in snd_rme9652_proc_read()
1710 snd_card_ro_proc_new(rme9652->card, "rme9652", rme9652, in snd_rme9652_proc_init()
1716 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data; in snd_rme9652_card_free()
1718 if (rme9652->irq >= 0) in snd_rme9652_card_free()
1726 capture_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES); in snd_rme9652_initialize_memory()
1727 playback_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES); in snd_rme9652_initialize_memory()
1729 dev_err(rme9652->card->dev, in snd_rme9652_initialize_memory()
1730 "%s: no buffers available\n", rme9652->card_name); in snd_rme9652_initialize_memory()
1731 return -ENOMEM; in snd_rme9652_initialize_memory()
1735 rme9652->capture_dma_buf = *capture_dma; in snd_rme9652_initialize_memory()
1736 rme9652->playback_dma_buf = *playback_dma; in snd_rme9652_initialize_memory()
1738 /* Align to bus-space 64K boundary */ in snd_rme9652_initialize_memory()
1739 rme9652->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul); in snd_rme9652_initialize_memory()
1740 rme9652->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul); in snd_rme9652_initialize_memory()
1743 rme9652_write(rme9652, RME9652_rec_buffer, rme9652->capture_dma_buf.addr); in snd_rme9652_initialize_memory()
1744 rme9652_write(rme9652, RME9652_play_buffer, rme9652->playback_dma_buf.addr); in snd_rme9652_initialize_memory()
1746 rme9652->capture_dma_buf.area += rme9652->capture_dma_buf.addr - capture_dma->addr; in snd_rme9652_initialize_memory()
1747 rme9652->playback_dma_buf.area += rme9652->playback_dma_buf.addr - playback_dma->addr; in snd_rme9652_initialize_memory()
1748 rme9652->capture_buffer = rme9652->capture_dma_buf.area; in snd_rme9652_initialize_memory()
1749 rme9652->playback_buffer = rme9652->playback_dma_buf.area; in snd_rme9652_initialize_memory()
1758 /* ASSUMPTION: rme9652->lock is either held, or in snd_rme9652_set_defaults()
1766 autosync clock mode in snd_rme9652_set_defaults()
1774 rme9652->control_register = in snd_rme9652_set_defaults()
1777 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); in snd_rme9652_set_defaults()
1787 rme9652->thru_bits = 0; in snd_rme9652_set_defaults()
1788 rme9652->passthru = 0; in snd_rme9652_set_defaults()
1805 if (rme9652->capture_substream) { in snd_rme9652_interrupt()
1806 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream); in snd_rme9652_interrupt()
1809 if (rme9652->playback_substream) { in snd_rme9652_interrupt()
1810 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream); in snd_rme9652_interrupt()
1831 mapped_channel = rme9652->channel_map[channel]; in rme9652_channel_buffer_location()
1836 return rme9652->capture_buffer + in rme9652_channel_buffer_location()
1839 return rme9652->playback_buffer + in rme9652_channel_buffer_location()
1852 return -EINVAL; in snd_rme9652_playback_copy()
1855 substream->pstr->stream, in snd_rme9652_playback_copy()
1858 return -EIO; in snd_rme9652_playback_copy()
1860 return -EFAULT; in snd_rme9652_playback_copy()
1872 return -EINVAL; in snd_rme9652_capture_copy()
1875 substream->pstr->stream, in snd_rme9652_capture_copy()
1878 return -EIO; in snd_rme9652_capture_copy()
1880 return -EFAULT; in snd_rme9652_capture_copy()
1892 substream->pstr->stream, in snd_rme9652_hw_silence()
1895 return -EIO; in snd_rme9652_hw_silence()
1902 struct snd_pcm_runtime *runtime = substream->runtime; in snd_rme9652_reset()
1905 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in snd_rme9652_reset()
1906 other = rme9652->capture_substream; in snd_rme9652_reset()
1908 other = rme9652->playback_substream; in snd_rme9652_reset()
1909 if (rme9652->running) in snd_rme9652_reset()
1910 runtime->status->hw_ptr = rme9652_hw_pointer(rme9652); in snd_rme9652_reset()
1912 runtime->status->hw_ptr = 0; in snd_rme9652_reset()
1915 struct snd_pcm_runtime *oruntime = other->runtime; in snd_rme9652_reset()
1918 oruntime->status->hw_ptr = runtime->status->hw_ptr; in snd_rme9652_reset()
1934 spin_lock_irq(&rme9652->lock); in snd_rme9652_hw_params()
1936 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) { in snd_rme9652_hw_params()
1937 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP); in snd_rme9652_hw_params()
1938 …rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= rme9652->creg_spdif_… in snd_rme9652_hw_params()
1939 this_pid = rme9652->playback_pid; in snd_rme9652_hw_params()
1940 other_pid = rme9652->capture_pid; in snd_rme9652_hw_params()
1942 this_pid = rme9652->capture_pid; in snd_rme9652_hw_params()
1943 other_pid = rme9652->playback_pid; in snd_rme9652_hw_params()
1955 spin_unlock_irq(&rme9652->lock); in snd_rme9652_hw_params()
1957 return -EBUSY; in snd_rme9652_hw_params()
1960 if (params_period_size(params) != rme9652->period_bytes / 4) { in snd_rme9652_hw_params()
1961 spin_unlock_irq(&rme9652->lock); in snd_rme9652_hw_params()
1963 return -EBUSY; in snd_rme9652_hw_params()
1968 spin_unlock_irq(&rme9652->lock); in snd_rme9652_hw_params()
1972 spin_unlock_irq(&rme9652->lock); in snd_rme9652_hw_params()
1975 /* how to make sure that the rate matches an externally-set one ? in snd_rme9652_hw_params()
1999 if (snd_BUG_ON(info->channel >= RME9652_NCHANNELS)) in snd_rme9652_channel_info()
2000 return -EINVAL; in snd_rme9652_channel_info()
2002 chn = rme9652->channel_map[array_index_nospec(info->channel, in snd_rme9652_channel_info()
2005 return -EINVAL; in snd_rme9652_channel_info()
2007 info->offset = chn * RME9652_CHANNEL_BUFFER_BYTES; in snd_rme9652_channel_info()
2008 info->first = 0; in snd_rme9652_channel_info()
2009 info->step = 32; in snd_rme9652_channel_info()
2035 memset(rme9652->playback_buffer, 0, RME9652_DMA_AREA_BYTES); in rme9652_silence_playback()
2044 spin_lock(&rme9652->lock); in snd_rme9652_trigger()
2045 running = rme9652->running; in snd_rme9652_trigger()
2048 running |= 1 << substream->stream; in snd_rme9652_trigger()
2051 running &= ~(1 << substream->stream); in snd_rme9652_trigger()
2055 spin_unlock(&rme9652->lock); in snd_rme9652_trigger()
2056 return -EINVAL; in snd_rme9652_trigger()
2058 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in snd_rme9652_trigger()
2059 other = rme9652->capture_substream; in snd_rme9652_trigger()
2061 other = rme9652->playback_substream; in snd_rme9652_trigger()
2069 running |= 1 << s->stream; in snd_rme9652_trigger()
2071 running &= ~(1 << s->stream); in snd_rme9652_trigger()
2077 substream->stream == SNDRV_PCM_STREAM_CAPTURE) in snd_rme9652_trigger()
2081 substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in snd_rme9652_trigger()
2085 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) in snd_rme9652_trigger()
2090 if (!rme9652->running && running) in snd_rme9652_trigger()
2092 else if (rme9652->running && !running) in snd_rme9652_trigger()
2094 rme9652->running = running; in snd_rme9652_trigger()
2095 spin_unlock(&rme9652->lock); in snd_rme9652_trigger()
2105 spin_lock_irqsave(&rme9652->lock, flags); in snd_rme9652_prepare()
2106 if (!rme9652->running) in snd_rme9652_prepare()
2108 spin_unlock_irqrestore(&rme9652->lock, flags); in snd_rme9652_prepare()
2170 struct snd_rme9652 *rme9652 = rule->private; in snd_rme9652_hw_rule_channels()
2172 unsigned int list[2] = { rme9652->ds_channels, rme9652->ss_channels }; in snd_rme9652_hw_rule_channels()
2179 struct snd_rme9652 *rme9652 = rule->private; in snd_rme9652_hw_rule_channels_rate()
2182 if (r->min > 48000) { in snd_rme9652_hw_rule_channels_rate()
2184 .min = rme9652->ds_channels, in snd_rme9652_hw_rule_channels_rate()
2185 .max = rme9652->ds_channels, in snd_rme9652_hw_rule_channels_rate()
2189 } else if (r->max < 88200) { in snd_rme9652_hw_rule_channels_rate()
2191 .min = rme9652->ss_channels, in snd_rme9652_hw_rule_channels_rate()
2192 .max = rme9652->ss_channels, in snd_rme9652_hw_rule_channels_rate()
2203 struct snd_rme9652 *rme9652 = rule->private; in snd_rme9652_hw_rule_rate_channels()
2206 if (c->min >= rme9652->ss_channels) { in snd_rme9652_hw_rule_rate_channels()
2213 } else if (c->max <= rme9652->ds_channels) { in snd_rme9652_hw_rule_rate_channels()
2227 struct snd_pcm_runtime *runtime = substream->runtime; in snd_rme9652_playback_open()
2229 spin_lock_irq(&rme9652->lock); in snd_rme9652_playback_open()
2233 runtime->hw = snd_rme9652_playback_subinfo; in snd_rme9652_playback_open()
2234 snd_pcm_set_runtime_buffer(substream, &rme9652->playback_dma_buf); in snd_rme9652_playback_open()
2236 if (rme9652->capture_substream == NULL) { in snd_rme9652_playback_open()
2238 rme9652_set_thru(rme9652, -1, 0); in snd_rme9652_playback_open()
2241 rme9652->playback_pid = current->pid; in snd_rme9652_playback_open()
2242 rme9652->playback_substream = substream; in snd_rme9652_playback_open()
2244 spin_unlock_irq(&rme9652->lock); in snd_rme9652_playback_open()
2250 SNDRV_PCM_HW_PARAM_CHANNELS, -1); in snd_rme9652_playback_open()
2253 SNDRV_PCM_HW_PARAM_RATE, -1); in snd_rme9652_playback_open()
2256 SNDRV_PCM_HW_PARAM_CHANNELS, -1); in snd_rme9652_playback_open()
2258 rme9652->creg_spdif_stream = rme9652->creg_spdif; in snd_rme9652_playback_open()
2259 rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; in snd_rme9652_playback_open()
2260 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE | in snd_rme9652_playback_open()
2261 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id); in snd_rme9652_playback_open()
2269 spin_lock_irq(&rme9652->lock); in snd_rme9652_playback_release()
2271 rme9652->playback_pid = -1; in snd_rme9652_playback_release()
2272 rme9652->playback_substream = NULL; in snd_rme9652_playback_release()
2274 spin_unlock_irq(&rme9652->lock); in snd_rme9652_playback_release()
2276 rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; in snd_rme9652_playback_release()
2277 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE | in snd_rme9652_playback_release()
2278 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id); in snd_rme9652_playback_release()
2286 struct snd_pcm_runtime *runtime = substream->runtime; in snd_rme9652_capture_open()
2288 spin_lock_irq(&rme9652->lock); in snd_rme9652_capture_open()
2292 runtime->hw = snd_rme9652_capture_subinfo; in snd_rme9652_capture_open()
2293 snd_pcm_set_runtime_buffer(substream, &rme9652->capture_dma_buf); in snd_rme9652_capture_open()
2295 if (rme9652->playback_substream == NULL) { in snd_rme9652_capture_open()
2297 rme9652_set_thru(rme9652, -1, 0); in snd_rme9652_capture_open()
2300 rme9652->capture_pid = current->pid; in snd_rme9652_capture_open()
2301 rme9652->capture_substream = substream; in snd_rme9652_capture_open()
2303 spin_unlock_irq(&rme9652->lock); in snd_rme9652_capture_open()
2309 SNDRV_PCM_HW_PARAM_CHANNELS, -1); in snd_rme9652_capture_open()
2312 SNDRV_PCM_HW_PARAM_RATE, -1); in snd_rme9652_capture_open()
2315 SNDRV_PCM_HW_PARAM_CHANNELS, -1); in snd_rme9652_capture_open()
2323 spin_lock_irq(&rme9652->lock); in snd_rme9652_capture_release()
2325 rme9652->capture_pid = -1; in snd_rme9652_capture_release()
2326 rme9652->capture_substream = NULL; in snd_rme9652_capture_release()
2328 spin_unlock_irq(&rme9652->lock); in snd_rme9652_capture_release()
2358 struct snd_pcm *pcm; in snd_rme9652_create_pcm() local
2361 err = snd_pcm_new(card, rme9652->card_name, 0, 1, 1, &pcm); in snd_rme9652_create_pcm()
2365 rme9652->pcm = pcm; in snd_rme9652_create_pcm()
2366 pcm->private_data = rme9652; in snd_rme9652_create_pcm()
2367 strcpy(pcm->name, rme9652->card_name); in snd_rme9652_create_pcm()
2369 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_rme9652_playback_ops); in snd_rme9652_create_pcm()
2370 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_rme9652_capture_ops); in snd_rme9652_create_pcm()
2372 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; in snd_rme9652_create_pcm()
2381 struct pci_dev *pci = rme9652->pci; in snd_rme9652_create()
2386 rme9652->irq = -1; in snd_rme9652_create()
2387 rme9652->card = card; in snd_rme9652_create()
2389 pci_read_config_word(rme9652->pci, PCI_CLASS_REVISION, &rev); in snd_rme9652_create()
2400 return -ENODEV; in snd_rme9652_create()
2407 spin_lock_init(&rme9652->lock); in snd_rme9652_create()
2412 rme9652->port = pci_resource_start(pci, 0); in snd_rme9652_create()
2413 rme9652->iobase = devm_ioremap(&pci->dev, rme9652->port, RME9652_IO_EXTENT); in snd_rme9652_create()
2414 if (rme9652->iobase == NULL) { in snd_rme9652_create()
2415 dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n", in snd_rme9652_create()
2416 rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1); in snd_rme9652_create()
2417 return -EBUSY; in snd_rme9652_create()
2420 if (devm_request_irq(&pci->dev, pci->irq, snd_rme9652_interrupt, in snd_rme9652_create()
2422 dev_err(card->dev, "unable to request IRQ %d\n", pci->irq); in snd_rme9652_create()
2423 return -EBUSY; in snd_rme9652_create()
2425 rme9652->irq = pci->irq; in snd_rme9652_create()
2426 card->sync_irq = rme9652->irq; in snd_rme9652_create()
2427 rme9652->precise_ptr = precise_ptr; in snd_rme9652_create()
2436 rme9652->hw_rev = 15; in snd_rme9652_create()
2438 rme9652->hw_rev = 11; in snd_rme9652_create()
2450 strcpy(card->driver, "RME9636"); in snd_rme9652_create()
2451 if (rme9652->hw_rev == 15) { in snd_rme9652_create()
2452 rme9652->card_name = "RME Digi9636 (Rev 1.5)"; in snd_rme9652_create()
2454 rme9652->card_name = "RME Digi9636"; in snd_rme9652_create()
2456 rme9652->ss_channels = RME9636_NCHANNELS; in snd_rme9652_create()
2459 strcpy(card->driver, "RME9636"); in snd_rme9652_create()
2460 rme9652->card_name = "RME Digi9636 (Rev G)"; in snd_rme9652_create()
2461 rme9652->ss_channels = RME9636_NCHANNELS; in snd_rme9652_create()
2464 strcpy(card->driver, "RME9652"); in snd_rme9652_create()
2465 rme9652->card_name = "RME Digi9652 (Rev G)"; in snd_rme9652_create()
2466 rme9652->ss_channels = RME9652_NCHANNELS; in snd_rme9652_create()
2469 strcpy(card->driver, "RME9652"); in snd_rme9652_create()
2470 if (rme9652->hw_rev == 15) { in snd_rme9652_create()
2471 rme9652->card_name = "RME Digi9652 (Rev 1.5)"; in snd_rme9652_create()
2473 rme9652->card_name = "RME Digi9652"; in snd_rme9652_create()
2475 rme9652->ss_channels = RME9652_NCHANNELS; in snd_rme9652_create()
2479 rme9652->ds_channels = (rme9652->ss_channels - 2) / 2 + 2; in snd_rme9652_create()
2481 pci_set_master(rme9652->pci); in snd_rme9652_create()
2497 rme9652->last_spdif_sample_rate = -1; in snd_rme9652_create()
2498 rme9652->last_adat_sample_rate = -1; in snd_rme9652_create()
2499 rme9652->playback_pid = -1; in snd_rme9652_create()
2500 rme9652->capture_pid = -1; in snd_rme9652_create()
2501 rme9652->capture_substream = NULL; in snd_rme9652_create()
2502 rme9652->playback_substream = NULL; in snd_rme9652_create()
2506 if (rme9652->hw_rev == 15) { in snd_rme9652_create()
2522 return -ENODEV; in snd_rme9652_probe()
2525 return -ENOENT; in snd_rme9652_probe()
2528 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, in snd_rme9652_probe()
2534 rme9652 = (struct snd_rme9652 *) card->private_data; in snd_rme9652_probe()
2535 card->private_free = snd_rme9652_card_free; in snd_rme9652_probe()
2536 rme9652->dev = dev; in snd_rme9652_probe()
2537 rme9652->pci = pci; in snd_rme9652_probe()
2542 strcpy(card->shortname, rme9652->card_name); in snd_rme9652_probe()
2544 sprintf(card->longname, "%s at 0x%lx, irq %d", in snd_rme9652_probe()
2545 card->shortname, rme9652->port, rme9652->irq); in snd_rme9652_probe()