ca_midi.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright 10/16/2005 Tilman Kranz <[email protected]>
  4. * Creative Audio MIDI, for the CA0106 Driver
  5. * Version: 0.0.1
  6. *
  7. * Changelog:
  8. * Implementation is based on mpu401 and emu10k1x and
  9. * tested with ca0106.
  10. * mpu401: Copyright (c) by Jaroslav Kysela <[email protected]>
  11. * emu10k1x: Copyright (c) by Francisco Moraes <[email protected]>
  12. */
  13. #include <linux/spinlock.h>
  14. #include <sound/core.h>
  15. #include <sound/rawmidi.h>
  16. #include "ca_midi.h"
  17. #define ca_midi_write_data(midi, data) midi->write(midi, data, 0)
  18. #define ca_midi_write_cmd(midi, data) midi->write(midi, data, 1)
  19. #define ca_midi_read_data(midi) midi->read(midi, 0)
  20. #define ca_midi_read_stat(midi) midi->read(midi, 1)
  21. #define ca_midi_input_avail(midi) (!(ca_midi_read_stat(midi) & midi->input_avail))
  22. #define ca_midi_output_ready(midi) (!(ca_midi_read_stat(midi) & midi->output_ready))
  23. static void ca_midi_clear_rx(struct snd_ca_midi *midi)
  24. {
  25. int timeout = 100000;
  26. for (; timeout > 0 && ca_midi_input_avail(midi); timeout--)
  27. ca_midi_read_data(midi);
  28. #ifdef CONFIG_SND_DEBUG
  29. if (timeout <= 0)
  30. pr_err("ca_midi_clear_rx: timeout (status = 0x%x)\n",
  31. ca_midi_read_stat(midi));
  32. #endif
  33. }
  34. static void ca_midi_interrupt(struct snd_ca_midi *midi, unsigned int status)
  35. {
  36. unsigned char byte;
  37. if (midi->rmidi == NULL) {
  38. midi->interrupt_disable(midi,midi->tx_enable | midi->rx_enable);
  39. return;
  40. }
  41. spin_lock(&midi->input_lock);
  42. if ((status & midi->ipr_rx) && ca_midi_input_avail(midi)) {
  43. if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
  44. ca_midi_clear_rx(midi);
  45. } else {
  46. byte = ca_midi_read_data(midi);
  47. if(midi->substream_input)
  48. snd_rawmidi_receive(midi->substream_input, &byte, 1);
  49. }
  50. }
  51. spin_unlock(&midi->input_lock);
  52. spin_lock(&midi->output_lock);
  53. if ((status & midi->ipr_tx) && ca_midi_output_ready(midi)) {
  54. if (midi->substream_output &&
  55. snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
  56. ca_midi_write_data(midi, byte);
  57. } else {
  58. midi->interrupt_disable(midi,midi->tx_enable);
  59. }
  60. }
  61. spin_unlock(&midi->output_lock);
  62. }
  63. static void ca_midi_cmd(struct snd_ca_midi *midi, unsigned char cmd, int ack)
  64. {
  65. unsigned long flags;
  66. int timeout, ok;
  67. spin_lock_irqsave(&midi->input_lock, flags);
  68. ca_midi_write_data(midi, 0x00);
  69. /* ca_midi_clear_rx(midi); */
  70. ca_midi_write_cmd(midi, cmd);
  71. if (ack) {
  72. ok = 0;
  73. timeout = 10000;
  74. while (!ok && timeout-- > 0) {
  75. if (ca_midi_input_avail(midi)) {
  76. if (ca_midi_read_data(midi) == midi->ack)
  77. ok = 1;
  78. }
  79. }
  80. if (!ok && ca_midi_read_data(midi) == midi->ack)
  81. ok = 1;
  82. } else {
  83. ok = 1;
  84. }
  85. spin_unlock_irqrestore(&midi->input_lock, flags);
  86. if (!ok)
  87. pr_err("ca_midi_cmd: 0x%x failed at 0x%x (status = 0x%x, data = 0x%x)!!!\n",
  88. cmd,
  89. midi->get_dev_id_port(midi->dev_id),
  90. ca_midi_read_stat(midi),
  91. ca_midi_read_data(midi));
  92. }
  93. static int ca_midi_input_open(struct snd_rawmidi_substream *substream)
  94. {
  95. struct snd_ca_midi *midi = substream->rmidi->private_data;
  96. unsigned long flags;
  97. if (snd_BUG_ON(!midi->dev_id))
  98. return -ENXIO;
  99. spin_lock_irqsave(&midi->open_lock, flags);
  100. midi->midi_mode |= CA_MIDI_MODE_INPUT;
  101. midi->substream_input = substream;
  102. if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
  103. spin_unlock_irqrestore(&midi->open_lock, flags);
  104. ca_midi_cmd(midi, midi->reset, 1);
  105. ca_midi_cmd(midi, midi->enter_uart, 1);
  106. } else {
  107. spin_unlock_irqrestore(&midi->open_lock, flags);
  108. }
  109. return 0;
  110. }
  111. static int ca_midi_output_open(struct snd_rawmidi_substream *substream)
  112. {
  113. struct snd_ca_midi *midi = substream->rmidi->private_data;
  114. unsigned long flags;
  115. if (snd_BUG_ON(!midi->dev_id))
  116. return -ENXIO;
  117. spin_lock_irqsave(&midi->open_lock, flags);
  118. midi->midi_mode |= CA_MIDI_MODE_OUTPUT;
  119. midi->substream_output = substream;
  120. if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
  121. spin_unlock_irqrestore(&midi->open_lock, flags);
  122. ca_midi_cmd(midi, midi->reset, 1);
  123. ca_midi_cmd(midi, midi->enter_uart, 1);
  124. } else {
  125. spin_unlock_irqrestore(&midi->open_lock, flags);
  126. }
  127. return 0;
  128. }
  129. static int ca_midi_input_close(struct snd_rawmidi_substream *substream)
  130. {
  131. struct snd_ca_midi *midi = substream->rmidi->private_data;
  132. unsigned long flags;
  133. if (snd_BUG_ON(!midi->dev_id))
  134. return -ENXIO;
  135. spin_lock_irqsave(&midi->open_lock, flags);
  136. midi->interrupt_disable(midi,midi->rx_enable);
  137. midi->midi_mode &= ~CA_MIDI_MODE_INPUT;
  138. midi->substream_input = NULL;
  139. if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
  140. spin_unlock_irqrestore(&midi->open_lock, flags);
  141. ca_midi_cmd(midi, midi->reset, 0);
  142. } else {
  143. spin_unlock_irqrestore(&midi->open_lock, flags);
  144. }
  145. return 0;
  146. }
  147. static int ca_midi_output_close(struct snd_rawmidi_substream *substream)
  148. {
  149. struct snd_ca_midi *midi = substream->rmidi->private_data;
  150. unsigned long flags;
  151. if (snd_BUG_ON(!midi->dev_id))
  152. return -ENXIO;
  153. spin_lock_irqsave(&midi->open_lock, flags);
  154. midi->interrupt_disable(midi,midi->tx_enable);
  155. midi->midi_mode &= ~CA_MIDI_MODE_OUTPUT;
  156. midi->substream_output = NULL;
  157. if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
  158. spin_unlock_irqrestore(&midi->open_lock, flags);
  159. ca_midi_cmd(midi, midi->reset, 0);
  160. } else {
  161. spin_unlock_irqrestore(&midi->open_lock, flags);
  162. }
  163. return 0;
  164. }
  165. static void ca_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
  166. {
  167. struct snd_ca_midi *midi = substream->rmidi->private_data;
  168. if (snd_BUG_ON(!midi->dev_id))
  169. return;
  170. if (up) {
  171. midi->interrupt_enable(midi,midi->rx_enable);
  172. } else {
  173. midi->interrupt_disable(midi, midi->rx_enable);
  174. }
  175. }
  176. static void ca_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
  177. {
  178. struct snd_ca_midi *midi = substream->rmidi->private_data;
  179. unsigned long flags;
  180. if (snd_BUG_ON(!midi->dev_id))
  181. return;
  182. if (up) {
  183. int max = 4;
  184. unsigned char byte;
  185. spin_lock_irqsave(&midi->output_lock, flags);
  186. /* try to send some amount of bytes here before interrupts */
  187. while (max > 0) {
  188. if (ca_midi_output_ready(midi)) {
  189. if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT) ||
  190. snd_rawmidi_transmit(substream, &byte, 1) != 1) {
  191. /* no more data */
  192. spin_unlock_irqrestore(&midi->output_lock, flags);
  193. return;
  194. }
  195. ca_midi_write_data(midi, byte);
  196. max--;
  197. } else {
  198. break;
  199. }
  200. }
  201. spin_unlock_irqrestore(&midi->output_lock, flags);
  202. midi->interrupt_enable(midi,midi->tx_enable);
  203. } else {
  204. midi->interrupt_disable(midi,midi->tx_enable);
  205. }
  206. }
  207. static const struct snd_rawmidi_ops ca_midi_output =
  208. {
  209. .open = ca_midi_output_open,
  210. .close = ca_midi_output_close,
  211. .trigger = ca_midi_output_trigger,
  212. };
  213. static const struct snd_rawmidi_ops ca_midi_input =
  214. {
  215. .open = ca_midi_input_open,
  216. .close = ca_midi_input_close,
  217. .trigger = ca_midi_input_trigger,
  218. };
  219. static void ca_midi_free(struct snd_ca_midi *midi)
  220. {
  221. midi->interrupt = NULL;
  222. midi->interrupt_enable = NULL;
  223. midi->interrupt_disable = NULL;
  224. midi->read = NULL;
  225. midi->write = NULL;
  226. midi->get_dev_id_card = NULL;
  227. midi->get_dev_id_port = NULL;
  228. midi->rmidi = NULL;
  229. }
  230. static void ca_rmidi_free(struct snd_rawmidi *rmidi)
  231. {
  232. ca_midi_free(rmidi->private_data);
  233. }
  234. int ca_midi_init(void *dev_id, struct snd_ca_midi *midi, int device, char *name)
  235. {
  236. struct snd_rawmidi *rmidi;
  237. int err;
  238. err = snd_rawmidi_new(midi->get_dev_id_card(midi->dev_id), name, device, 1, 1, &rmidi);
  239. if (err < 0)
  240. return err;
  241. midi->dev_id = dev_id;
  242. midi->interrupt = ca_midi_interrupt;
  243. spin_lock_init(&midi->open_lock);
  244. spin_lock_init(&midi->input_lock);
  245. spin_lock_init(&midi->output_lock);
  246. strcpy(rmidi->name, name);
  247. snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &ca_midi_output);
  248. snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &ca_midi_input);
  249. rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
  250. SNDRV_RAWMIDI_INFO_INPUT |
  251. SNDRV_RAWMIDI_INFO_DUPLEX;
  252. rmidi->private_data = midi;
  253. rmidi->private_free = ca_rmidi_free;
  254. midi->rmidi = rmidi;
  255. return 0;
  256. }