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;
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);
301 writel(val, rme9652->iobase + reg);
306 return readl(rme9652->iobase + reg);
311 guard(spinlock_irqsave)(&rme9652->lock);
312 if ((rme9652->playback_pid != rme9652->capture_pid) &&
313 (rme9652->playback_pid >= 0) && (rme9652->capture_pid >= 0))
333 i = rme9652->control_register & RME9652_latency;
334 rme9652->period_bytes = 1 << ((rme9652_decode_latency(i) + 8));
335 rme9652->hw_offsetmask =
336 (rme9652->period_bytes * 2 - 1) & RME9652_buf_pos;
337 rme9652->max_jitter = 80;
344 snd_pcm_uframes_t period_size = rme9652->period_bytes / 4;
348 if (!rme9652->precise_ptr)
356 delta = rme9652->prev_hw_offset - offset;
358 if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4)
359 offset = rme9652->prev_hw_offset;
361 rme9652->prev_hw_offset = offset;
362 offset &= rme9652->hw_offsetmask;
367 if (offset > rme9652->max_jitter) {
369 dev_err(rme9652->card->dev,
374 offset -= rme9652->max_jitter;
378 if (offset > period_size + rme9652->max_jitter) {
380 dev_err(rme9652->card->dev,
385 offset -= rme9652->max_jitter;
397 them all to zero. Note that s->iobase is a pointer to
405 rme9652->prev_hw_offset = 0;
410 s->control_register |= (RME9652_IE | RME9652_start_bit);
411 rme9652_write(s, RME9652_control_register, s->control_register);
416 s->control_register &= ~(RME9652_start_bit | RME9652_IE);
417 rme9652_write(s, RME9652_control_register, s->control_register);
426 guard(spinlock_irq)(&s->lock);
428 restart = s->running;
439 s->control_register &= ~RME9652_latency;
440 s->control_register |= rme9652_encode_latency(n);
442 rme9652_write(s, RME9652_control_register, s->control_register);
459 return -EBUSY;
469 exists for externally-driven rate changes. All we can do
473 guard(spinlock_irq)(&rme9652->lock);
502 return -EINVAL;
505 if (reject_if_open && (rme9652->capture_pid >= 0 || rme9652->playback_pid >= 0))
506 return -EBUSY;
508 restart = rme9652->running;
511 rme9652->control_register &= ~(RME9652_freq | RME9652_DS);
512 rme9652->control_register |= rate;
513 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
519 if (rme9652->ss_channels == RME9652_NCHANNELS) {
520 rme9652->channel_map = channel_map_9652_ds;
522 rme9652->channel_map = channel_map_9636_ds;
525 if (rme9652->ss_channels == RME9652_NCHANNELS) {
526 rme9652->channel_map = channel_map_9652_ss;
528 rme9652->channel_map = channel_map_9636_ss;
539 rme9652->passthru = 0;
547 rme9652->thru_bits |= (1 << i);
552 rme9652->thru_bits &= ~(1 << i);
560 mapped_channel = rme9652->channel_map[channel];
563 rme9652->thru_bits |= (1 << mapped_channel);
565 rme9652->thru_bits &= ~(1 << mapped_channel);
577 rme9652_set_thru(rme9652, -1, 1);
583 rme9652->control_register =
591 rme9652->control_register);
592 rme9652->passthru = 1;
594 rme9652_set_thru(rme9652, -1, 0);
596 rme9652->passthru = 0;
605 rme9652->control_register |= mask;
607 rme9652->control_register &= ~mask;
609 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
677 rme9652->control_register |= RME9652_SPDIF_RESET;
689 return -1; /* error condition */
692 if (s->hw_rev == 15) {
735 dev_err(s->card->dev,
737 s->card_name, rate_bits);
742 /*-----------------------------------------------------------------------------
744 ----------------------------------------------------------------------------*/
749 val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME9652_PRO : 0;
750 val |= (aes->status[0] & IEC958_AES0_NONAUDIO) ? RME9652_Dolby : 0;
752 val |= (aes->status[0] & IEC958_AES0_PRO_EMPHASIS_5015) ? RME9652_EMP : 0;
754 val |= (aes->status[0] & IEC958_AES0_CON_EMPHASIS_5015) ? RME9652_EMP : 0;
760 aes->status[0] = ((val & RME9652_PRO) ? IEC958_AES0_PROFESSIONAL : 0) |
763 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_PRO_EMPHASIS_5015 : 0;
765 aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0;
770 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
771 uinfo->count = 1;
779 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif);
789 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958);
790 guard(spinlock_irq)(&rme9652->lock);
791 change = val != rme9652->creg_spdif;
792 rme9652->creg_spdif = val;
798 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
799 uinfo->count = 1;
807 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif_stream);
817 val = snd_rme9652_convert_from_aes(&ucontrol->value.iec958);
818 guard(spinlock_irq)(&rme9652->lock);
819 change = val != rme9652->creg_spdif_stream;
820 rme9652->creg_spdif_stream = val;
821 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
822 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= val);
828 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
829 uinfo->count = 1;
835 ucontrol->value.iec958.status[0] = kcontrol->private_value;
847 if (rme9652->control_register & RME9652_ADAT1_INTERNAL)
857 rme9652->control_register |= RME9652_ADAT1_INTERNAL;
859 rme9652->control_register &= ~RME9652_ADAT1_INTERNAL;
864 restart = rme9652->running;
868 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
887 guard(spinlock_irq)(&rme9652->lock);
888 ucontrol->value.enumerated.item[0] = rme9652_adat1_in(rme9652);
899 return -EBUSY;
900 val = ucontrol->value.enumerated.item[0] % 2;
901 guard(spinlock_irq)(&rme9652->lock);
915 return rme9652_decode_spdif_in(rme9652->control_register &
923 rme9652->control_register &= ~RME9652_inp;
924 rme9652->control_register |= rme9652_encode_spdif_in(in);
926 restart = rme9652->running;
930 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
949 guard(spinlock_irq)(&rme9652->lock);
950 ucontrol->value.enumerated.item[0] = rme9652_spdif_in(rme9652);
961 return -EBUSY;
962 val = ucontrol->value.enumerated.item[0] % 3;
963 guard(spinlock_irq)(&rme9652->lock);
977 return (rme9652->control_register & RME9652_opt_out) ? 1 : 0;
985 rme9652->control_register |= RME9652_opt_out;
987 rme9652->control_register &= ~RME9652_opt_out;
990 restart = rme9652->running;
994 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1008 guard(spinlock_irq)(&rme9652->lock);
1009 ucontrol->value.integer.value[0] = rme9652_spdif_out(rme9652);
1020 return -EBUSY;
1021 val = ucontrol->value.integer.value[0] & 1;
1022 guard(spinlock_irq)(&rme9652->lock);
1035 if (rme9652->control_register & RME9652_wsel) {
1037 } else if (rme9652->control_register & RME9652_Master) {
1044 static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode)
1048 switch (mode) {
1050 rme9652->control_register &=
1054 rme9652->control_register =
1055 (rme9652->control_register & ~RME9652_wsel) | RME9652_Master;
1058 rme9652->control_register |=
1063 restart = rme9652->running;
1067 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1088 guard(spinlock_irq)(&rme9652->lock);
1089 ucontrol->value.enumerated.item[0] = rme9652_sync_mode(rme9652);
1099 val = ucontrol->value.enumerated.item[0] % 3;
1100 guard(spinlock_irq)(&rme9652->lock);
1113 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1131 rme9652->control_register &= ~RME9652_SyncPref_Mask;
1134 rme9652->control_register |= RME9652_SyncPref_ADAT1;
1137 rme9652->control_register |= RME9652_SyncPref_ADAT2;
1140 rme9652->control_register |= RME9652_SyncPref_ADAT3;
1143 rme9652->control_register |= RME9652_SyncPref_SPDIF;
1147 restart = rme9652->running;
1151 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1167 rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3,
1175 guard(spinlock_irq)(&rme9652->lock);
1176 ucontrol->value.enumerated.item[0] = rme9652_sync_pref(rme9652);
1187 return -EBUSY;
1188 max = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3;
1189 val = ucontrol->value.enumerated.item[0] % max;
1190 guard(spinlock_irq)(&rme9652->lock);
1199 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1200 uinfo->count = rme9652->ss_channels;
1201 uinfo->value.integer.min = 0;
1202 uinfo->value.integer.max = 1;
1210 u32 thru_bits = rme9652->thru_bits;
1212 for (k = 0; k < rme9652->ss_channels; ++k) {
1213 ucontrol->value.integer.value[k] = !!(thru_bits & (1 << k));
1226 return -EBUSY;
1228 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1229 if (ucontrol->value.integer.value[chn])
1233 guard(spinlock_irq)(&rme9652->lock);
1234 change = thru_bits ^ rme9652->thru_bits;
1236 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1257 guard(spinlock_irq)(&rme9652->lock);
1258 ucontrol->value.integer.value[0] = rme9652->passthru;
1270 return -EBUSY;
1272 val = ucontrol->value.integer.value[0] & 1;
1273 guard(spinlock_irq)(&rme9652->lock);
1274 change = (ucontrol->value.integer.value[0] != rme9652->passthru);
1280 /* Read-only switches */
1290 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1291 uinfo->count = 1;
1292 uinfo->value.integer.min = 0;
1293 uinfo->value.integer.max = 96000;
1301 guard(spinlock_irq)(&rme9652->lock);
1302 ucontrol->value.integer.value[0] = rme9652_spdif_sample_rate(rme9652);
1315 "No Lock", "Lock", "No Lock Sync", "Lock Sync"
1326 switch (kcontrol->private_value) {
1330 default: return -EINVAL;
1333 ucontrol->value.enumerated.item[0] = (val & mask1) ? 1 : 0;
1334 ucontrol->value.enumerated.item[0] |= (val & mask2) ? 2 : 0;
1350 ucontrol->value.integer.value[0] =
1357 /* FIXME: this routine needs a port to the new control API --jk */
1367 uswitch->type = SNDRV_SW_TYPE_DWORD;
1371 uswitch->value.data32[0] = 0;
1379 /* XXX bug alert: loop-based timing !!!! */
1387 return -EIO;
1400 value -= 2 * 60 * 48000;
1405 uswitch->value.data32[0] = value;
1450 RME9652_SYNC_MODE("Sync Mode", 0),
1451 RME9652_SYNC_PREF("Preferred Sync Source", 0),
1461 RME9652_ADAT_SYNC("ADAT1 Sync Check", 0, 0),
1462 RME9652_ADAT_SYNC("ADAT2 Sync Check", 0, 1),
1468 RME9652_ADAT_SYNC("ADAT3 Sync Check", 0, 2);
1485 rme9652->spdif_ctl = kctl;
1488 if (rme9652->ss_channels == RME9652_NCHANNELS) {
1495 if (rme9652->hw_rev >= 15) {
1505 /*------------------------------------------------------------
1507 ------------------------------------------------------------*/
1512 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data;
1513 u32 thru_bits = rme9652->thru_bits;
1521 snd_iprintf(buffer, "%s (Card #%d)\n", rme9652->card_name, rme9652->card->number + 1);
1523 rme9652->capture_buffer, rme9652->playback_buffer);
1525 rme9652->irq, rme9652->port, (unsigned long)rme9652->iobase);
1526 snd_iprintf(buffer, "Control register: %x\n", rme9652->control_register);
1530 x = 1 << (6 + rme9652_decode_latency(rme9652->control_register &
1534 x, (unsigned long) rme9652->period_bytes);
1537 snd_iprintf(buffer, "Passthru: %s\n", str_yes_no(rme9652->passthru));
1539 if ((rme9652->control_register & (RME9652_Master | RME9652_wsel)) == 0) {
1540 snd_iprintf(buffer, "Clock mode: autosync\n");
1542 } else if (rme9652->control_register & RME9652_wsel) {
1544 snd_iprintf(buffer, "Clock mode: word clock\n");
1546 snd_iprintf(buffer, "Clock mode: word clock (no signal)\n");
1549 snd_iprintf(buffer, "Clock mode: master\n");
1553 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1555 snd_iprintf(buffer, "Pref. sync source: ADAT1\n");
1558 snd_iprintf(buffer, "Pref. sync source: ADAT2\n");
1561 snd_iprintf(buffer, "Pref. sync source: ADAT3\n");
1564 snd_iprintf(buffer, "Pref. sync source: IEC958\n");
1567 snd_iprintf(buffer, "Pref. sync source: ???\n");
1571 if (rme9652->hw_rev >= 15)
1573 (rme9652->control_register & RME9652_ADAT1_INTERNAL) ?
1578 switch (rme9652_decode_spdif_in(rme9652->control_register &
1594 if (rme9652->control_register & RME9652_opt_out) {
1600 if (rme9652->control_register & RME9652_PRO) {
1606 if (rme9652->control_register & RME9652_EMP) {
1612 if (rme9652->control_register & RME9652_Dolby) {
1634 /* Sync Check */
1638 snd_iprintf(buffer, "ADAT1: %s\n", x ? "Sync" : "Lock");
1645 snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
1652 snd_iprintf(buffer, "ADAT3: %s\n", x ? "Sync" : "Lock");
1666 for (i = 0; i < rme9652->ss_channels; i++) {
1683 snd_card_ro_proc_new(rme9652->card, "rme9652", rme9652,
1689 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
1691 if (rme9652->irq >= 0)
1699 capture_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
1700 playback_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
1702 dev_err(rme9652->card->dev,
1703 "%s: no buffers available\n", rme9652->card_name);
1704 return -ENOMEM;
1708 rme9652->capture_dma_buf = *capture_dma;
1709 rme9652->playback_dma_buf = *playback_dma;
1711 /* Align to bus-space 64K boundary */
1712 rme9652->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul);
1713 rme9652->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul);
1716 rme9652_write(rme9652, RME9652_rec_buffer, rme9652->capture_dma_buf.addr);
1717 rme9652_write(rme9652, RME9652_play_buffer, rme9652->playback_dma_buf.addr);
1719 rme9652->capture_dma_buf.area += rme9652->capture_dma_buf.addr - capture_dma->addr;
1720 rme9652->playback_dma_buf.area += rme9652->playback_dma_buf.addr - playback_dma->addr;
1721 rme9652->capture_buffer = rme9652->capture_dma_buf.area;
1722 rme9652->playback_buffer = rme9652->playback_dma_buf.area;
1731 /* ASSUMPTION: rme9652->lock is either held, or
1739 autosync clock mode
1747 rme9652->control_register =
1750 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1760 rme9652->thru_bits = 0;
1761 rme9652->passthru = 0;
1778 if (rme9652->capture_substream) {
1779 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
1782 if (rme9652->playback_substream) {
1783 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
1804 mapped_channel = rme9652->channel_map[channel];
1809 return rme9652->capture_buffer +
1812 return rme9652->playback_buffer +
1825 return -EINVAL;
1828 substream->pstr->stream,
1831 return -EIO;
1833 return -EFAULT;
1845 return -EINVAL;
1848 substream->pstr->stream,
1851 return -EIO;
1853 return -EFAULT;
1865 substream->pstr->stream,
1868 return -EIO;
1875 struct snd_pcm_runtime *runtime = substream->runtime;
1878 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1879 other = rme9652->capture_substream;
1881 other = rme9652->playback_substream;
1882 if (rme9652->running)
1883 runtime->status->hw_ptr = rme9652_hw_pointer(rme9652);
1885 runtime->status->hw_ptr = 0;
1888 struct snd_pcm_runtime *oruntime = other->runtime;
1891 oruntime->status->hw_ptr = runtime->status->hw_ptr;
1907 scoped_guard(spinlock_irq, &rme9652->lock) {
1909 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1910 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
1911 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= rme9652->creg_spdif_stream);
1912 this_pid = rme9652->playback_pid;
1913 other_pid = rme9652->capture_pid;
1915 this_pid = rme9652->capture_pid;
1916 other_pid = rme9652->playback_pid;
1929 return -EBUSY;
1932 if (params_period_size(params) != rme9652->period_bytes / 4) {
1934 return -EBUSY;
1942 /* how to make sure that the rate matches an externally-set one ?
1966 if (snd_BUG_ON(info->channel >= RME9652_NCHANNELS))
1967 return -EINVAL;
1969 chn = rme9652->channel_map[array_index_nospec(info->channel,
1972 return -EINVAL;
1974 info->offset = chn * RME9652_CHANNEL_BUFFER_BYTES;
1975 info->first = 0;
1976 info->step = 32;
2002 memset(rme9652->playback_buffer, 0, RME9652_DMA_AREA_BYTES);
2012 guard(spinlock)(&rme9652->lock);
2013 running = rme9652->running;
2016 running |= 1 << substream->stream;
2019 running &= ~(1 << substream->stream);
2023 return -EINVAL;
2025 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2026 other = rme9652->capture_substream;
2028 other = rme9652->playback_substream;
2036 running |= 1 << s->stream;
2038 running &= ~(1 << s->stream);
2044 substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2048 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2052 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2057 if (!rme9652->running && running)
2059 else if (rme9652->running && !running)
2061 rme9652->running = running;
2070 guard(spinlock_irqsave)(&rme9652->lock);
2071 if (!rme9652->running)
2134 struct snd_rme9652 *rme9652 = rule->private;
2136 unsigned int list[2] = { rme9652->ds_channels, rme9652->ss_channels };
2143 struct snd_rme9652 *rme9652 = rule->private;
2146 if (r->min > 48000) {
2148 .min = rme9652->ds_channels,
2149 .max = rme9652->ds_channels,
2153 } else if (r->max < 88200) {
2155 .min = rme9652->ss_channels,
2156 .max = rme9652->ss_channels,
2167 struct snd_rme9652 *rme9652 = rule->private;
2170 if (c->min >= rme9652->ss_channels) {
2177 } else if (c->max <= rme9652->ds_channels) {
2191 struct snd_pcm_runtime *runtime = substream->runtime;
2193 scoped_guard(spinlock_irq, &rme9652->lock) {
2196 runtime->hw = snd_rme9652_playback_subinfo;
2197 snd_pcm_set_runtime_buffer(substream, &rme9652->playback_dma_buf);
2199 if (rme9652->capture_substream == NULL) {
2201 rme9652_set_thru(rme9652, -1, 0);
2204 rme9652->playback_pid = current->pid;
2205 rme9652->playback_substream = substream;
2212 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2215 SNDRV_PCM_HW_PARAM_RATE, -1);
2218 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2220 rme9652->creg_spdif_stream = rme9652->creg_spdif;
2221 rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2222 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2223 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2231 scoped_guard(spinlock_irq, &rme9652->lock) {
2232 rme9652->playback_pid = -1;
2233 rme9652->playback_substream = NULL;
2236 rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2237 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2238 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2246 struct snd_pcm_runtime *runtime = substream->runtime;
2248 scoped_guard(spinlock_irq, &rme9652->lock) {
2251 runtime->hw = snd_rme9652_capture_subinfo;
2252 snd_pcm_set_runtime_buffer(substream, &rme9652->capture_dma_buf);
2254 if (rme9652->playback_substream == NULL) {
2256 rme9652_set_thru(rme9652, -1, 0);
2259 rme9652->capture_pid = current->pid;
2260 rme9652->capture_substream = substream;
2267 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2270 SNDRV_PCM_HW_PARAM_RATE, -1);
2273 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2281 guard(spinlock_irq)(&rme9652->lock);
2283 rme9652->capture_pid = -1;
2284 rme9652->capture_substream = NULL;
2315 struct snd_pcm *pcm;
2318 err = snd_pcm_new(card, rme9652->card_name, 0, 1, 1, &pcm);
2322 rme9652->pcm = pcm;
2323 pcm->private_data = rme9652;
2324 strscpy(pcm->name, rme9652->card_name);
2326 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_rme9652_playback_ops);
2327 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_rme9652_capture_ops);
2329 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
2338 struct pci_dev *pci = rme9652->pci;
2343 rme9652->irq = -1;
2344 rme9652->card = card;
2346 pci_read_config_word(rme9652->pci, PCI_CLASS_REVISION, &rev);
2357 return -ENODEV;
2364 spin_lock_init(&rme9652->lock);
2369 rme9652->port = pci_resource_start(pci, 0);
2370 rme9652->iobase = devm_ioremap(&pci->dev, rme9652->port, RME9652_IO_EXTENT);
2371 if (rme9652->iobase == NULL) {
2372 dev_err(card->dev, "unable to remap region 0x%lx-0x%lx\n",
2373 rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
2374 return -EBUSY;
2377 if (devm_request_irq(&pci->dev, pci->irq, snd_rme9652_interrupt,
2379 dev_err(card->dev, "unable to request IRQ %d\n", pci->irq);
2380 return -EBUSY;
2382 rme9652->irq = pci->irq;
2383 card->sync_irq = rme9652->irq;
2384 rme9652->precise_ptr = precise_ptr;
2393 rme9652->hw_rev = 15;
2395 rme9652->hw_rev = 11;
2407 strscpy(card->driver, "RME9636");
2408 if (rme9652->hw_rev == 15) {
2409 rme9652->card_name = "RME Digi9636 (Rev 1.5)";
2411 rme9652->card_name = "RME Digi9636";
2413 rme9652->ss_channels = RME9636_NCHANNELS;
2416 strscpy(card->driver, "RME9636");
2417 rme9652->card_name = "RME Digi9636 (Rev G)";
2418 rme9652->ss_channels = RME9636_NCHANNELS;
2421 strscpy(card->driver, "RME9652");
2422 rme9652->card_name = "RME Digi9652 (Rev G)";
2423 rme9652->ss_channels = RME9652_NCHANNELS;
2426 strscpy(card->driver, "RME9652");
2427 if (rme9652->hw_rev == 15) {
2428 rme9652->card_name = "RME Digi9652 (Rev 1.5)";
2430 rme9652->card_name = "RME Digi9652";
2432 rme9652->ss_channels = RME9652_NCHANNELS;
2436 rme9652->ds_channels = (rme9652->ss_channels - 2) / 2 + 2;
2438 pci_set_master(rme9652->pci);
2454 rme9652->last_spdif_sample_rate = -1;
2455 rme9652->last_adat_sample_rate = -1;
2456 rme9652->playback_pid = -1;
2457 rme9652->capture_pid = -1;
2458 rme9652->capture_substream = NULL;
2459 rme9652->playback_substream = NULL;
2463 if (rme9652->hw_rev == 15) {
2479 return -ENODEV;
2482 return -ENOENT;
2485 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2491 rme9652 = (struct snd_rme9652 *) card->private_data;
2492 card->private_free = snd_rme9652_card_free;
2493 rme9652->dev = dev;
2494 rme9652->pci = pci;
2499 strscpy(card->shortname, rme9652->card_name);
2501 sprintf(card->longname, "%s at 0x%lx, irq %d",
2502 card->shortname, rme9652->port, rme9652->irq);