gus_irq.c 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. /*
  2. * Routine for IRQ handling from GF1/InterWave chip
  3. * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
  4. *
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. *
  20. */
  21. #include <sound/driver.h>
  22. #include <sound/core.h>
  23. #include <sound/info.h>
  24. #include <sound/gus.h>
  25. #ifdef CONFIG_SND_DEBUG
  26. #define STAT_ADD(x) ((x)++)
  27. #else
  28. #define STAT_ADD(x) while (0) { ; }
  29. #endif
  30. irqreturn_t snd_gus_interrupt(int irq, void *dev_id)
  31. {
  32. struct snd_gus_card * gus = dev_id;
  33. unsigned char status;
  34. int loop = 100;
  35. int handled = 0;
  36. __again:
  37. status = inb(gus->gf1.reg_irqstat);
  38. if (status == 0)
  39. return IRQ_RETVAL(handled);
  40. handled = 1;
  41. // snd_printk("IRQ: status = 0x%x\n", status);
  42. if (status & 0x02) {
  43. STAT_ADD(gus->gf1.interrupt_stat_midi_in);
  44. gus->gf1.interrupt_handler_midi_in(gus);
  45. }
  46. if (status & 0x01) {
  47. STAT_ADD(gus->gf1.interrupt_stat_midi_out);
  48. gus->gf1.interrupt_handler_midi_out(gus);
  49. }
  50. if (status & (0x20 | 0x40)) {
  51. unsigned int already, _current_;
  52. unsigned char voice_status, voice;
  53. struct snd_gus_voice *pvoice;
  54. already = 0;
  55. while (((voice_status = snd_gf1_i_read8(gus, SNDRV_GF1_GB_VOICES_IRQ)) & 0xc0) != 0xc0) {
  56. voice = voice_status & 0x1f;
  57. _current_ = 1 << voice;
  58. if (already & _current_)
  59. continue; /* multi request */
  60. already |= _current_; /* mark request */
  61. #if 0
  62. printk("voice = %i, voice_status = 0x%x, voice_verify = %i\n", voice, voice_status, inb(GUSP(gus, GF1PAGE)));
  63. #endif
  64. pvoice = &gus->gf1.voices[voice];
  65. if (pvoice->use) {
  66. if (!(voice_status & 0x80)) { /* voice position IRQ */
  67. STAT_ADD(pvoice->interrupt_stat_wave);
  68. pvoice->handler_wave(gus, pvoice);
  69. }
  70. if (!(voice_status & 0x40)) { /* volume ramp IRQ */
  71. STAT_ADD(pvoice->interrupt_stat_volume);
  72. pvoice->handler_volume(gus, pvoice);
  73. }
  74. } else {
  75. STAT_ADD(gus->gf1.interrupt_stat_voice_lost);
  76. snd_gf1_i_ctrl_stop(gus, SNDRV_GF1_VB_ADDRESS_CONTROL);
  77. snd_gf1_i_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
  78. }
  79. }
  80. }
  81. if (status & 0x04) {
  82. STAT_ADD(gus->gf1.interrupt_stat_timer1);
  83. gus->gf1.interrupt_handler_timer1(gus);
  84. }
  85. if (status & 0x08) {
  86. STAT_ADD(gus->gf1.interrupt_stat_timer2);
  87. gus->gf1.interrupt_handler_timer2(gus);
  88. }
  89. if (status & 0x80) {
  90. if (snd_gf1_i_look8(gus, SNDRV_GF1_GB_DRAM_DMA_CONTROL) & 0x40) {
  91. STAT_ADD(gus->gf1.interrupt_stat_dma_write);
  92. gus->gf1.interrupt_handler_dma_write(gus);
  93. }
  94. if (snd_gf1_i_look8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL) & 0x40) {
  95. STAT_ADD(gus->gf1.interrupt_stat_dma_read);
  96. gus->gf1.interrupt_handler_dma_read(gus);
  97. }
  98. }
  99. if (--loop > 0)
  100. goto __again;
  101. return IRQ_NONE;
  102. }
  103. #ifdef CONFIG_SND_DEBUG
  104. static void snd_gus_irq_info_read(struct snd_info_entry *entry,
  105. struct snd_info_buffer *buffer)
  106. {
  107. struct snd_gus_card *gus;
  108. struct snd_gus_voice *pvoice;
  109. int idx;
  110. gus = entry->private_data;
  111. snd_iprintf(buffer, "midi out = %u\n", gus->gf1.interrupt_stat_midi_out);
  112. snd_iprintf(buffer, "midi in = %u\n", gus->gf1.interrupt_stat_midi_in);
  113. snd_iprintf(buffer, "timer1 = %u\n", gus->gf1.interrupt_stat_timer1);
  114. snd_iprintf(buffer, "timer2 = %u\n", gus->gf1.interrupt_stat_timer2);
  115. snd_iprintf(buffer, "dma write = %u\n", gus->gf1.interrupt_stat_dma_write);
  116. snd_iprintf(buffer, "dma read = %u\n", gus->gf1.interrupt_stat_dma_read);
  117. snd_iprintf(buffer, "voice lost = %u\n", gus->gf1.interrupt_stat_voice_lost);
  118. for (idx = 0; idx < 32; idx++) {
  119. pvoice = &gus->gf1.voices[idx];
  120. snd_iprintf(buffer, "voice %i: wave = %u, volume = %u\n",
  121. idx,
  122. pvoice->interrupt_stat_wave,
  123. pvoice->interrupt_stat_volume);
  124. }
  125. }
  126. void snd_gus_irq_profile_init(struct snd_gus_card *gus)
  127. {
  128. struct snd_info_entry *entry;
  129. if (! snd_card_proc_new(gus->card, "gusirq", &entry))
  130. snd_info_set_text_ops(entry, gus, snd_gus_irq_info_read);
  131. }
  132. #endif