Lines Matching refs:rme9652
328 static inline void rme9652_write(struct snd_rme9652 *rme9652, int reg, int val)
330 writel(val, rme9652->iobase + reg);
333 static inline unsigned int rme9652_read(struct snd_rme9652 *rme9652, int reg)
335 return readl(rme9652->iobase + reg);
338 static inline int snd_rme9652_use_is_exclusive(struct snd_rme9652 *rme9652)
343 spin_lock_irqsave(&rme9652->lock, flags);
344 if ((rme9652->playback_pid != rme9652->capture_pid) &&
345 (rme9652->playback_pid >= 0) && (rme9652->capture_pid >= 0)) {
348 spin_unlock_irqrestore(&rme9652->lock, flags);
352 static inline int rme9652_adat_sample_rate(struct snd_rme9652 *rme9652)
354 if (rme9652_running_double_speed(rme9652)) {
355 return (rme9652_read(rme9652, RME9652_status_register) &
358 return (rme9652_read(rme9652, RME9652_status_register) &
363 static inline void rme9652_compute_period_size(struct snd_rme9652 *rme9652)
367 i = rme9652->control_register & RME9652_latency;
368 rme9652->period_bytes = 1 << ((rme9652_decode_latency(i) + 8));
369 rme9652->hw_offsetmask =
370 (rme9652->period_bytes * 2 - 1) & RME9652_buf_pos;
371 rme9652->max_jitter = 80;
374 static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652)
378 snd_pcm_uframes_t period_size = rme9652->period_bytes / 4;
381 status = rme9652_read(rme9652, RME9652_status_register);
382 if (!rme9652->precise_ptr)
390 delta = rme9652->prev_hw_offset - offset;
392 if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4)
393 offset = rme9652->prev_hw_offset;
395 rme9652->prev_hw_offset = offset;
396 offset &= rme9652->hw_offsetmask;
401 if (offset > rme9652->max_jitter) {
406 offset -= rme9652->max_jitter;
410 if (offset > period_size + rme9652->max_jitter) {
415 offset -= rme9652->max_jitter;
421 static inline void rme9652_reset_hw_pointer(struct snd_rme9652 *rme9652)
432 rme9652_write(rme9652, i * 4, 0);
435 rme9652->prev_hw_offset = 0;
484 static int rme9652_set_rate(struct snd_rme9652 *rme9652, int rate)
490 if (!snd_rme9652_use_is_exclusive (rme9652)) {
505 spin_lock_irq(&rme9652->lock);
506 xrate = rme9652_adat_sample_rate(rme9652);
534 spin_unlock_irq(&rme9652->lock);
538 if (reject_if_open && (rme9652->capture_pid >= 0 || rme9652->playback_pid >= 0)) {
539 spin_unlock_irq(&rme9652->lock);
543 if ((restart = rme9652->running)) {
544 rme9652_stop(rme9652);
546 rme9652->control_register &= ~(RME9652_freq | RME9652_DS);
547 rme9652->control_register |= rate;
548 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
551 rme9652_start(rme9652);
555 if (rme9652->ss_channels == RME9652_NCHANNELS) {
556 rme9652->channel_map = channel_map_9652_ds;
558 rme9652->channel_map = channel_map_9636_ds;
561 if (rme9652->ss_channels == RME9652_NCHANNELS) {
562 rme9652->channel_map = channel_map_9652_ss;
564 rme9652->channel_map = channel_map_9636_ss;
568 spin_unlock_irq(&rme9652->lock);
572 static void rme9652_set_thru(struct snd_rme9652 *rme9652, int channel, int enable)
576 rme9652->passthru = 0;
584 rme9652->thru_bits |= (1 << i);
585 rme9652_write(rme9652, RME9652_thru_base + i * 4, 1);
589 rme9652->thru_bits &= ~(1 << i);
590 rme9652_write(rme9652, RME9652_thru_base + i * 4, 0);
597 mapped_channel = rme9652->channel_map[channel];
600 rme9652->thru_bits |= (1 << mapped_channel);
602 rme9652->thru_bits &= ~(1 << mapped_channel);
605 rme9652_write(rme9652,
611 static int rme9652_set_passthru(struct snd_rme9652 *rme9652, int onoff)
614 rme9652_set_thru(rme9652, -1, 1);
620 rme9652->control_register =
625 rme9652_reset_hw_pointer(rme9652);
627 rme9652_write(rme9652, RME9652_control_register,
628 rme9652->control_register);
629 rme9652->passthru = 1;
631 rme9652_set_thru(rme9652, -1, 0);
632 rme9652_stop(rme9652);
633 rme9652->passthru = 0;
639 static void rme9652_spdif_set_bit (struct snd_rme9652 *rme9652, int mask, int onoff)
642 rme9652->control_register |= mask;
644 rme9652->control_register &= ~mask;
646 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
649 static void rme9652_spdif_write_byte (struct snd_rme9652 *rme9652, const int val)
656 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_WRITE, 1);
658 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_WRITE, 0);
660 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 1);
661 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 0);
665 static int rme9652_spdif_read_byte (struct snd_rme9652 *rme9652)
674 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 1);
675 if (rme9652_read (rme9652, RME9652_status_register) & RME9652_SPDIF_READ)
677 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_CLOCK, 0);
683 static void rme9652_write_spdif_codec (struct snd_rme9652 *rme9652, const int address, const int data)
685 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
686 rme9652_spdif_write_byte (rme9652, 0x20);
687 rme9652_spdif_write_byte (rme9652, address);
688 rme9652_spdif_write_byte (rme9652, data);
689 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
693 static int rme9652_spdif_read_codec (struct snd_rme9652 *rme9652, const int address)
697 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
698 rme9652_spdif_write_byte (rme9652, 0x20);
699 rme9652_spdif_write_byte (rme9652, address);
700 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
701 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1);
703 rme9652_spdif_write_byte (rme9652, 0x21);
704 ret = rme9652_spdif_read_byte (rme9652);
705 rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 0);
710 static void rme9652_initialize_spdif_receiver (struct snd_rme9652 *rme9652)
713 rme9652->control_register |= RME9652_SPDIF_RESET;
715 rme9652_write_spdif_codec (rme9652, 4, 0x40);
716 rme9652_write_spdif_codec (rme9652, 17, 0x13);
717 rme9652_write_spdif_codec (rme9652, 6, 0x02);
819 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
821 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif);
827 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
832 spin_lock_irq(&rme9652->lock);
833 change = val != rme9652->creg_spdif;
834 rme9652->creg_spdif = val;
835 spin_unlock_irq(&rme9652->lock);
848 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
850 snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif_stream);
856 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
861 spin_lock_irq(&rme9652->lock);
862 change = val != rme9652->creg_spdif_stream;
863 rme9652->creg_spdif_stream = val;
864 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
865 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= val);
866 spin_unlock_irq(&rme9652->lock);
889 static unsigned int rme9652_adat1_in(struct snd_rme9652 *rme9652)
891 if (rme9652->control_register & RME9652_ADAT1_INTERNAL)
896 static int rme9652_set_adat1_input(struct snd_rme9652 *rme9652, int internal)
901 rme9652->control_register |= RME9652_ADAT1_INTERNAL;
903 rme9652->control_register &= ~RME9652_ADAT1_INTERNAL;
907 if ((restart = rme9652->running)) {
908 rme9652_stop(rme9652);
911 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
914 rme9652_start(rme9652);
935 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
937 spin_lock_irq(&rme9652->lock);
938 ucontrol->value.enumerated.item[0] = rme9652_adat1_in(rme9652);
939 spin_unlock_irq(&rme9652->lock);
945 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
949 if (!snd_rme9652_use_is_exclusive(rme9652))
952 spin_lock_irq(&rme9652->lock);
953 change = val != rme9652_adat1_in(rme9652);
955 rme9652_set_adat1_input(rme9652, val);
956 spin_unlock_irq(&rme9652->lock);
965 static unsigned int rme9652_spdif_in(struct snd_rme9652 *rme9652)
967 return rme9652_decode_spdif_in(rme9652->control_register &
971 static int rme9652_set_spdif_input(struct snd_rme9652 *rme9652, int in)
975 rme9652->control_register &= ~RME9652_inp;
976 rme9652->control_register |= rme9652_encode_spdif_in(in);
978 if ((restart = rme9652->running)) {
979 rme9652_stop(rme9652);
982 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
985 rme9652_start(rme9652);
1006 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1008 spin_lock_irq(&rme9652->lock);
1009 ucontrol->value.enumerated.item[0] = rme9652_spdif_in(rme9652);
1010 spin_unlock_irq(&rme9652->lock);
1016 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1020 if (!snd_rme9652_use_is_exclusive(rme9652))
1023 spin_lock_irq(&rme9652->lock);
1024 change = val != rme9652_spdif_in(rme9652);
1026 rme9652_set_spdif_input(rme9652, val);
1027 spin_unlock_irq(&rme9652->lock);
1036 static int rme9652_spdif_out(struct snd_rme9652 *rme9652)
1038 return (rme9652->control_register & RME9652_opt_out) ? 1 : 0;
1041 static int rme9652_set_spdif_output(struct snd_rme9652 *rme9652, int out)
1046 rme9652->control_register |= RME9652_opt_out;
1048 rme9652->control_register &= ~RME9652_opt_out;
1051 if ((restart = rme9652->running)) {
1052 rme9652_stop(rme9652);
1055 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1058 rme9652_start(rme9652);
1068 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1070 spin_lock_irq(&rme9652->lock);
1071 ucontrol->value.integer.value[0] = rme9652_spdif_out(rme9652);
1072 spin_unlock_irq(&rme9652->lock);
1078 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1082 if (!snd_rme9652_use_is_exclusive(rme9652))
1085 spin_lock_irq(&rme9652->lock);
1086 change = (int)val != rme9652_spdif_out(rme9652);
1087 rme9652_set_spdif_output(rme9652, val);
1088 spin_unlock_irq(&rme9652->lock);
1097 static int rme9652_sync_mode(struct snd_rme9652 *rme9652)
1099 if (rme9652->control_register & RME9652_wsel) {
1101 } else if (rme9652->control_register & RME9652_Master) {
1108 static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode)
1114 rme9652->control_register &=
1118 rme9652->control_register =
1119 (rme9652->control_register & ~RME9652_wsel) | RME9652_Master;
1122 rme9652->control_register |=
1127 if ((restart = rme9652->running)) {
1128 rme9652_stop(rme9652);
1131 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1134 rme9652_start(rme9652);
1155 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1157 spin_lock_irq(&rme9652->lock);
1158 ucontrol->value.enumerated.item[0] = rme9652_sync_mode(rme9652);
1159 spin_unlock_irq(&rme9652->lock);
1165 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1170 spin_lock_irq(&rme9652->lock);
1171 change = (int)val != rme9652_sync_mode(rme9652);
1172 rme9652_set_sync_mode(rme9652, val);
1173 spin_unlock_irq(&rme9652->lock);
1182 static int rme9652_sync_pref(struct snd_rme9652 *rme9652)
1184 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1198 static int rme9652_set_sync_pref(struct snd_rme9652 *rme9652, int pref)
1202 rme9652->control_register &= ~RME9652_SyncPref_Mask;
1205 rme9652->control_register |= RME9652_SyncPref_ADAT1;
1208 rme9652->control_register |= RME9652_SyncPref_ADAT2;
1211 rme9652->control_register |= RME9652_SyncPref_ADAT3;
1214 rme9652->control_register |= RME9652_SyncPref_SPDIF;
1218 if ((restart = rme9652->running)) {
1219 rme9652_stop(rme9652);
1222 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1225 rme9652_start(rme9652);
1234 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1238 uinfo->value.enumerated.items = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3;
1247 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1249 spin_lock_irq(&rme9652->lock);
1250 ucontrol->value.enumerated.item[0] = rme9652_sync_pref(rme9652);
1251 spin_unlock_irq(&rme9652->lock);
1257 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1261 if (!snd_rme9652_use_is_exclusive(rme9652))
1263 max = rme9652->ss_channels == RME9652_NCHANNELS ? 4 : 3;
1265 spin_lock_irq(&rme9652->lock);
1266 change = (int)val != rme9652_sync_pref(rme9652);
1267 rme9652_set_sync_pref(rme9652, val);
1268 spin_unlock_irq(&rme9652->lock);
1274 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1276 uinfo->count = rme9652->ss_channels;
1284 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1286 u32 thru_bits = rme9652->thru_bits;
1288 for (k = 0; k < rme9652->ss_channels; ++k) {
1296 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1301 if (!snd_rme9652_use_is_exclusive(rme9652))
1304 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1309 spin_lock_irq(&rme9652->lock);
1310 change = thru_bits ^ rme9652->thru_bits;
1312 for (chn = 0; chn < rme9652->ss_channels; ++chn) {
1315 rme9652_set_thru(rme9652,chn,thru_bits&(1<<chn));
1318 spin_unlock_irq(&rme9652->lock);
1332 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1334 spin_lock_irq(&rme9652->lock);
1335 ucontrol->value.integer.value[0] = rme9652->passthru;
1336 spin_unlock_irq(&rme9652->lock);
1342 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1347 if (!snd_rme9652_use_is_exclusive(rme9652))
1351 spin_lock_irq(&rme9652->lock);
1352 change = (ucontrol->value.integer.value[0] != rme9652->passthru);
1354 err = rme9652_set_passthru(rme9652, val);
1355 spin_unlock_irq(&rme9652->lock);
1378 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1380 spin_lock_irq(&rme9652->lock);
1381 ucontrol->value.integer.value[0] = rme9652_spdif_sample_rate(rme9652);
1382 spin_unlock_irq(&rme9652->lock);
1407 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1416 val = rme9652_read(rme9652, RME9652_status_register);
1432 struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol);
1435 (rme9652_read(rme9652, RME9652_status_register) & RME9652_tc_valid) ? 1 : 0;
1555 static int snd_rme9652_create_controls(struct snd_card *card, struct snd_rme9652 *rme9652)
1562 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_controls[idx], rme9652))) < 0)
1565 rme9652->spdif_ctl = kctl;
1568 if (rme9652->ss_channels == RME9652_NCHANNELS)
1569 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_adat3_check, rme9652))) < 0)
1572 if (rme9652->hw_rev >= 15)
1573 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_adat1_input, rme9652))) < 0)
1586 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data;
1587 u32 thru_bits = rme9652->thru_bits;
1593 status = rme9652_read(rme9652, RME9652_status_register);
1595 snd_iprintf(buffer, "%s (Card #%d)\n", rme9652->card_name, rme9652->card->number + 1);
1597 rme9652->capture_buffer, rme9652->playback_buffer);
1599 rme9652->irq, rme9652->port, (unsigned long)rme9652->iobase);
1600 snd_iprintf(buffer, "Control register: %x\n", rme9652->control_register);
1604 x = 1 << (6 + rme9652_decode_latency(rme9652->control_register &
1608 x, (unsigned long) rme9652->period_bytes);
1610 rme9652_hw_pointer(rme9652));
1612 rme9652->passthru ? "yes" : "no");
1614 if ((rme9652->control_register & (RME9652_Master | RME9652_wsel)) == 0) {
1617 } else if (rme9652->control_register & RME9652_wsel) {
1628 switch (rme9652->control_register & RME9652_SyncPref_Mask) {
1646 if (rme9652->hw_rev >= 15)
1648 (rme9652->control_register & RME9652_ADAT1_INTERNAL) ?
1653 switch (rme9652_decode_spdif_in(rme9652->control_register &
1669 if (rme9652->control_register & RME9652_opt_out) {
1675 if (rme9652->control_register & RME9652_PRO) {
1681 if (rme9652->control_register & RME9652_EMP) {
1687 if (rme9652->control_register & RME9652_Dolby) {
1693 i = rme9652_spdif_sample_rate(rme9652);
1707 rme9652_adat_sample_rate(rme9652));
1741 for (i = 0; i < rme9652->ss_channels; i++) {
1756 static void __devinit snd_rme9652_proc_init(struct snd_rme9652 *rme9652)
1760 if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
1761 snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
1764 static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652)
1766 snd_hammerfall_free_buffer(&rme9652->capture_dma_buf, rme9652->pci);
1767 snd_hammerfall_free_buffer(&rme9652->playback_dma_buf, rme9652->pci);
1770 static int snd_rme9652_free(struct snd_rme9652 *rme9652)
1772 if (rme9652->irq >= 0)
1773 rme9652_stop(rme9652);
1774 snd_rme9652_free_buffers(rme9652);
1776 if (rme9652->irq >= 0)
1777 free_irq(rme9652->irq, (void *)rme9652);
1778 if (rme9652->iobase)
1779 iounmap(rme9652->iobase);
1780 if (rme9652->port)
1781 pci_release_regions(rme9652->pci);
1783 pci_disable_device(rme9652->pci);
1787 static int __devinit snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)
1791 if (snd_hammerfall_get_buffer(rme9652->pci, &rme9652->capture_dma_buf, RME9652_DMA_AREA_BYTES) < 0 ||
1792 snd_hammerfall_get_buffer(rme9652->pci, &rme9652->playback_dma_buf, RME9652_DMA_AREA_BYTES) < 0) {
1793 if (rme9652->capture_dma_buf.area)
1794 snd_dma_free_pages(&rme9652->capture_dma_buf);
1795 printk(KERN_ERR "%s: no buffers available\n", rme9652->card_name);
1801 cb_bus = ALIGN(rme9652->capture_dma_buf.addr, 0x10000ul);
1802 pb_bus = ALIGN(rme9652->playback_dma_buf.addr, 0x10000ul);
1806 rme9652_write(rme9652, RME9652_rec_buffer, cb_bus);
1807 rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
1809 rme9652->capture_buffer = rme9652->capture_dma_buf.area + (cb_bus - rme9652->capture_dma_buf.addr);
1810 rme9652->playback_buffer = rme9652->playback_dma_buf.area + (pb_bus - rme9652->playback_dma_buf.addr);
1815 static void snd_rme9652_set_defaults(struct snd_rme9652 *rme9652)
1819 /* ASSUMPTION: rme9652->lock is either held, or
1835 rme9652->control_register =
1838 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register);
1840 rme9652_reset_hw_pointer(rme9652);
1841 rme9652_compute_period_size(rme9652);
1846 rme9652_write(rme9652, RME9652_thru_base + k * 4, 0);
1848 rme9652->thru_bits = 0;
1849 rme9652->passthru = 0;
1853 rme9652_set_rate(rme9652, 48000);
1858 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) dev_id;
1860 if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) {
1864 rme9652_write(rme9652, RME9652_irq_clear, 0);
1866 if (rme9652->capture_substream) {
1867 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
1870 if (rme9652->playback_substream) {
1871 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
1878 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1879 return rme9652_hw_pointer(rme9652);
1882 static char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652,
1892 if ((mapped_channel = rme9652->channel_map[channel]) < 0) {
1897 return rme9652->capture_buffer +
1900 return rme9652->playback_buffer +
1908 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1914 channel_buf = rme9652_channel_buffer_location (rme9652,
1927 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1933 channel_buf = rme9652_channel_buffer_location (rme9652,
1946 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1949 channel_buf = rme9652_channel_buffer_location (rme9652,
1961 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1964 other = rme9652->capture_substream;
1966 other = rme9652->playback_substream;
1967 if (rme9652->running)
1968 runtime->status->hw_ptr = rme9652_hw_pointer(rme9652);
1987 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
1992 spin_lock_irq(&rme9652->lock);
1995 rme9652->control_register &= ~(RME9652_PRO | RME9652_Dolby | RME9652_EMP);
1996 rme9652_write(rme9652, RME9652_control_register, rme9652->control_register |= rme9652->creg_spdif_stream);
1997 this_pid = rme9652->playback_pid;
1998 other_pid = rme9652->capture_pid;
2000 this_pid = rme9652->capture_pid;
2001 other_pid = rme9652->playback_pid;
2012 rme9652_adat_sample_rate(rme9652)) {
2013 spin_unlock_irq(&rme9652->lock);
2018 if (params_period_size(params) != rme9652->period_bytes / 4) {
2019 spin_unlock_irq(&rme9652->lock);
2026 spin_unlock_irq(&rme9652->lock);
2030 spin_unlock_irq(&rme9652->lock);
2036 if ((err = rme9652_set_rate(rme9652, params_rate(params))) < 0) {
2041 if ((err = rme9652_set_interrupt_interval(rme9652, params_period_size(params))) < 0) {
2052 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2058 if ((chn = rme9652->channel_map[info->channel]) < 0) {
2088 static void rme9652_silence_playback(struct snd_rme9652 *rme9652)
2090 memset(rme9652->playback_buffer, 0, RME9652_DMA_AREA_BYTES);
2096 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2099 spin_lock(&rme9652->lock);
2100 running = rme9652->running;
2110 spin_unlock(&rme9652->lock);
2114 other = rme9652->capture_substream;
2116 other = rme9652->playback_substream;
2133 rme9652_silence_playback(rme9652);
2137 rme9652_silence_playback(rme9652);
2141 rme9652_silence_playback(rme9652);
2145 if (!rme9652->running && running)
2146 rme9652_start(rme9652);
2147 else if (rme9652->running && !running)
2148 rme9652_stop(rme9652);
2149 rme9652->running = running;
2150 spin_unlock(&rme9652->lock);
2157 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2161 spin_lock_irqsave(&rme9652->lock, flags);
2162 if (!rme9652->running)
2163 rme9652_reset_hw_pointer(rme9652);
2164 spin_unlock_irqrestore(&rme9652->lock, flags);
2226 struct snd_rme9652 *rme9652 = rule->private;
2228 unsigned int list[2] = { rme9652->ds_channels, rme9652->ss_channels };
2235 struct snd_rme9652 *rme9652 = rule->private;
2240 .min = rme9652->ds_channels,
2241 .max = rme9652->ds_channels,
2247 .min = rme9652->ss_channels,
2248 .max = rme9652->ss_channels,
2259 struct snd_rme9652 *rme9652 = rule->private;
2262 if (c->min >= rme9652->ss_channels) {
2269 } else if (c->max <= rme9652->ds_channels) {
2282 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2285 spin_lock_irq(&rme9652->lock);
2290 runtime->dma_area = rme9652->playback_buffer;
2293 if (rme9652->capture_substream == NULL) {
2294 rme9652_stop(rme9652);
2295 rme9652_set_thru(rme9652, -1, 0);
2298 rme9652->playback_pid = current->pid;
2299 rme9652->playback_substream = substream;
2301 spin_unlock_irq(&rme9652->lock);
2306 snd_rme9652_hw_rule_channels, rme9652,
2309 snd_rme9652_hw_rule_channels_rate, rme9652,
2312 snd_rme9652_hw_rule_rate_channels, rme9652,
2315 rme9652->creg_spdif_stream = rme9652->creg_spdif;
2316 rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2317 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2318 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2324 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2326 spin_lock_irq(&rme9652->lock);
2328 rme9652->playback_pid = -1;
2329 rme9652->playback_substream = NULL;
2331 spin_unlock_irq(&rme9652->lock);
2333 rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2334 snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
2335 SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
2342 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2345 spin_lock_irq(&rme9652->lock);
2350 runtime->dma_area = rme9652->capture_buffer;
2353 if (rme9652->playback_substream == NULL) {
2354 rme9652_stop(rme9652);
2355 rme9652_set_thru(rme9652, -1, 0);
2358 rme9652->capture_pid = current->pid;
2359 rme9652->capture_substream = substream;
2361 spin_unlock_irq(&rme9652->lock);
2366 snd_rme9652_hw_rule_channels, rme9652,
2369 snd_rme9652_hw_rule_channels_rate, rme9652,
2372 snd_rme9652_hw_rule_rate_channels, rme9652,
2379 struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
2381 spin_lock_irq(&rme9652->lock);
2383 rme9652->capture_pid = -1;
2384 rme9652->capture_substream = NULL;
2386 spin_unlock_irq(&rme9652->lock);
2414 struct snd_rme9652 *rme9652)
2420 rme9652->card_name,
2425 rme9652->pcm = pcm;
2426 pcm->private_data = rme9652;
2427 strcpy(pcm->name, rme9652->card_name);
2438 struct snd_rme9652 *rme9652,
2441 struct pci_dev *pci = rme9652->pci;
2446 rme9652->irq = -1;
2447 rme9652->card = card;
2449 pci_read_config_word(rme9652->pci, PCI_CLASS_REVISION, &rev);
2466 spin_lock_init(&rme9652->lock);
2468 if ((err = pci_request_regions(pci, "rme9652")) < 0)
2470 rme9652->port = pci_resource_start(pci, 0);
2471 rme9652->iobase = ioremap_nocache(rme9652->port, RME9652_IO_EXTENT);
2472 if (rme9652->iobase == NULL) {
2473 snd_printk(KERN_ERR "unable to remap region 0x%lx-0x%lx\n", rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
2478 "rme9652", rme9652)) {
2482 rme9652->irq = pci->irq;
2483 rme9652->precise_ptr = precise_ptr;
2490 status = rme9652_read(rme9652, RME9652_status_register);
2492 rme9652->hw_rev = 15;
2494 rme9652->hw_rev = 11;
2507 if (rme9652->hw_rev == 15) {
2508 rme9652->card_name = "RME Digi9636 (Rev 1.5)";
2510 rme9652->card_name = "RME Digi9636";
2512 rme9652->ss_channels = RME9636_NCHANNELS;
2516 rme9652->card_name = "RME Digi9636 (Rev G)";
2517 rme9652->ss_channels = RME9636_NCHANNELS;
2521 rme9652->card_name = "RME Digi9652 (Rev G)";
2522 rme9652->ss_channels = RME9652_NCHANNELS;
2526 if (rme9652->hw_rev == 15) {
2527 rme9652->card_name = "RME Digi9652 (Rev 1.5)";
2529 rme9652->card_name = "RME Digi9652";
2531 rme9652->ss_channels = RME9652_NCHANNELS;
2535 rme9652->ds_channels = (rme9652->ss_channels - 2) / 2 + 2;
2537 pci_set_master(rme9652->pci);
2539 if ((err = snd_rme9652_initialize_memory(rme9652)) < 0) {
2543 if ((err = snd_rme9652_create_pcm(card, rme9652)) < 0) {
2547 if ((err = snd_rme9652_create_controls(card, rme9652)) < 0) {
2551 snd_rme9652_proc_init(rme9652);
2553 rme9652->last_spdif_sample_rate = -1;
2554 rme9652->last_adat_sample_rate = -1;
2555 rme9652->playback_pid = -1;
2556 rme9652->capture_pid = -1;
2557 rme9652->capture_substream = NULL;
2558 rme9652->playback_substream = NULL;
2560 snd_rme9652_set_defaults(rme9652);
2562 if (rme9652->hw_rev == 15) {
2563 rme9652_initialize_spdif_receiver (rme9652);
2571 struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data;
2573 if (rme9652)
2574 snd_rme9652_free(rme9652);
2581 struct snd_rme9652 *rme9652;
2598 rme9652 = (struct snd_rme9652 *) card->private_data;
2600 rme9652->dev = dev;
2601 rme9652->pci = pci;
2604 if ((err = snd_rme9652_create(card, rme9652, precise_ptr[dev])) < 0) {
2609 strcpy(card->shortname, rme9652->card_name);
2612 card->shortname, rme9652->port, rme9652->irq);