aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci/ca0106/ca_midi.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/pci/ca0106/ca_midi.c')
-rw-r--r--sound/pci/ca0106/ca_midi.c304
1 files changed, 304 insertions, 0 deletions
diff --git a/sound/pci/ca0106/ca_midi.c b/sound/pci/ca0106/ca_midi.c
new file mode 100644
index 000000000000..f439d14876b0
--- /dev/null
+++ b/sound/pci/ca0106/ca_midi.c
@@ -0,0 +1,304 @@
1/*
2 * Copyright 10/16/2005 Tilman Kranz <tilde@tk-sls.de>
3 * Creative Audio MIDI, for the CA0106 Driver
4 * Version: 0.0.1
5 *
6 * Changelog:
7 * Implementation is based on mpu401 and emu10k1x and
8 * tested with ca0106.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 *
25 */
26
27#include <linux/spinlock.h>
28#include <sound/driver.h>
29#include <sound/core.h>
30#include <sound/rawmidi.h>
31
32#include "ca_midi.h"
33
34#define ca_midi_write_data(midi, data) midi->write(midi, data, 0)
35#define ca_midi_write_cmd(midi, data) midi->write(midi, data, 1)
36#define ca_midi_read_data(midi) midi->read(midi, 0)
37#define ca_midi_read_stat(midi) midi->read(midi, 1)
38#define ca_midi_input_avail(midi) (!(ca_midi_read_stat(midi) & midi->input_avail))
39#define ca_midi_output_ready(midi) (!(ca_midi_read_stat(midi) & midi->output_ready))
40
41static void ca_midi_clear_rx(ca_midi_t *midi)
42{
43 int timeout = 100000;
44 for (; timeout > 0 && ca_midi_input_avail(midi); timeout--)
45 ca_midi_read_data(midi);
46#ifdef CONFIG_SND_DEBUG
47 if (timeout <= 0)
48 snd_printk(KERN_ERR "ca_midi_clear_rx: timeout (status = 0x%x)\n", ca_midi_read_stat(midi));
49#endif
50}
51
52void ca_midi_interrupt(ca_midi_t *midi, unsigned int status) {
53 unsigned char byte;
54
55 if (midi->rmidi == NULL) {
56 midi->interrupt_disable(midi,midi->tx_enable | midi->rx_enable);
57 return;
58 }
59
60 spin_lock(&midi->input_lock);
61 if ((status & midi->ipr_rx) && ca_midi_input_avail(midi)) {
62 if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
63 ca_midi_clear_rx(midi);
64 } else {
65 byte = ca_midi_read_data(midi);
66 if(midi->substream_input)
67 snd_rawmidi_receive(midi->substream_input, &byte, 1);
68
69
70 }
71 }
72 spin_unlock(&midi->input_lock);
73
74 spin_lock(&midi->output_lock);
75 if ((status & midi->ipr_tx) && ca_midi_output_ready(midi)) {
76 if (midi->substream_output &&
77 snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
78 ca_midi_write_data(midi, byte);
79 } else {
80 midi->interrupt_disable(midi,midi->tx_enable);
81 }
82 }
83 spin_unlock(&midi->output_lock);
84
85}
86
87static void ca_midi_cmd(ca_midi_t *midi, unsigned char cmd, int ack)
88{
89 unsigned long flags;
90 int timeout, ok;
91
92 spin_lock_irqsave(&midi->input_lock, flags);
93 ca_midi_write_data(midi, 0x00);
94 /* ca_midi_clear_rx(midi); */
95
96 ca_midi_write_cmd(midi, cmd);
97 if (ack) {
98 ok = 0;
99 timeout = 10000;
100 while (!ok && timeout-- > 0) {
101 if (ca_midi_input_avail(midi)) {
102 if (ca_midi_read_data(midi) == midi->ack)
103 ok = 1;
104 }
105 }
106 if (!ok && ca_midi_read_data(midi) == midi->ack)
107 ok = 1;
108 } else {
109 ok = 1;
110 }
111 spin_unlock_irqrestore(&midi->input_lock, flags);
112 if (!ok)
113 snd_printk(KERN_ERR "ca_midi_cmd: 0x%x failed at 0x%x (status = 0x%x, data = 0x%x)!!!\n",
114 cmd,
115 midi->get_dev_id_port(midi->dev_id),
116 ca_midi_read_stat(midi),
117 ca_midi_read_data(midi));
118}
119
120static int ca_midi_input_open(snd_rawmidi_substream_t * substream)
121{
122 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
123 unsigned long flags;
124
125 snd_assert(midi->dev_id, return -ENXIO);
126 spin_lock_irqsave(&midi->open_lock, flags);
127 midi->midi_mode |= CA_MIDI_MODE_INPUT;
128 midi->substream_input = substream;
129 if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
130 spin_unlock_irqrestore(&midi->open_lock, flags);
131 ca_midi_cmd(midi, midi->reset, 1);
132 ca_midi_cmd(midi, midi->enter_uart, 1);
133 } else {
134 spin_unlock_irqrestore(&midi->open_lock, flags);
135 }
136 return 0;
137}
138
139static int ca_midi_output_open(snd_rawmidi_substream_t * substream)
140{
141 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
142 unsigned long flags;
143
144 snd_assert(midi->dev_id, return -ENXIO);
145 spin_lock_irqsave(&midi->open_lock, flags);
146 midi->midi_mode |= CA_MIDI_MODE_OUTPUT;
147 midi->substream_output = substream;
148 if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
149 spin_unlock_irqrestore(&midi->open_lock, flags);
150 ca_midi_cmd(midi, midi->reset, 1);
151 ca_midi_cmd(midi, midi->enter_uart, 1);
152 } else {
153 spin_unlock_irqrestore(&midi->open_lock, flags);
154 }
155 return 0;
156}
157
158static int ca_midi_input_close(snd_rawmidi_substream_t * substream)
159{
160 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
161 unsigned long flags;
162
163 snd_assert(midi->dev_id, return -ENXIO);
164 spin_lock_irqsave(&midi->open_lock, flags);
165 midi->interrupt_disable(midi,midi->rx_enable);
166 midi->midi_mode &= ~CA_MIDI_MODE_INPUT;
167 midi->substream_input = NULL;
168 if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT)) {
169 spin_unlock_irqrestore(&midi->open_lock, flags);
170 ca_midi_cmd(midi, midi->reset, 0);
171 } else {
172 spin_unlock_irqrestore(&midi->open_lock, flags);
173 }
174 return 0;
175}
176
177static int ca_midi_output_close(snd_rawmidi_substream_t * substream)
178{
179 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
180 unsigned long flags;
181 snd_assert(midi->dev_id, return -ENXIO);
182
183 spin_lock_irqsave(&midi->open_lock, flags);
184
185 midi->interrupt_disable(midi,midi->tx_enable);
186 midi->midi_mode &= ~CA_MIDI_MODE_OUTPUT;
187 midi->substream_output = NULL;
188
189 if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
190 spin_unlock_irqrestore(&midi->open_lock, flags);
191 ca_midi_cmd(midi, midi->reset, 0);
192 } else {
193 spin_unlock_irqrestore(&midi->open_lock, flags);
194 }
195 return 0;
196}
197
198static void ca_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
199{
200 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
201 snd_assert(midi->dev_id, return);
202
203 if (up) {
204 midi->interrupt_enable(midi,midi->rx_enable);
205 } else {
206 midi->interrupt_disable(midi, midi->rx_enable);
207 }
208}
209
210static void ca_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
211{
212 ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data;
213 unsigned long flags;
214
215 snd_assert(midi->dev_id, return);
216
217 if (up) {
218 int max = 4;
219 unsigned char byte;
220
221 spin_lock_irqsave(&midi->output_lock, flags);
222
223 /* try to send some amount of bytes here before interrupts */
224 while (max > 0) {
225 if (ca_midi_output_ready(midi)) {
226 if (!(midi->midi_mode & CA_MIDI_MODE_OUTPUT) ||
227 snd_rawmidi_transmit(substream, &byte, 1) != 1) {
228 /* no more data */
229 spin_unlock_irqrestore(&midi->output_lock, flags);
230 return;
231 }
232 ca_midi_write_data(midi, byte);
233 max--;
234 } else {
235 break;
236 }
237 }
238
239 spin_unlock_irqrestore(&midi->output_lock, flags);
240 midi->interrupt_enable(midi,midi->tx_enable);
241
242 } else {
243 midi->interrupt_disable(midi,midi->tx_enable);
244 }
245}
246
247static snd_rawmidi_ops_t ca_midi_output =
248{
249 .open = ca_midi_output_open,
250 .close = ca_midi_output_close,
251 .trigger = ca_midi_output_trigger,
252};
253
254static snd_rawmidi_ops_t ca_midi_input =
255{
256 .open = ca_midi_input_open,
257 .close = ca_midi_input_close,
258 .trigger = ca_midi_input_trigger,
259};
260
261void ca_midi_free(ca_midi_t *midi) {
262 midi->interrupt = NULL;
263 midi->interrupt_enable = NULL;
264 midi->interrupt_disable = NULL;
265 midi->read = NULL;
266 midi->write = NULL;
267 midi->get_dev_id_card = NULL;
268 midi->get_dev_id_port = NULL;
269 midi->rmidi = NULL;
270}
271
272static void ca_rmidi_free(snd_rawmidi_t *rmidi)
273{
274 ca_midi_free((ca_midi_t *)rmidi->private_data);
275}
276
277int __devinit ca_midi_init(void *dev_id, ca_midi_t *midi, int device, char *name)
278{
279 snd_rawmidi_t *rmidi;
280 int err;
281
282 if ((err = snd_rawmidi_new(midi->get_dev_id_card(midi->dev_id), name, device, 1, 1, &rmidi)) < 0)
283 return err;
284
285 midi->dev_id = dev_id;
286 midi->interrupt = ca_midi_interrupt;
287
288 spin_lock_init(&midi->open_lock);
289 spin_lock_init(&midi->input_lock);
290 spin_lock_init(&midi->output_lock);
291
292 strcpy(rmidi->name, name);
293 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &ca_midi_output);
294 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &ca_midi_input);
295 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
296 SNDRV_RAWMIDI_INFO_INPUT |
297 SNDRV_RAWMIDI_INFO_DUPLEX;
298 rmidi->private_data = midi;
299 rmidi->private_free = ca_rmidi_free;
300
301 midi->rmidi = rmidi;
302 return 0;
303}
304
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-31 09:28:06 -0400