Lines Matching refs:rme32
51 * full duplex support for the rme32 at the moment. That's bad, but I'm not
194 struct rme32 {
238 #define RME32_ISWORKING(rme32) ((rme32)->wcreg & RME32_WCR_START)
239 #define RME32_PRO_WITH_8414(rme32) ((rme32)->pci->device == PCI_DEVICE_ID_RME_DIGI32_PRO && (rme32)->rev == RME32_PRO_REVISION_WITH_8414)
247 static void snd_rme32_proc_init(struct rme32 * rme32);
249 static int snd_rme32_create_switches(struct snd_card *card, struct rme32 * rme32);
251 static inline unsigned int snd_rme32_pcm_byteptr(struct rme32 * rme32)
253 return (readl(rme32->iobase + RME32_IO_GET_POS)
262 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
263 count <<= rme32->playback_frlog;
264 pos <<= rme32->playback_frlog;
265 memset_io(rme32->iobase + RME32_IO_DATA_BUFFER + pos, 0, count);
274 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
275 count <<= rme32->playback_frlog;
276 pos <<= rme32->playback_frlog;
277 if (copy_from_user_toio(rme32->iobase + RME32_IO_DATA_BUFFER + pos,
288 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
289 count <<= rme32->capture_frlog;
290 pos <<= rme32->capture_frlog;
292 rme32->iobase + RME32_IO_DATA_BUFFER + pos,
400 static void snd_rme32_reset_dac(struct rme32 *rme32)
402 writel(rme32->wcreg | RME32_WCR_PD,
403 rme32->iobase + RME32_IO_CONTROL_REGISTER);
404 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
407 static int snd_rme32_playback_getrate(struct rme32 * rme32)
411 rate = ((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_0) & 1) +
412 (((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_1) & 1) << 1);
426 return (rme32->wcreg & RME32_WCR_DS_BM) ? rate << 1 : rate;
429 static int snd_rme32_capture_getrate(struct rme32 * rme32, int *is_adat)
434 if (rme32->rcreg & RME32_RCR_LOCK) {
438 if (rme32->rcreg & RME32_RCR_ERF) {
443 n = ((rme32->rcreg >> RME32_RCR_BITPOS_F0) & 1) +
444 (((rme32->rcreg >> RME32_RCR_BITPOS_F1) & 1) << 1) +
445 (((rme32->rcreg >> RME32_RCR_BITPOS_F2) & 1) << 2);
447 if (RME32_PRO_WITH_8414(rme32))
491 static int snd_rme32_playback_setrate(struct rme32 * rme32, int rate)
495 ds = rme32->wcreg & RME32_WCR_DS_BM;
498 rme32->wcreg &= ~RME32_WCR_DS_BM;
499 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) &
503 rme32->wcreg &= ~RME32_WCR_DS_BM;
504 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_1) &
508 rme32->wcreg &= ~RME32_WCR_DS_BM;
509 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) |
513 if (rme32->pci->device != PCI_DEVICE_ID_RME_DIGI32_PRO)
515 rme32->wcreg |= RME32_WCR_DS_BM;
516 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) &
520 if (rme32->pci->device != PCI_DEVICE_ID_RME_DIGI32_PRO)
522 rme32->wcreg |= RME32_WCR_DS_BM;
523 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_1) &
527 if (rme32->pci->device != PCI_DEVICE_ID_RME_DIGI32_PRO)
529 rme32->wcreg |= RME32_WCR_DS_BM;
530 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) |
536 if ((!ds && rme32->wcreg & RME32_WCR_DS_BM) ||
537 (ds && !(rme32->wcreg & RME32_WCR_DS_BM)))
540 snd_rme32_reset_dac(rme32);
542 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
547 static int snd_rme32_setclockmode(struct rme32 * rme32, int mode)
552 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_FREQ_0) &
557 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) &
562 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_FREQ_0) |
567 rme32->wcreg = (rme32->wcreg | RME32_WCR_FREQ_0) |
573 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
577 static int snd_rme32_getclockmode(struct rme32 * rme32)
579 return ((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_0) & 1) +
580 (((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_1) & 1) << 1);
583 static int snd_rme32_setinputtype(struct rme32 * rme32, int type)
587 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_INP_0) &
591 rme32->wcreg = (rme32->wcreg | RME32_WCR_INP_0) &
595 rme32->wcreg = (rme32->wcreg & ~RME32_WCR_INP_0) |
599 rme32->wcreg = (rme32->wcreg | RME32_WCR_INP_0) |
605 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
609 static int snd_rme32_getinputtype(struct rme32 * rme32)
611 return ((rme32->wcreg >> RME32_WCR_BITPOS_INP_0) & 1) +
612 (((rme32->wcreg >> RME32_WCR_BITPOS_INP_1) & 1) << 1);
616 snd_rme32_setframelog(struct rme32 * rme32, int n_channels, int is_playback)
627 frlog += (rme32->wcreg & RME32_WCR_MODE24) ? 2 : 1;
628 rme32->playback_frlog = frlog;
630 frlog += (rme32->wcreg & RME32_WCR_MODE24) ? 2 : 1;
631 rme32->capture_frlog = frlog;
635 static int snd_rme32_setformat(struct rme32 * rme32, int format)
639 rme32->wcreg &= ~RME32_WCR_MODE24;
642 rme32->wcreg |= RME32_WCR_MODE24;
647 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
656 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
659 if (rme32->fullduplex_mode) {
664 runtime->dma_area = (void __force *)(rme32->iobase +
666 runtime->dma_addr = rme32->port + RME32_IO_DATA_BUFFER;
670 spin_lock_irq(&rme32->lock);
671 if ((rme32->rcreg & RME32_RCR_KMODE) &&
672 (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
675 spin_unlock_irq(&rme32->lock);
678 } else if ((err = snd_rme32_playback_setrate(rme32, params_rate(params))) < 0) {
679 spin_unlock_irq(&rme32->lock);
682 if ((err = snd_rme32_setformat(rme32, params_format(params))) < 0) {
683 spin_unlock_irq(&rme32->lock);
687 snd_rme32_setframelog(rme32, params_channels(params), 1);
688 if (rme32->capture_periodsize != 0) {
689 if (params_period_size(params) << rme32->playback_frlog != rme32->capture_periodsize) {
690 spin_unlock_irq(&rme32->lock);
694 rme32->playback_periodsize = params_period_size(params) << rme32->playback_frlog;
696 if ((rme32->wcreg & RME32_WCR_ADAT) == 0) {
697 rme32->wcreg &= ~(RME32_WCR_PRO | RME32_WCR_EMP);
698 rme32->wcreg |= rme32->wcreg_spdif_stream;
699 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
701 spin_unlock_irq(&rme32->lock);
711 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
714 if (rme32->fullduplex_mode) {
719 runtime->dma_area = (void __force *)rme32->iobase +
721 runtime->dma_addr = rme32->port + RME32_IO_DATA_BUFFER;
725 spin_lock_irq(&rme32->lock);
727 rme32->wcreg |= RME32_WCR_AUTOSYNC;
728 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
730 if ((err = snd_rme32_setformat(rme32, params_format(params))) < 0) {
731 spin_unlock_irq(&rme32->lock);
734 if ((err = snd_rme32_playback_setrate(rme32, params_rate(params))) < 0) {
735 spin_unlock_irq(&rme32->lock);
738 if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
740 spin_unlock_irq(&rme32->lock);
745 spin_unlock_irq(&rme32->lock);
750 rme32->wcreg &= ~RME32_WCR_AUTOSYNC;
751 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
753 snd_rme32_setframelog(rme32, params_channels(params), 0);
754 if (rme32->playback_periodsize != 0) {
755 if (params_period_size(params) << rme32->capture_frlog !=
756 rme32->playback_periodsize) {
757 spin_unlock_irq(&rme32->lock);
761 rme32->capture_periodsize =
762 params_period_size(params) << rme32->capture_frlog;
763 spin_unlock_irq(&rme32->lock);
770 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
771 if (! rme32->fullduplex_mode)
776 static void snd_rme32_pcm_start(struct rme32 * rme32, int from_pause)
779 writel(0, rme32->iobase + RME32_IO_RESET_POS);
782 rme32->wcreg |= RME32_WCR_START;
783 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
786 static void snd_rme32_pcm_stop(struct rme32 * rme32, int to_pause)
792 rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
793 if (rme32->rcreg & RME32_RCR_IRQ) {
794 writel(0, rme32->iobase + RME32_IO_CONFIRM_ACTION_IRQ);
796 rme32->wcreg &= ~RME32_WCR_START;
797 if (rme32->wcreg & RME32_WCR_SEL)
798 rme32->wcreg |= RME32_WCR_MUTE;
799 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
801 writel(0, rme32->iobase + RME32_IO_RESET_POS);
806 struct rme32 *rme32 = (struct rme32 *) dev_id;
808 rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
809 if (!(rme32->rcreg & RME32_RCR_IRQ)) {
812 if (rme32->capture_substream) {
813 snd_pcm_period_elapsed(rme32->capture_substream);
815 if (rme32->playback_substream) {
816 snd_pcm_period_elapsed(rme32->playback_substream);
818 writel(0, rme32->iobase + RME32_IO_CONFIRM_ACTION_IRQ);
832 static void snd_rme32_set_buffer_constraint(struct rme32 *rme32, struct snd_pcm_runtime *runtime)
834 if (! rme32->fullduplex_mode) {
847 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
852 spin_lock_irq(&rme32->lock);
853 if (rme32->playback_substream != NULL) {
854 spin_unlock_irq(&rme32->lock);
857 rme32->wcreg &= ~RME32_WCR_ADAT;
858 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
859 rme32->playback_substream = substream;
860 spin_unlock_irq(&rme32->lock);
862 if (rme32->fullduplex_mode)
866 if (rme32->pci->device == PCI_DEVICE_ID_RME_DIGI32_PRO) {
870 if ((rme32->rcreg & RME32_RCR_KMODE) &&
871 (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
878 snd_rme32_set_buffer_constraint(rme32, runtime);
880 rme32->wcreg_spdif_stream = rme32->wcreg_spdif;
881 rme32->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
882 snd_ctl_notify(rme32->card, SNDRV_CTL_EVENT_MASK_VALUE |
883 SNDRV_CTL_EVENT_MASK_INFO, &rme32->spdif_ctl->id);
890 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
895 spin_lock_irq(&rme32->lock);
896 if (rme32->capture_substream != NULL) {
897 spin_unlock_irq(&rme32->lock);
900 rme32->capture_substream = substream;
901 spin_unlock_irq(&rme32->lock);
903 if (rme32->fullduplex_mode)
907 if (RME32_PRO_WITH_8414(rme32)) {
911 if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
920 snd_rme32_set_buffer_constraint(rme32, runtime);
929 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
934 spin_lock_irq(&rme32->lock);
935 if (rme32->playback_substream != NULL) {
936 spin_unlock_irq(&rme32->lock);
939 rme32->wcreg |= RME32_WCR_ADAT;
940 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
941 rme32->playback_substream = substream;
942 spin_unlock_irq(&rme32->lock);
944 if (rme32->fullduplex_mode)
948 if ((rme32->rcreg & RME32_RCR_KMODE) &&
949 (rate = snd_rme32_capture_getrate(rme32, &dummy)) > 0) {
956 snd_rme32_set_buffer_constraint(rme32, runtime);
964 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
967 if (rme32->fullduplex_mode)
971 if ((rate = snd_rme32_capture_getrate(rme32, &isadat)) > 0) {
982 spin_lock_irq(&rme32->lock);
983 if (rme32->capture_substream != NULL) {
984 spin_unlock_irq(&rme32->lock);
987 rme32->capture_substream = substream;
988 spin_unlock_irq(&rme32->lock);
990 snd_rme32_set_buffer_constraint(rme32, runtime);
996 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
999 spin_lock_irq(&rme32->lock);
1000 rme32->playback_substream = NULL;
1001 rme32->playback_periodsize = 0;
1002 spdif = (rme32->wcreg & RME32_WCR_ADAT) == 0;
1003 spin_unlock_irq(&rme32->lock);
1005 rme32->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1006 snd_ctl_notify(rme32->card, SNDRV_CTL_EVENT_MASK_VALUE |
1008 &rme32->spdif_ctl->id);
1015 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1017 spin_lock_irq(&rme32->lock);
1018 rme32->capture_substream = NULL;
1019 rme32->capture_periodsize = 0;
1020 spin_unlock(&rme32->lock);
1026 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1028 spin_lock_irq(&rme32->lock);
1029 if (rme32->fullduplex_mode) {
1030 memset(&rme32->playback_pcm, 0, sizeof(rme32->playback_pcm));
1031 rme32->playback_pcm.hw_buffer_size = RME32_BUFFER_SIZE;
1032 rme32->playback_pcm.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
1034 writel(0, rme32->iobase + RME32_IO_RESET_POS);
1036 if (rme32->wcreg & RME32_WCR_SEL)
1037 rme32->wcreg &= ~RME32_WCR_MUTE;
1038 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1039 spin_unlock_irq(&rme32->lock);
1045 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1047 spin_lock_irq(&rme32->lock);
1048 if (rme32->fullduplex_mode) {
1049 memset(&rme32->capture_pcm, 0, sizeof(rme32->capture_pcm));
1050 rme32->capture_pcm.hw_buffer_size = RME32_BUFFER_SIZE;
1051 rme32->capture_pcm.hw_queue_size = RME32_BUFFER_SIZE / 2;
1052 rme32->capture_pcm.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
1054 writel(0, rme32->iobase + RME32_IO_RESET_POS);
1056 spin_unlock_irq(&rme32->lock);
1063 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1066 spin_lock(&rme32->lock);
1068 if (s != rme32->playback_substream &&
1069 s != rme32->capture_substream)
1073 rme32->running |= (1 << s->stream);
1074 if (rme32->fullduplex_mode) {
1076 if (s == rme32->playback_substream) {
1077 rme32->playback_pcm.hw_io =
1078 rme32->playback_pcm.hw_data = snd_rme32_pcm_byteptr(rme32);
1080 rme32->capture_pcm.hw_io =
1081 rme32->capture_pcm.hw_data = snd_rme32_pcm_byteptr(rme32);
1086 rme32->running &= ~(1 << s->stream);
1093 if (cmd == SNDRV_PCM_TRIGGER_START && rme32->fullduplex_mode) {
1095 if (s == rme32->playback_substream) {
1104 if (rme32->running && ! RME32_ISWORKING(rme32))
1105 snd_rme32_pcm_start(rme32, 0);
1108 if (! rme32->running && RME32_ISWORKING(rme32))
1109 snd_rme32_pcm_stop(rme32, 0);
1112 if (rme32->running && RME32_ISWORKING(rme32))
1113 snd_rme32_pcm_stop(rme32, 1);
1116 if (rme32->running && ! RME32_ISWORKING(rme32))
1117 snd_rme32_pcm_start(rme32, 1);
1120 spin_unlock(&rme32->lock);
1128 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1129 return snd_rme32_pcm_byteptr(rme32) >> rme32->playback_frlog;
1135 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1136 return snd_rme32_pcm_byteptr(rme32) >> rme32->capture_frlog;
1144 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1145 memcpy_toio(rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data,
1151 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1154 rec = &rme32->playback_pcm;
1155 cprec = &rme32->capture_pcm;
1156 spin_lock(&rme32->lock);
1158 if (rme32->running & (1 << SNDRV_PCM_STREAM_CAPTURE))
1160 spin_unlock(&rme32->lock);
1169 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1171 rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data,
1177 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1178 snd_pcm_indirect_capture_transfer(substream, &rme32->capture_pcm,
1186 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1187 return snd_pcm_indirect_playback_pointer(substream, &rme32->playback_pcm,
1188 snd_rme32_pcm_byteptr(rme32));
1194 struct rme32 *rme32 = snd_pcm_substream_chip(substream);
1195 return snd_pcm_indirect_capture_pointer(substream, &rme32->capture_pcm,
1196 snd_rme32_pcm_byteptr(rme32));
1301 struct rme32 *rme32 = (struct rme32 *) private_data;
1303 if (rme32 == NULL) {
1306 if (rme32->irq >= 0) {
1307 snd_rme32_pcm_stop(rme32, 0);
1308 free_irq(rme32->irq, (void *) rme32);
1309 rme32->irq = -1;
1311 if (rme32->iobase) {
1312 iounmap(rme32->iobase);
1313 rme32->iobase = NULL;
1315 if (rme32->port) {
1316 pci_release_regions(rme32->pci);
1317 rme32->port = 0;
1319 pci_disable_device(rme32->pci);
1324 struct rme32 *rme32 = (struct rme32 *) pcm->private_data;
1325 rme32->spdif_pcm = NULL;
1331 struct rme32 *rme32 = (struct rme32 *) pcm->private_data;
1332 rme32->adat_pcm = NULL;
1335 static int __devinit snd_rme32_create(struct rme32 * rme32)
1337 struct pci_dev *pci = rme32->pci;
1340 rme32->irq = -1;
1341 spin_lock_init(&rme32->lock);
1348 rme32->port = pci_resource_start(rme32->pci, 0);
1350 rme32->iobase = ioremap_nocache(rme32->port, RME32_IO_SIZE);
1351 if (!rme32->iobase) {
1353 rme32->port, rme32->port + RME32_IO_SIZE - 1);
1358 "RME32", rme32)) {
1362 rme32->irq = pci->irq;
1365 pci_read_config_byte(pci, 8, &rme32->rev);
1368 if ((err = snd_pcm_new(rme32->card, "Digi32 IEC958", 0, 1, 1, &rme32->spdif_pcm)) < 0) {
1371 rme32->spdif_pcm->private_data = rme32;
1372 rme32->spdif_pcm->private_free = snd_rme32_free_spdif_pcm;
1373 strcpy(rme32->spdif_pcm->name, "Digi32 IEC958");
1374 if (rme32->fullduplex_mode) {
1375 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1377 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_CAPTURE,
1379 snd_pcm_lib_preallocate_pages_for_all(rme32->spdif_pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1382 rme32->spdif_pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
1384 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1386 snd_pcm_set_ops(rme32->spdif_pcm, SNDRV_PCM_STREAM_CAPTURE,
1388 rme32->spdif_pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
1395 rme32->adat_pcm = NULL;
1398 if ((err = snd_pcm_new(rme32->card, "Digi32 ADAT", 1,
1399 1, 1, &rme32->adat_pcm)) < 0)
1403 rme32->adat_pcm->private_data = rme32;
1404 rme32->adat_pcm->private_free = snd_rme32_free_adat_pcm;
1405 strcpy(rme32->adat_pcm->name, "Digi32 ADAT");
1406 if (rme32->fullduplex_mode) {
1407 snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1409 snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_CAPTURE,
1411 snd_pcm_lib_preallocate_pages_for_all(rme32->adat_pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1414 rme32->adat_pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
1416 snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_PLAYBACK,
1418 snd_pcm_set_ops(rme32->adat_pcm, SNDRV_PCM_STREAM_CAPTURE,
1420 rme32->adat_pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
1425 rme32->playback_periodsize = 0;
1426 rme32->capture_periodsize = 0;
1429 snd_rme32_pcm_stop(rme32, 0);
1432 snd_rme32_reset_dac(rme32);
1435 writel(0, rme32->iobase + RME32_IO_RESET_POS);
1438 rme32->wcreg = RME32_WCR_SEL | /* normal playback */
1441 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1445 if ((err = snd_rme32_create_switches(rme32->card, rme32)) < 0) {
1450 snd_rme32_proc_init(rme32);
1452 rme32->capture_substream = NULL;
1453 rme32->playback_substream = NULL;
1466 struct rme32 *rme32 = (struct rme32 *) entry->private_data;
1468 rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
1470 snd_iprintf(buffer, rme32->card->longname);
1471 snd_iprintf(buffer, " (index #%d)\n", rme32->card->number + 1);
1474 if (rme32->fullduplex_mode)
1478 if (RME32_PRO_WITH_8414(rme32)) {
1483 if (rme32->wcreg & RME32_WCR_MODE24) {
1488 if (rme32->wcreg & RME32_WCR_MONO) {
1495 switch (snd_rme32_getinputtype(rme32)) {
1509 if (snd_rme32_capture_getrate(rme32, &n) < 0) {
1518 snd_rme32_capture_getrate(rme32, &n));
1522 if (rme32->wcreg & RME32_WCR_SEL) {
1527 if (rme32->wcreg & RME32_WCR_MUTE) {
1535 ((!(rme32->wcreg & RME32_WCR_FREQ_0))
1536 && (!(rme32->wcreg & RME32_WCR_FREQ_1)))) {
1538 snd_rme32_playback_getrate(rme32));
1540 if (rme32->rcreg & RME32_RCR_KMODE) {
1545 if (rme32->wcreg & RME32_WCR_PRO) {
1550 if (rme32->wcreg & RME32_WCR_EMP) {
1557 static void __devinit snd_rme32_proc_init(struct rme32 * rme32)
1561 if (! snd_card_proc_new(rme32->card, "rme32", &entry))
1562 snd_info_set_text_ops(entry, rme32, snd_rme32_proc_read);
1575 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1577 spin_lock_irq(&rme32->lock);
1579 rme32->wcreg & RME32_WCR_SEL ? 0 : 1;
1580 spin_unlock_irq(&rme32->lock);
1587 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1592 spin_lock_irq(&rme32->lock);
1593 val = (rme32->wcreg & ~RME32_WCR_SEL) | val;
1594 change = val != rme32->wcreg;
1599 rme32->wcreg = val;
1600 writel(val, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1601 spin_unlock_irq(&rme32->lock);
1609 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1614 switch (rme32->pci->device) {
1639 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1642 spin_lock_irq(&rme32->lock);
1643 ucontrol->value.enumerated.item[0] = snd_rme32_getinputtype(rme32);
1645 switch (rme32->pci->device) {
1661 spin_unlock_irq(&rme32->lock);
1668 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1672 switch (rme32->pci->device) {
1686 spin_lock_irq(&rme32->lock);
1687 change = val != (unsigned int)snd_rme32_getinputtype(rme32);
1688 snd_rme32_setinputtype(rme32, val);
1689 spin_unlock_irq(&rme32->lock);
1716 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1718 spin_lock_irq(&rme32->lock);
1719 ucontrol->value.enumerated.item[0] = snd_rme32_getclockmode(rme32);
1720 spin_unlock_irq(&rme32->lock);
1727 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1732 spin_lock_irq(&rme32->lock);
1733 change = val != (unsigned int)snd_rme32_getclockmode(rme32);
1734 snd_rme32_setclockmode(rme32, val);
1735 spin_unlock_irq(&rme32->lock);
1770 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1773 rme32->wcreg_spdif);
1780 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1785 spin_lock_irq(&rme32->lock);
1786 change = val != rme32->wcreg_spdif;
1787 rme32->wcreg_spdif = val;
1788 spin_unlock_irq(&rme32->lock);
1804 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1807 rme32->wcreg_spdif_stream);
1815 struct rme32 *rme32 = snd_kcontrol_chip(kcontrol);
1820 spin_lock_irq(&rme32->lock);
1821 change = val != rme32->wcreg_spdif_stream;
1822 rme32->wcreg_spdif_stream = val;
1823 rme32->wcreg &= ~(RME32_WCR_PRO | RME32_WCR_EMP);
1824 rme32->wcreg |= val;
1825 writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
1826 spin_unlock_irq(&rme32->lock);
1901 static int snd_rme32_create_switches(struct snd_card *card, struct rme32 * rme32)
1907 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme32_controls[idx], rme32))) < 0)
1910 rme32->spdif_ctl = kctl;
1929 struct rme32 *rme32;
1942 sizeof(struct rme32), &card);
1946 rme32 = (struct rme32 *) card->private_data;
1947 rme32->card = card;
1948 rme32->pci = pci;
1951 rme32->fullduplex_mode = 1;
1952 if ((err = snd_rme32_create(rme32)) < 0) {
1958 switch (rme32->pci->device) {
1970 card->shortname, rme32->rev, rme32->port, rme32->irq);