Lines Matching defs:hdspm
44 #include <sound/hdspm.h>
424 struct hdspm *hdspm;
435 struct hdspm {
531 struct hdspm * hdspm);
533 struct hdspm * hdspm);
535 static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm);
536 static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm);
537 static int hdspm_autosync_ref(struct hdspm * hdspm);
538 static int snd_hdspm_set_defaults(struct hdspm * hdspm);
539 static void hdspm_set_sgbuf(struct hdspm * hdspm,
556 static inline void hdspm_write(struct hdspm * hdspm, unsigned int reg,
559 writel(val, hdspm->iobase + reg);
562 static inline unsigned int hdspm_read(struct hdspm * hdspm, unsigned int reg)
564 return readl(hdspm->iobase + reg);
571 static inline int hdspm_read_in_gain(struct hdspm * hdspm, unsigned int chan,
577 return hdspm->mixer->ch[chan].in[in];
580 static inline int hdspm_read_pb_gain(struct hdspm * hdspm, unsigned int chan,
585 return hdspm->mixer->ch[chan].pb[pb];
588 static int hdspm_write_in_gain(struct hdspm *hdspm, unsigned int chan,
594 hdspm_write(hdspm,
597 (hdspm->mixer->ch[chan].in[in] = data & 0xFFFF));
601 static int hdspm_write_pb_gain(struct hdspm *hdspm, unsigned int chan,
607 hdspm_write(hdspm,
610 (hdspm->mixer->ch[chan].pb[pb] = data & 0xFFFF));
616 static inline void snd_hdspm_enable_in(struct hdspm * hdspm, int i, int v)
618 hdspm_write(hdspm, HDSPM_inputEnableBase + (4 * i), v);
621 static inline void snd_hdspm_enable_out(struct hdspm * hdspm, int i, int v)
623 hdspm_write(hdspm, HDSPM_outputEnableBase + (4 * i), v);
627 static int snd_hdspm_use_is_exclusive(struct hdspm *hdspm)
632 spin_lock_irqsave(&hdspm->lock, flags);
633 if ((hdspm->playback_pid != hdspm->capture_pid) &&
634 (hdspm->playback_pid >= 0) && (hdspm->capture_pid >= 0)) {
637 spin_unlock_irqrestore(&hdspm->lock, flags);
642 static int hdspm_external_sample_rate(struct hdspm *hdspm)
644 if (hdspm->is_aes32) {
645 unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
646 unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister);
648 hdspm_read(hdspm, HDSPM_timecodeRegister);
650 int syncref = hdspm_autosync_ref(hdspm);
664 unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
665 unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister);
750 static inline void hdspm_compute_period_size(struct hdspm * hdspm)
752 hdspm->period_bytes =
753 1 << ((hdspm_decode_latency(hdspm->control_register) + 8));
756 static snd_pcm_uframes_t hdspm_hw_pointer(struct hdspm * hdspm)
760 position = hdspm_read(hdspm, HDSPM_statusRegister);
762 if (!hdspm->precise_ptr)
764 (hdspm->period_bytes / 4) : 0;
774 position = ((position - 64) % (2 * hdspm->period_bytes)) / 4;
780 static inline void hdspm_start_audio(struct hdspm * s)
786 static inline void hdspm_stop_audio(struct hdspm * s)
793 static void hdspm_silence_playback(struct hdspm *hdspm)
796 int n = hdspm->period_bytes;
797 void *buf = hdspm->playback_buffer;
808 static int hdspm_set_interrupt_interval(struct hdspm * s, unsigned int frames)
832 static void hdspm_set_dds_value(struct hdspm *hdspm, int rate)
850 hdspm_write(hdspm, HDSPM_freqReg, (u32)n);
854 static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally)
861 /* ASSUMPTION: hdspm->lock is either set, or there is no need for
865 if (!(hdspm->control_register & HDSPM_ClockModeMaster)) {
882 hdspm_external_sample_rate(hdspm);
884 if (hdspm_autosync_ref(hdspm) ==
901 current_rate = hdspm->system_sample_rate;
960 && (hdspm->capture_pid >= 0 || hdspm->playback_pid >= 0)) {
967 hdspm->capture_pid, hdspm->playback_pid);
971 hdspm->control_register &= ~HDSPM_FrequencyMask;
972 hdspm->control_register |= rate_bits;
973 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
977 hdspm_set_dds_value(hdspm, rate);
979 if (hdspm->is_aes32 && rate != current_rate)
980 hdspm_write(hdspm, HDSPM_eeprom_wr, 0);
984 hdspm->channel_map = channel_map_madi_ss;
986 hdspm->system_sample_rate = rate;
995 static void all_in_all_mixer(struct hdspm * hdspm, int sgain)
1009 hdspm_write_in_gain(hdspm, i, j, gain);
1010 hdspm_write_pb_gain(hdspm, i, j, gain);
1018 static inline unsigned char snd_hdspm_midi_read_byte (struct hdspm *hdspm,
1023 return hdspm_read(hdspm, HDSPM_midiDataIn1);
1025 return hdspm_read(hdspm, HDSPM_midiDataIn0);
1028 static inline void snd_hdspm_midi_write_byte (struct hdspm *hdspm, int id,
1033 hdspm_write(hdspm, HDSPM_midiDataOut1, val);
1035 hdspm_write(hdspm, HDSPM_midiDataOut0, val);
1038 static inline int snd_hdspm_midi_input_available (struct hdspm *hdspm, int id)
1041 return (hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xff);
1043 return (hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xff);
1046 static inline int snd_hdspm_midi_output_possible (struct hdspm *hdspm, int id)
1051 fifo_bytes_used = hdspm_read(hdspm, HDSPM_midiStatusOut1);
1053 fifo_bytes_used = hdspm_read(hdspm, HDSPM_midiStatusOut0);
1062 static void snd_hdspm_flush_midi_input(struct hdspm *hdspm, int id)
1064 while (snd_hdspm_midi_input_available (hdspm, id))
1065 snd_hdspm_midi_read_byte (hdspm, id);
1081 n_pending = snd_hdspm_midi_output_possible (hmidi->hdspm,
1091 snd_hdspm_midi_write_byte (hmidi->hdspm,
1111 n_pending = snd_hdspm_midi_input_available (hmidi->hdspm, hmidi->id);
1117 buf[i] = snd_hdspm_midi_read_byte (hmidi->hdspm,
1125 snd_hdspm_midi_read_byte (hmidi->hdspm,
1131 hmidi->hdspm->control_register |= HDSPM_Midi1InterruptEnable;
1133 hmidi->hdspm->control_register |= HDSPM_Midi0InterruptEnable;
1134 hdspm_write(hmidi->hdspm, HDSPM_controlRegister,
1135 hmidi->hdspm->control_register);
1143 struct hdspm *hdspm;
1149 hdspm = hmidi->hdspm;
1152 spin_lock_irqsave (&hdspm->lock, flags);
1154 if (!(hdspm->control_register & ie)) {
1155 snd_hdspm_flush_midi_input (hdspm, hmidi->id);
1156 hdspm->control_register |= ie;
1159 hdspm->control_register &= ~ie;
1162 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1163 spin_unlock_irqrestore (&hdspm->lock, flags);
1220 snd_hdspm_flush_midi_input (hmidi->hdspm, hmidi->id);
1282 struct hdspm *hdspm, int id)
1287 hdspm->midi[id].id = id;
1288 hdspm->midi[id].hdspm = hdspm;
1289 spin_lock_init (&hdspm->midi[id].lock);
1292 err = snd_rawmidi_new (card, buf, id, 1, 1, &hdspm->midi[id].rmidi);
1296 sprintf(hdspm->midi[id].rmidi->name, "HDSPM MIDI %d", id+1);
1297 hdspm->midi[id].rmidi->private_data = &hdspm->midi[id];
1299 snd_rawmidi_set_ops(hdspm->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
1301 snd_rawmidi_set_ops(hdspm->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
1304 hdspm->midi[id].rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
1314 struct hdspm *hdspm = (struct hdspm *)arg;
1316 if (hdspm->midi[0].pending)
1317 snd_hdspm_midi_input_read (&hdspm->midi[0]);
1318 if (hdspm->midi[1].pending)
1319 snd_hdspm_midi_input_read (&hdspm->midi[1]);
1350 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1352 ucontrol->value.enumerated.item[0] = hdspm->system_sample_rate;
1388 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1390 switch (hdspm_external_sample_rate(hdspm)) {
1436 static int hdspm_system_clock_mode(struct hdspm * hdspm)
1440 if (hdspm->control_register & HDSPM_ClockModeMaster)
1464 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1467 hdspm_system_clock_mode(hdspm);
1480 static int hdspm_clock_source(struct hdspm * hdspm)
1482 if (hdspm->control_register & HDSPM_ClockModeMaster) {
1483 switch (hdspm->system_sample_rate) {
1510 static int hdspm_set_clock_source(struct hdspm * hdspm, int mode)
1516 if (hdspm_external_sample_rate(hdspm) != 0) {
1517 hdspm->control_register &= ~HDSPM_ClockModeMaster;
1518 hdspm_write(hdspm, HDSPM_controlRegister,
1519 hdspm->control_register);
1554 hdspm->control_register |= HDSPM_ClockModeMaster;
1555 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1556 hdspm_set_rate(hdspm, rate, 1);
1589 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1591 ucontrol->value.enumerated.item[0] = hdspm_clock_source(hdspm);
1598 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1602 if (!snd_hdspm_use_is_exclusive(hdspm))
1609 spin_lock_irq(&hdspm->lock);
1610 if (val != hdspm_clock_source(hdspm))
1611 change = (hdspm_set_clock_source(hdspm, val) == 0) ? 1 : 0;
1614 spin_unlock_irq(&hdspm->lock);
1627 static int hdspm_pref_sync_ref(struct hdspm * hdspm)
1632 if (hdspm->is_aes32) {
1633 switch (hdspm->control_register & HDSPM_SyncRefMask) {
1647 switch (hdspm->control_register & HDSPM_SyncRefMask) {
1658 static int hdspm_set_pref_sync_ref(struct hdspm * hdspm, int pref)
1660 hdspm->control_register &= ~HDSPM_SyncRefMask;
1662 if (hdspm->is_aes32) {
1665 hdspm->control_register |= 0;
1668 hdspm->control_register |= HDSPM_SyncRef0;
1671 hdspm->control_register |= HDSPM_SyncRef1;
1674 hdspm->control_register |= HDSPM_SyncRef1+HDSPM_SyncRef0;
1677 hdspm->control_register |= HDSPM_SyncRef2;
1680 hdspm->control_register |= HDSPM_SyncRef2+HDSPM_SyncRef0;
1683 hdspm->control_register |= HDSPM_SyncRef2+HDSPM_SyncRef1;
1686 hdspm->control_register |=
1690 hdspm->control_register |= HDSPM_SyncRef3;
1698 hdspm->control_register |= HDSPM_SyncRef_MADI;
1701 hdspm->control_register |= HDSPM_SyncRef_Word;
1707 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1714 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1716 if (hdspm->is_aes32) {
1752 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1754 ucontrol->value.enumerated.item[0] = hdspm_pref_sync_ref(hdspm);
1761 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1765 max = hdspm->is_aes32 ? 9 : 2;
1767 if (!snd_hdspm_use_is_exclusive(hdspm))
1772 spin_lock_irq(&hdspm->lock);
1773 change = (int) val != hdspm_pref_sync_ref(hdspm);
1774 hdspm_set_pref_sync_ref(hdspm, val);
1775 spin_unlock_irq(&hdspm->lock);
1788 static int hdspm_autosync_ref(struct hdspm * hdspm)
1790 if (hdspm->is_aes32) {
1791 unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister);
1801 unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
1821 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1823 if (hdspm->is_aes32) {
1855 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1857 ucontrol->value.enumerated.item[0] = hdspm_autosync_ref(hdspm);
1870 static int hdspm_line_out(struct hdspm * hdspm)
1872 return (hdspm->control_register & HDSPM_LineOut) ? 1 : 0;
1876 static int hdspm_set_line_output(struct hdspm * hdspm, int out)
1879 hdspm->control_register |= HDSPM_LineOut;
1881 hdspm->control_register &= ~HDSPM_LineOut;
1882 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1892 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1894 spin_lock_irq(&hdspm->lock);
1895 ucontrol->value.integer.value[0] = hdspm_line_out(hdspm);
1896 spin_unlock_irq(&hdspm->lock);
1903 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1907 if (!snd_hdspm_use_is_exclusive(hdspm))
1910 spin_lock_irq(&hdspm->lock);
1911 change = (int) val != hdspm_line_out(hdspm);
1912 hdspm_set_line_output(hdspm, val);
1913 spin_unlock_irq(&hdspm->lock);
1926 static int hdspm_tx_64(struct hdspm * hdspm)
1928 return (hdspm->control_register & HDSPM_TX_64ch) ? 1 : 0;
1931 static int hdspm_set_tx_64(struct hdspm * hdspm, int out)
1934 hdspm->control_register |= HDSPM_TX_64ch;
1936 hdspm->control_register &= ~HDSPM_TX_64ch;
1937 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
1947 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1949 spin_lock_irq(&hdspm->lock);
1950 ucontrol->value.integer.value[0] = hdspm_tx_64(hdspm);
1951 spin_unlock_irq(&hdspm->lock);
1958 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
1962 if (!snd_hdspm_use_is_exclusive(hdspm))
1965 spin_lock_irq(&hdspm->lock);
1966 change = (int) val != hdspm_tx_64(hdspm);
1967 hdspm_set_tx_64(hdspm, val);
1968 spin_unlock_irq(&hdspm->lock);
1981 static int hdspm_c_tms(struct hdspm * hdspm)
1983 return (hdspm->control_register & HDSPM_clr_tms) ? 1 : 0;
1986 static int hdspm_set_c_tms(struct hdspm * hdspm, int out)
1989 hdspm->control_register |= HDSPM_clr_tms;
1991 hdspm->control_register &= ~HDSPM_clr_tms;
1992 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2002 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2004 spin_lock_irq(&hdspm->lock);
2005 ucontrol->value.integer.value[0] = hdspm_c_tms(hdspm);
2006 spin_unlock_irq(&hdspm->lock);
2013 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2017 if (!snd_hdspm_use_is_exclusive(hdspm))
2020 spin_lock_irq(&hdspm->lock);
2021 change = (int) val != hdspm_c_tms(hdspm);
2022 hdspm_set_c_tms(hdspm, val);
2023 spin_unlock_irq(&hdspm->lock);
2036 static int hdspm_safe_mode(struct hdspm * hdspm)
2038 return (hdspm->control_register & HDSPM_AutoInp) ? 1 : 0;
2041 static int hdspm_set_safe_mode(struct hdspm * hdspm, int out)
2044 hdspm->control_register |= HDSPM_AutoInp;
2046 hdspm->control_register &= ~HDSPM_AutoInp;
2047 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2057 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2059 spin_lock_irq(&hdspm->lock);
2060 ucontrol->value.integer.value[0] = hdspm_safe_mode(hdspm);
2061 spin_unlock_irq(&hdspm->lock);
2068 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2072 if (!snd_hdspm_use_is_exclusive(hdspm))
2075 spin_lock_irq(&hdspm->lock);
2076 change = (int) val != hdspm_safe_mode(hdspm);
2077 hdspm_set_safe_mode(hdspm, val);
2078 spin_unlock_irq(&hdspm->lock);
2091 static int hdspm_emphasis(struct hdspm * hdspm)
2093 return (hdspm->control_register & HDSPM_Emphasis) ? 1 : 0;
2096 static int hdspm_set_emphasis(struct hdspm * hdspm, int emp)
2099 hdspm->control_register |= HDSPM_Emphasis;
2101 hdspm->control_register &= ~HDSPM_Emphasis;
2102 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2112 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2114 spin_lock_irq(&hdspm->lock);
2115 ucontrol->value.enumerated.item[0] = hdspm_emphasis(hdspm);
2116 spin_unlock_irq(&hdspm->lock);
2123 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2127 if (!snd_hdspm_use_is_exclusive(hdspm))
2130 spin_lock_irq(&hdspm->lock);
2131 change = (int) val != hdspm_emphasis(hdspm);
2132 hdspm_set_emphasis(hdspm, val);
2133 spin_unlock_irq(&hdspm->lock);
2146 static int hdspm_dolby(struct hdspm * hdspm)
2148 return (hdspm->control_register & HDSPM_Dolby) ? 1 : 0;
2151 static int hdspm_set_dolby(struct hdspm * hdspm, int dol)
2154 hdspm->control_register |= HDSPM_Dolby;
2156 hdspm->control_register &= ~HDSPM_Dolby;
2157 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2167 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2169 spin_lock_irq(&hdspm->lock);
2170 ucontrol->value.enumerated.item[0] = hdspm_dolby(hdspm);
2171 spin_unlock_irq(&hdspm->lock);
2178 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2182 if (!snd_hdspm_use_is_exclusive(hdspm))
2185 spin_lock_irq(&hdspm->lock);
2186 change = (int) val != hdspm_dolby(hdspm);
2187 hdspm_set_dolby(hdspm, val);
2188 spin_unlock_irq(&hdspm->lock);
2201 static int hdspm_professional(struct hdspm * hdspm)
2203 return (hdspm->control_register & HDSPM_Professional) ? 1 : 0;
2206 static int hdspm_set_professional(struct hdspm * hdspm, int dol)
2209 hdspm->control_register |= HDSPM_Professional;
2211 hdspm->control_register &= ~HDSPM_Professional;
2212 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2222 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2224 spin_lock_irq(&hdspm->lock);
2225 ucontrol->value.enumerated.item[0] = hdspm_professional(hdspm);
2226 spin_unlock_irq(&hdspm->lock);
2233 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2237 if (!snd_hdspm_use_is_exclusive(hdspm))
2240 spin_lock_irq(&hdspm->lock);
2241 change = (int) val != hdspm_professional(hdspm);
2242 hdspm_set_professional(hdspm, val);
2243 spin_unlock_irq(&hdspm->lock);
2256 static int hdspm_input_select(struct hdspm * hdspm)
2258 return (hdspm->control_register & HDSPM_InputSelect0) ? 1 : 0;
2261 static int hdspm_set_input_select(struct hdspm * hdspm, int out)
2264 hdspm->control_register |= HDSPM_InputSelect0;
2266 hdspm->control_register &= ~HDSPM_InputSelect0;
2267 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2293 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2295 spin_lock_irq(&hdspm->lock);
2296 ucontrol->value.enumerated.item[0] = hdspm_input_select(hdspm);
2297 spin_unlock_irq(&hdspm->lock);
2304 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2308 if (!snd_hdspm_use_is_exclusive(hdspm))
2311 spin_lock_irq(&hdspm->lock);
2312 change = (int) val != hdspm_input_select(hdspm);
2313 hdspm_set_input_select(hdspm, val);
2314 spin_unlock_irq(&hdspm->lock);
2327 static int hdspm_ds_wire(struct hdspm * hdspm)
2329 return (hdspm->control_register & HDSPM_DS_DoubleWire) ? 1 : 0;
2332 static int hdspm_set_ds_wire(struct hdspm * hdspm, int ds)
2335 hdspm->control_register |= HDSPM_DS_DoubleWire;
2337 hdspm->control_register &= ~HDSPM_DS_DoubleWire;
2338 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2364 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2366 spin_lock_irq(&hdspm->lock);
2367 ucontrol->value.enumerated.item[0] = hdspm_ds_wire(hdspm);
2368 spin_unlock_irq(&hdspm->lock);
2375 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2379 if (!snd_hdspm_use_is_exclusive(hdspm))
2382 spin_lock_irq(&hdspm->lock);
2383 change = (int) val != hdspm_ds_wire(hdspm);
2384 hdspm_set_ds_wire(hdspm, val);
2385 spin_unlock_irq(&hdspm->lock);
2398 static int hdspm_qs_wire(struct hdspm * hdspm)
2400 if (hdspm->control_register & HDSPM_QS_DoubleWire)
2402 if (hdspm->control_register & HDSPM_QS_QuadWire)
2407 static int hdspm_set_qs_wire(struct hdspm * hdspm, int mode)
2409 hdspm->control_register &= ~(HDSPM_QS_DoubleWire | HDSPM_QS_QuadWire);
2414 hdspm->control_register |= HDSPM_QS_DoubleWire;
2417 hdspm->control_register |= HDSPM_QS_QuadWire;
2420 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
2446 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2448 spin_lock_irq(&hdspm->lock);
2449 ucontrol->value.enumerated.item[0] = hdspm_qs_wire(hdspm);
2450 spin_unlock_irq(&hdspm->lock);
2457 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2461 if (!snd_hdspm_use_is_exclusive(hdspm))
2468 spin_lock_irq(&hdspm->lock);
2469 change = val != hdspm_qs_wire(hdspm);
2470 hdspm_set_qs_wire(hdspm, val);
2471 spin_unlock_irq(&hdspm->lock);
2511 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2527 spin_lock_irq(&hdspm->lock);
2530 hdspm_read_pb_gain(hdspm, destination,
2534 hdspm_read_in_gain(hdspm, destination, source);
2536 spin_unlock_irq(&hdspm->lock);
2544 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2550 if (!snd_hdspm_use_is_exclusive(hdspm))
2563 spin_lock_irq(&hdspm->lock);
2566 change = gain != hdspm_read_pb_gain(hdspm, destination,
2570 change = gain != hdspm_read_in_gain(hdspm, destination,
2575 hdspm_write_pb_gain(hdspm, destination,
2579 hdspm_write_in_gain(hdspm, destination, source,
2582 spin_unlock_irq(&hdspm->lock);
2615 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2624 mapped_channel = hdspm->channel_map[channel];
2628 spin_lock_irq(&hdspm->lock);
2630 hdspm_read_pb_gain(hdspm, mapped_channel, mapped_channel);
2631 spin_unlock_irq(&hdspm->lock);
2645 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2651 if (!snd_hdspm_use_is_exclusive(hdspm))
2659 mapped_channel = hdspm->channel_map[channel];
2665 spin_lock_irq(&hdspm->lock);
2667 gain != hdspm_read_pb_gain(hdspm, mapped_channel,
2670 hdspm_write_pb_gain(hdspm, mapped_channel, mapped_channel,
2672 spin_unlock_irq(&hdspm->lock);
2700 static int hdspm_wc_sync_check(struct hdspm * hdspm)
2702 if (hdspm->is_aes32) {
2703 int status = hdspm_read(hdspm, HDSPM_statusRegister);
2711 int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
2725 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2727 ucontrol->value.enumerated.item[0] = hdspm_wc_sync_check(hdspm);
2741 static int hdspm_madisync_sync_check(struct hdspm * hdspm)
2743 int status = hdspm_read(hdspm, HDSPM_statusRegister);
2757 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2760 hdspm_madisync_sync_check(hdspm);
2774 static int hdspm_aes_sync_check(struct hdspm * hdspm, int idx)
2776 int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
2789 struct hdspm *hdspm = snd_kcontrol_chip(kcontrol);
2796 hdspm_aes_sync_check(hdspm, offset);
2848 static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm)
2852 for (i = hdspm->ds_channels; i < hdspm->ss_channels; ++i) {
2853 if (hdspm->system_sample_rate > 48000) {
2854 hdspm->playback_mixer_ctls[i]->vd[0].access =
2859 hdspm->playback_mixer_ctls[i]->vd[0].access =
2863 snd_ctl_notify(hdspm->card, SNDRV_CTL_EVENT_MASK_VALUE |
2865 &hdspm->playback_mixer_ctls[i]->id);
2872 static int snd_hdspm_create_controls(struct snd_card *card, struct hdspm * hdspm)
2879 if (hdspm->is_aes32) {
2887 hdspm));
2894 snd_ctl_new1(&aes_sync_ctl, hdspm));
2903 hdspm));
2926 kctl = snd_ctl_new1(&snd_hdspm_playback_mixer, hdspm);
2930 hdspm->playback_mixer_ctls[idx] = kctl;
2944 struct hdspm *hdspm = entry->private_data;
2955 status = hdspm_read(hdspm, HDSPM_statusRegister);
2956 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
2959 hdspm->card_name, hdspm->card->number + 1,
2960 hdspm->firmware_rev,
2966 hdspm->irq, hdspm->port, (unsigned long)hdspm->iobase);
2975 hdspm->irq_count);
2982 (2 * (int)hdspm->period_bytes),
2984 (2 * (int)hdspm->period_bytes),
2985 (long) hdspm_hw_pointer(hdspm) * 4);
2989 hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xFF,
2990 hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xFF,
2991 hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xFF,
2992 hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xFF);
2996 hdspm->control_register, hdspm->control2_register,
3001 x = 1 << (6 + hdspm_decode_latency(hdspm->control_register &
3006 x, (unsigned long) hdspm->period_bytes);
3009 (hdspm->control_register & HDSPM_LineOut) ? "on " : "off",
3010 (hdspm->precise_ptr) ? "on" : "off");
3012 switch (hdspm->control_register & HDSPM_InputMask) {
3023 switch (hdspm->control_register & HDSPM_SyncRefMask) {
3039 (hdspm->
3041 (hdspm->
3043 (hdspm->
3046 switch (hdspm_clock_source(hdspm)) {
3072 if (!(hdspm->control_register & HDSPM_ClockModeMaster))
3078 switch (hdspm_pref_sync_ref(hdspm)) {
3093 hdspm->system_sample_rate);
3107 switch (hdspm_autosync_ref(hdspm)) {
3123 autosync_ref, hdspm_external_sample_rate(hdspm),
3139 struct hdspm *hdspm = entry->private_data;
3149 status = hdspm_read(hdspm, HDSPM_statusRegister);
3150 status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
3151 timecode = hdspm_read(hdspm, HDSPM_timecodeRegister);
3154 hdspm->card_name, hdspm->card->number + 1,
3155 hdspm->firmware_rev);
3158 hdspm->irq, hdspm->port, (unsigned long)hdspm->iobase);
3167 hdspm->irq_count);
3174 (2 * (int)hdspm->period_bytes),
3176 (2 * (int)hdspm->period_bytes),
3177 (long) hdspm_hw_pointer(hdspm) * 4);
3181 hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xFF,
3182 hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xFF,
3183 hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xFF,
3184 hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xFF);
3188 hdspm->control_register,
3193 x = 1 << (6 + hdspm_decode_latency(hdspm->control_register &
3198 x, (unsigned long) hdspm->period_bytes);
3201 (hdspm->
3203 (hdspm->precise_ptr) ? "on" : "off");
3207 (hdspm->
3209 (hdspm->
3211 (hdspm->
3214 switch (hdspm_clock_source(hdspm)) {
3249 if (!(hdspm->control_register & HDSPM_ClockModeMaster))
3255 pref_syncref = hdspm_pref_sync_ref(hdspm);
3263 hdspm->system_sample_rate);
3266 hdspm->control_register & HDSPM_DS_DoubleWire?
3269 hdspm->control_register & HDSPM_QS_DoubleWire?
3271 hdspm->control_register & HDSPM_QS_QuadWire?
3288 switch (hdspm_autosync_ref(hdspm)) {
3311 struct hdspm *hdspm = entry->private_data;
3318 snd_iprintf(buffer, "%08X ", hdspm_read(hdspm, i + j));
3326 static void __devinit snd_hdspm_proc_init(struct hdspm * hdspm)
3330 if (!snd_card_proc_new(hdspm->card, "hdspm", &entry))
3331 snd_info_set_text_ops(entry, hdspm,
3332 hdspm->is_aes32 ?
3336 /* debug file to read all hdspm registers */
3337 if (!snd_card_proc_new(hdspm->card, "debug", &entry))
3338 snd_info_set_text_ops(entry, hdspm,
3344 hdspm intitialize
3347 static int snd_hdspm_set_defaults(struct hdspm * hdspm)
3351 /* ASSUMPTION: hdspm->lock is either held, or there is no need to
3357 if (hdspm->is_aes32)
3358 hdspm->control_register =
3367 hdspm->control_register =
3382 hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
3384 if (!hdspm->is_aes32) {
3387 hdspm->control2_register = HDSPM_BIGENDIAN_MODE;
3389 hdspm->control2_register = 0;
3392 hdspm_write(hdspm, HDSPM_control2Reg, hdspm->control2_register);
3394 hdspm_compute_period_size(hdspm);
3398 all_in_all_mixer(hdspm, 0 * UNITY_GAIN);
3400 if (line_outs_monitor[hdspm->dev]) {
3406 if (hdspm_write_pb_gain(hdspm, i, i, UNITY_GAIN))
3412 hdspm->channel_map = channel_map_madi_ss;
3413 hdspm_set_rate(hdspm, 44100, 1);
3425 struct hdspm *hdspm = (struct hdspm *) dev_id;
3434 status = hdspm_read(hdspm, HDSPM_statusRegister);
3443 hdspm_write(hdspm, HDSPM_interruptConfirmation, 0);
3444 hdspm->irq_count++;
3446 midi0status = hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xff;
3447 midi1status = hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xff;
3451 if (hdspm->capture_substream)
3452 snd_pcm_period_elapsed(hdspm->capture_substream);
3454 if (hdspm->playback_substream)
3455 snd_pcm_period_elapsed(hdspm->playback_substream);
3462 hdspm->control_register &= ~HDSPM_Midi0InterruptEnable;
3463 hdspm_write(hdspm, HDSPM_controlRegister,
3464 hdspm->control_register);
3465 hdspm->midi[0].pending = 1;
3472 hdspm->control_register &= ~HDSPM_Midi1InterruptEnable;
3473 hdspm_write(hdspm, HDSPM_controlRegister,
3474 hdspm->control_register);
3475 hdspm->midi[1].pending = 1;
3479 tasklet_schedule(&hdspm->midi_tasklet);
3491 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3492 return hdspm_hw_pointer(hdspm);
3495 static char *hdspm_channel_buffer_location(struct hdspm * hdspm,
3503 mapped_channel = hdspm->channel_map[channel];
3508 return hdspm->capture_buffer +
3511 return hdspm->playback_buffer +
3521 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3528 hdspm_channel_buffer_location(hdspm, substream->pstr->stream,
3541 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3548 hdspm_channel_buffer_location(hdspm, substream->pstr->stream,
3559 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3563 hdspm_channel_buffer_location(hdspm, substream->pstr->stream,
3574 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3578 other = hdspm->capture_substream;
3580 other = hdspm->playback_substream;
3582 if (hdspm->running)
3583 runtime->status->hw_ptr = hdspm_hw_pointer(hdspm);
3603 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3609 spin_lock_irq(&hdspm->lock);
3612 this_pid = hdspm->playback_pid;
3613 other_pid = hdspm->capture_pid;
3615 this_pid = hdspm->capture_pid;
3616 other_pid = hdspm->playback_pid;
3626 if (params_rate(params) != hdspm->system_sample_rate) {
3627 spin_unlock_irq(&hdspm->lock);
3633 if (params_period_size(params) != hdspm->period_bytes / 4) {
3634 spin_unlock_irq(&hdspm->lock);
3642 spin_unlock_irq(&hdspm->lock);
3646 spin_lock_irq(&hdspm->lock);
3647 err = hdspm_set_rate(hdspm, params_rate(params), 0);
3649 spin_unlock_irq(&hdspm->lock);
3654 spin_unlock_irq(&hdspm->lock);
3656 err = hdspm_set_interrupt_interval(hdspm,
3677 hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferOut,
3681 snd_hdspm_enable_out(hdspm, i, 1);
3683 hdspm->playback_buffer =
3686 hdspm->playback_buffer);
3688 hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferIn,
3692 snd_hdspm_enable_in(hdspm, i, 1);
3694 hdspm->capture_buffer =
3697 hdspm->capture_buffer);
3718 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3725 snd_hdspm_enable_out(hdspm, i, 0);
3727 hdspm->playback_buffer = NULL;
3730 snd_hdspm_enable_in(hdspm, i, 0);
3732 hdspm->capture_buffer = NULL;
3744 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3750 mapped_channel = hdspm->channel_map[info->channel];
3781 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3785 spin_lock(&hdspm->lock);
3786 running = hdspm->running;
3796 spin_unlock(&hdspm->lock);
3800 other = hdspm->capture_substream;
3802 other = hdspm->playback_substream;
3820 hdspm_silence_playback(hdspm);
3824 hdspm_silence_playback(hdspm);
3828 hdspm_silence_playback(hdspm);
3832 if (!hdspm->running && running)
3833 hdspm_start_audio(hdspm);
3834 else if (hdspm->running && !running)
3835 hdspm_stop_audio(hdspm);
3836 hdspm->running = running;
3837 spin_unlock(&hdspm->lock);
3910 struct hdspm *hdspm = rule->private;
3918 .min = hdspm->ds_channels,
3919 .max = hdspm->ds_channels,
3925 .min = hdspm->ss_channels,
3926 .max = hdspm->ss_channels,
3937 struct hdspm *hdspm = rule->private;
3943 if (c->min >= hdspm->ss_channels) {
3950 } else if (c->max <= hdspm->ds_channels) {
3966 struct hdspm *hdspm = rule->private;
3969 if (hdspm->is_aes32) {
3970 list[0] = hdspm->qs_channels;
3971 list[1] = hdspm->ds_channels;
3972 list[2] = hdspm->ss_channels;
3975 list[0] = hdspm->ds_channels;
3976 list[1] = hdspm->ss_channels;
3995 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
3998 spin_lock_irq(&hdspm->lock);
4004 if (hdspm->capture_substream == NULL)
4005 hdspm_stop_audio(hdspm);
4007 hdspm->playback_pid = current->pid;
4008 hdspm->playback_substream = substream;
4010 spin_unlock_irq(&hdspm->lock);
4018 if (hdspm->is_aes32) {
4023 snd_hdspm_hw_rule_channels, hdspm,
4026 snd_hdspm_hw_rule_channels_rate, hdspm,
4030 snd_hdspm_hw_rule_rate_channels, hdspm,
4038 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
4040 spin_lock_irq(&hdspm->lock);
4042 hdspm->playback_pid = -1;
4043 hdspm->playback_substream = NULL;
4045 spin_unlock_irq(&hdspm->lock);
4053 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
4056 spin_lock_irq(&hdspm->lock);
4060 if (hdspm->playback_substream == NULL)
4061 hdspm_stop_audio(hdspm);
4063 hdspm->capture_pid = current->pid;
4064 hdspm->capture_substream = substream;
4066 spin_unlock_irq(&hdspm->lock);
4072 if (hdspm->is_aes32) {
4077 snd_hdspm_hw_rule_channels, hdspm,
4080 snd_hdspm_hw_rule_channels_rate, hdspm,
4084 snd_hdspm_hw_rule_rate_channels, hdspm,
4092 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
4094 spin_lock_irq(&hdspm->lock);
4096 hdspm->capture_pid = -1;
4097 hdspm->capture_substream = NULL;
4099 spin_unlock_irq(&hdspm->lock);
4106 struct hdspm *hdspm = hw->private_data;
4121 hdspm->iobase+HDSPM_MADI_peakrmsbase,
4131 spin_lock_irq(&hdspm->lock);
4132 info.pref_sync_ref = hdspm_pref_sync_ref(hdspm);
4133 info.wordclock_sync_check = hdspm_wc_sync_check(hdspm);
4135 info.system_sample_rate = hdspm->system_sample_rate;
4137 hdspm_external_sample_rate(hdspm);
4138 info.system_clock_mode = hdspm_system_clock_mode(hdspm);
4139 info.clock_source = hdspm_clock_source(hdspm);
4140 info.autosync_ref = hdspm_autosync_ref(hdspm);
4141 info.line_out = hdspm_line_out(hdspm);
4143 spin_unlock_irq(&hdspm->lock);
4149 hdspm_version.firmware_rev = hdspm->firmware_rev;
4158 if (copy_to_user((void __user *)mixer.mixer, hdspm->mixer,
4197 struct hdspm * hdspm)
4206 hdspm->hwdep = hw;
4207 hw->private_data = hdspm;
4219 static int __devinit snd_hdspm_preallocate_memory(struct hdspm * hdspm)
4225 pcm = hdspm->pcm;
4232 snd_dma_pci_data(hdspm->pci),
4245 static void hdspm_set_sgbuf(struct hdspm * hdspm,
4251 hdspm_write(hdspm, reg + 4 * i,
4257 struct hdspm * hdspm)
4262 err = snd_pcm_new(card, hdspm->card_name, 0, 1, 1, &pcm);
4266 hdspm->pcm = pcm;
4267 pcm->private_data = hdspm;
4268 strcpy(pcm->name, hdspm->card_name);
4277 err = snd_hdspm_preallocate_memory(hdspm);
4284 static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm)
4286 snd_hdspm_flush_midi_input(hdspm, 0);
4287 snd_hdspm_flush_midi_input(hdspm, 1);
4291 struct hdspm * hdspm)
4296 err = snd_hdspm_create_pcm(card, hdspm);
4300 err = snd_hdspm_create_midi(card, hdspm, 0);
4304 err = snd_hdspm_create_midi(card, hdspm, 1);
4308 err = snd_hdspm_create_controls(card, hdspm);
4312 err = snd_hdspm_create_hwdep(card, hdspm);
4317 snd_hdspm_proc_init(hdspm);
4319 hdspm->system_sample_rate = -1;
4320 hdspm->last_external_sample_rate = -1;
4321 hdspm->last_internal_sample_rate = -1;
4322 hdspm->playback_pid = -1;
4323 hdspm->capture_pid = -1;
4324 hdspm->capture_substream = NULL;
4325 hdspm->playback_substream = NULL;
4328 err = snd_hdspm_set_defaults(hdspm);
4333 hdspm_update_simple_mixer_controls(hdspm);
4349 struct hdspm *hdspm,
4352 struct pci_dev *pci = hdspm->pci;
4356 hdspm->irq = -1;
4358 spin_lock_init(&hdspm->midi[0].lock);
4359 spin_lock_init(&hdspm->midi[1].lock);
4361 hdspm->card = card;
4363 spin_lock_init(&hdspm->lock);
4365 tasklet_init(&hdspm->midi_tasklet,
4366 hdspm_midi_tasklet, (unsigned long) hdspm);
4368 pci_read_config_word(hdspm->pci,
4369 PCI_CLASS_REVISION, &hdspm->firmware_rev);
4371 hdspm->is_aes32 = (hdspm->firmware_rev >= HDSPM_AESREVISION);
4374 if (hdspm->is_aes32) {
4376 hdspm->card_name = "RME HDSPM AES32";
4379 hdspm->card_name = "RME HDSPM MADI";
4386 pci_set_master(hdspm->pci);
4388 err = pci_request_regions(pci, "hdspm");
4392 hdspm->port = pci_resource_start(pci, 0);
4396 hdspm->port, hdspm->port + io_extent - 1);
4399 hdspm->iobase = ioremap_nocache(hdspm->port, io_extent);
4400 if (!hdspm->iobase) {
4403 hdspm->port, hdspm->port + io_extent - 1);
4407 (unsigned long)hdspm->iobase, hdspm->port,
4408 hdspm->port + io_extent - 1);
4411 IRQF_SHARED, "hdspm", hdspm)) {
4418 hdspm->irq = pci->irq;
4419 hdspm->precise_ptr = precise_ptr;
4421 hdspm->monitor_outs = enable_monitor;
4425 hdspm->mixer = kzalloc(sizeof(struct hdspm_mixer), GFP_KERNEL);
4426 if (!hdspm->mixer) {
4433 hdspm->ss_channels = MADI_SS_CHANNELS;
4434 hdspm->ds_channels = MADI_DS_CHANNELS;
4435 hdspm->qs_channels = MADI_QS_CHANNELS;
4438 err = snd_hdspm_create_alsa_devices(card, hdspm);
4442 snd_hdspm_initialize_midi_flush(hdspm);
4447 static int snd_hdspm_free(struct hdspm * hdspm)
4450 if (hdspm->port) {
4453 hdspm->control_register &=
4456 hdspm_write(hdspm, HDSPM_controlRegister,
4457 hdspm->control_register);
4460 if (hdspm->irq >= 0)
4461 free_irq(hdspm->irq, (void *) hdspm);
4463 kfree(hdspm->mixer);
4465 if (hdspm->iobase)
4466 iounmap(hdspm->iobase);
4468 if (hdspm->port)
4469 pci_release_regions(hdspm->pci);
4471 pci_disable_device(hdspm->pci);
4477 struct hdspm *hdspm = card->private_data;
4479 if (hdspm)
4480 snd_hdspm_free(hdspm);
4487 struct hdspm *hdspm;
4499 THIS_MODULE, sizeof(struct hdspm), &card);
4503 hdspm = card->private_data;
4505 hdspm->dev = dev;
4506 hdspm->pci = pci;
4510 err = snd_hdspm_create(card, hdspm, precise_ptr[dev],
4518 sprintf(card->longname, "%s at 0x%lx, irq %d", hdspm->card_name,
4519 hdspm->port, hdspm->irq);