1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Generic MIDI synth driver for ALSA sequencer |
4 | * Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl> |
5 | * Jaroslav Kysela <perex@perex.cz> |
6 | */ |
7 | |
8 | /* |
9 | Possible options for midisynth module: |
10 | - automatic opening of midi ports on first received event or subscription |
11 | (close will be performed when client leaves) |
12 | */ |
13 | |
14 | |
15 | #include <linux/init.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/errno.h> |
18 | #include <linux/string.h> |
19 | #include <linux/module.h> |
20 | #include <linux/mutex.h> |
21 | #include <sound/core.h> |
22 | #include <sound/rawmidi.h> |
23 | #include <sound/seq_kernel.h> |
24 | #include <sound/seq_device.h> |
25 | #include <sound/seq_midi_event.h> |
26 | #include <sound/initval.h> |
27 | |
28 | MODULE_AUTHOR("Frank van de Pol <fvdpol@coil.demon.nl>, Jaroslav Kysela <perex@perex.cz>" ); |
29 | MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI synth." ); |
30 | MODULE_LICENSE("GPL" ); |
31 | static int output_buffer_size = PAGE_SIZE; |
32 | module_param(output_buffer_size, int, 0644); |
33 | MODULE_PARM_DESC(output_buffer_size, "Output buffer size in bytes." ); |
34 | static int input_buffer_size = PAGE_SIZE; |
35 | module_param(input_buffer_size, int, 0644); |
36 | MODULE_PARM_DESC(input_buffer_size, "Input buffer size in bytes." ); |
37 | |
38 | /* data for this midi synth driver */ |
39 | struct seq_midisynth { |
40 | struct snd_card *card; |
41 | struct snd_rawmidi *rmidi; |
42 | int device; |
43 | int subdevice; |
44 | struct snd_rawmidi_file input_rfile; |
45 | struct snd_rawmidi_file output_rfile; |
46 | int seq_client; |
47 | int seq_port; |
48 | struct snd_midi_event *parser; |
49 | }; |
50 | |
51 | struct seq_midisynth_client { |
52 | int seq_client; |
53 | int num_ports; |
54 | int ports_per_device[SNDRV_RAWMIDI_DEVICES]; |
55 | struct seq_midisynth *ports[SNDRV_RAWMIDI_DEVICES]; |
56 | }; |
57 | |
58 | static struct seq_midisynth_client *synths[SNDRV_CARDS]; |
59 | static DEFINE_MUTEX(register_mutex); |
60 | |
61 | /* handle rawmidi input event (MIDI v1.0 stream) */ |
62 | static void snd_midi_input_event(struct snd_rawmidi_substream *substream) |
63 | { |
64 | struct snd_rawmidi_runtime *runtime; |
65 | struct seq_midisynth *msynth; |
66 | struct snd_seq_event ev; |
67 | char buf[16], *pbuf; |
68 | long res; |
69 | |
70 | if (substream == NULL) |
71 | return; |
72 | runtime = substream->runtime; |
73 | msynth = runtime->private_data; |
74 | if (msynth == NULL) |
75 | return; |
76 | memset(&ev, 0, sizeof(ev)); |
77 | while (runtime->avail > 0) { |
78 | res = snd_rawmidi_kernel_read(substream, buf, count: sizeof(buf)); |
79 | if (res <= 0) |
80 | continue; |
81 | if (msynth->parser == NULL) |
82 | continue; |
83 | pbuf = buf; |
84 | while (res-- > 0) { |
85 | if (!snd_midi_event_encode_byte(dev: msynth->parser, |
86 | c: *pbuf++, ev: &ev)) |
87 | continue; |
88 | ev.source.port = msynth->seq_port; |
89 | ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS; |
90 | snd_seq_kernel_client_dispatch(client: msynth->seq_client, ev: &ev, atomic: 1, hop: 0); |
91 | /* clear event and reset header */ |
92 | memset(&ev, 0, sizeof(ev)); |
93 | } |
94 | } |
95 | } |
96 | |
97 | static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, int count) |
98 | { |
99 | struct snd_rawmidi_runtime *runtime; |
100 | int tmp; |
101 | |
102 | if (snd_BUG_ON(!substream || !buf)) |
103 | return -EINVAL; |
104 | runtime = substream->runtime; |
105 | tmp = runtime->avail; |
106 | if (tmp < count) { |
107 | if (printk_ratelimit()) |
108 | pr_err("ALSA: seq_midi: MIDI output buffer overrun\n" ); |
109 | return -ENOMEM; |
110 | } |
111 | if (snd_rawmidi_kernel_write(substream, buf, count) < count) |
112 | return -EINVAL; |
113 | return 0; |
114 | } |
115 | |
116 | /* callback for snd_seq_dump_var_event(), bridging to dump_midi() */ |
117 | static int __dump_midi(void *ptr, void *buf, int count) |
118 | { |
119 | return dump_midi(substream: ptr, buf, count); |
120 | } |
121 | |
122 | static int event_process_midi(struct snd_seq_event *ev, int direct, |
123 | void *private_data, int atomic, int hop) |
124 | { |
125 | struct seq_midisynth *msynth = private_data; |
126 | unsigned char msg[10]; /* buffer for constructing midi messages */ |
127 | struct snd_rawmidi_substream *substream; |
128 | int len; |
129 | |
130 | if (snd_BUG_ON(!msynth)) |
131 | return -EINVAL; |
132 | substream = msynth->output_rfile.output; |
133 | if (substream == NULL) |
134 | return -ENODEV; |
135 | if (ev->type == SNDRV_SEQ_EVENT_SYSEX) { /* special case, to save space */ |
136 | if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) { |
137 | /* invalid event */ |
138 | pr_debug("ALSA: seq_midi: invalid sysex event flags = 0x%x\n" , ev->flags); |
139 | return 0; |
140 | } |
141 | snd_seq_dump_var_event(event: ev, func: __dump_midi, private_data: substream); |
142 | snd_midi_event_reset_decode(dev: msynth->parser); |
143 | } else { |
144 | if (msynth->parser == NULL) |
145 | return -EIO; |
146 | len = snd_midi_event_decode(dev: msynth->parser, buf: msg, count: sizeof(msg), ev); |
147 | if (len < 0) |
148 | return 0; |
149 | if (dump_midi(substream, buf: msg, count: len) < 0) |
150 | snd_midi_event_reset_decode(dev: msynth->parser); |
151 | } |
152 | return 0; |
153 | } |
154 | |
155 | |
156 | static int snd_seq_midisynth_new(struct seq_midisynth *msynth, |
157 | struct snd_card *card, |
158 | int device, |
159 | int subdevice) |
160 | { |
161 | if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, rdev: &msynth->parser) < 0) |
162 | return -ENOMEM; |
163 | msynth->card = card; |
164 | msynth->device = device; |
165 | msynth->subdevice = subdevice; |
166 | return 0; |
167 | } |
168 | |
169 | /* open associated midi device for input */ |
170 | static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe *info) |
171 | { |
172 | int err; |
173 | struct seq_midisynth *msynth = private_data; |
174 | struct snd_rawmidi_runtime *runtime; |
175 | struct snd_rawmidi_params params; |
176 | |
177 | /* open midi port */ |
178 | err = snd_rawmidi_kernel_open(rmidi: msynth->rmidi, subdevice: msynth->subdevice, |
179 | SNDRV_RAWMIDI_LFLG_INPUT, |
180 | rfile: &msynth->input_rfile); |
181 | if (err < 0) { |
182 | pr_debug("ALSA: seq_midi: midi input open failed!!!\n" ); |
183 | return err; |
184 | } |
185 | runtime = msynth->input_rfile.input->runtime; |
186 | memset(¶ms, 0, sizeof(params)); |
187 | params.avail_min = 1; |
188 | params.buffer_size = input_buffer_size; |
189 | err = snd_rawmidi_input_params(substream: msynth->input_rfile.input, params: ¶ms); |
190 | if (err < 0) { |
191 | snd_rawmidi_kernel_release(rfile: &msynth->input_rfile); |
192 | return err; |
193 | } |
194 | snd_midi_event_reset_encode(dev: msynth->parser); |
195 | runtime->event = snd_midi_input_event; |
196 | runtime->private_data = msynth; |
197 | snd_rawmidi_kernel_read(substream: msynth->input_rfile.input, NULL, count: 0); |
198 | return 0; |
199 | } |
200 | |
201 | /* close associated midi device for input */ |
202 | static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscribe *info) |
203 | { |
204 | int err; |
205 | struct seq_midisynth *msynth = private_data; |
206 | |
207 | if (snd_BUG_ON(!msynth->input_rfile.input)) |
208 | return -EINVAL; |
209 | err = snd_rawmidi_kernel_release(rfile: &msynth->input_rfile); |
210 | return err; |
211 | } |
212 | |
213 | /* open associated midi device for output */ |
214 | static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info) |
215 | { |
216 | int err; |
217 | struct seq_midisynth *msynth = private_data; |
218 | struct snd_rawmidi_params params; |
219 | |
220 | /* open midi port */ |
221 | err = snd_rawmidi_kernel_open(rmidi: msynth->rmidi, subdevice: msynth->subdevice, |
222 | SNDRV_RAWMIDI_LFLG_OUTPUT, |
223 | rfile: &msynth->output_rfile); |
224 | if (err < 0) { |
225 | pr_debug("ALSA: seq_midi: midi output open failed!!!\n" ); |
226 | return err; |
227 | } |
228 | memset(¶ms, 0, sizeof(params)); |
229 | params.avail_min = 1; |
230 | params.buffer_size = output_buffer_size; |
231 | params.no_active_sensing = 1; |
232 | err = snd_rawmidi_output_params(substream: msynth->output_rfile.output, params: ¶ms); |
233 | if (err < 0) { |
234 | snd_rawmidi_kernel_release(rfile: &msynth->output_rfile); |
235 | return err; |
236 | } |
237 | snd_midi_event_reset_decode(dev: msynth->parser); |
238 | return 0; |
239 | } |
240 | |
241 | /* close associated midi device for output */ |
242 | static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *info) |
243 | { |
244 | struct seq_midisynth *msynth = private_data; |
245 | |
246 | if (snd_BUG_ON(!msynth->output_rfile.output)) |
247 | return -EINVAL; |
248 | snd_rawmidi_drain_output(substream: msynth->output_rfile.output); |
249 | return snd_rawmidi_kernel_release(rfile: &msynth->output_rfile); |
250 | } |
251 | |
252 | /* delete given midi synth port */ |
253 | static void snd_seq_midisynth_delete(struct seq_midisynth *msynth) |
254 | { |
255 | if (msynth == NULL) |
256 | return; |
257 | |
258 | if (msynth->seq_client > 0) { |
259 | /* delete port */ |
260 | snd_seq_event_port_detach(client: msynth->seq_client, port: msynth->seq_port); |
261 | } |
262 | |
263 | snd_midi_event_free(dev: msynth->parser); |
264 | } |
265 | |
266 | /* register new midi synth port */ |
267 | static int |
268 | snd_seq_midisynth_probe(struct device *_dev) |
269 | { |
270 | struct snd_seq_device *dev = to_seq_dev(_dev); |
271 | struct seq_midisynth_client *client; |
272 | struct seq_midisynth *msynth, *ms; |
273 | struct snd_seq_port_info *port __free(kfree) = NULL; |
274 | struct snd_rawmidi_info *info __free(kfree) = NULL; |
275 | struct snd_rawmidi *rmidi = dev->private_data; |
276 | int newclient = 0; |
277 | unsigned int p, ports; |
278 | struct snd_seq_port_callback pcallbacks; |
279 | struct snd_card *card = dev->card; |
280 | int device = dev->device; |
281 | unsigned int input_count = 0, output_count = 0; |
282 | |
283 | if (snd_BUG_ON(!card || device < 0 || device >= SNDRV_RAWMIDI_DEVICES)) |
284 | return -EINVAL; |
285 | info = kmalloc(size: sizeof(*info), GFP_KERNEL); |
286 | if (! info) |
287 | return -ENOMEM; |
288 | info->device = device; |
289 | info->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; |
290 | info->subdevice = 0; |
291 | if (snd_rawmidi_info_select(card, info) >= 0) |
292 | output_count = info->subdevices_count; |
293 | info->stream = SNDRV_RAWMIDI_STREAM_INPUT; |
294 | if (snd_rawmidi_info_select(card, info) >= 0) { |
295 | input_count = info->subdevices_count; |
296 | } |
297 | ports = output_count; |
298 | if (ports < input_count) |
299 | ports = input_count; |
300 | if (ports == 0) |
301 | return -ENODEV; |
302 | if (ports > (256 / SNDRV_RAWMIDI_DEVICES)) |
303 | ports = 256 / SNDRV_RAWMIDI_DEVICES; |
304 | |
305 | guard(mutex)(T: ®ister_mutex); |
306 | client = synths[card->number]; |
307 | if (client == NULL) { |
308 | newclient = 1; |
309 | client = kzalloc(size: sizeof(*client), GFP_KERNEL); |
310 | if (client == NULL) |
311 | return -ENOMEM; |
312 | client->seq_client = |
313 | snd_seq_create_kernel_client( |
314 | card, client_index: 0, name_fmt: "%s" , card->shortname[0] ? |
315 | (const char *)card->shortname : "External MIDI" ); |
316 | if (client->seq_client < 0) { |
317 | kfree(objp: client); |
318 | return -ENOMEM; |
319 | } |
320 | } |
321 | |
322 | msynth = kcalloc(n: ports, size: sizeof(struct seq_midisynth), GFP_KERNEL); |
323 | port = kmalloc(size: sizeof(*port), GFP_KERNEL); |
324 | if (msynth == NULL || port == NULL) |
325 | goto __nomem; |
326 | |
327 | for (p = 0; p < ports; p++) { |
328 | ms = &msynth[p]; |
329 | ms->rmidi = rmidi; |
330 | |
331 | if (snd_seq_midisynth_new(msynth: ms, card, device, subdevice: p) < 0) |
332 | goto __nomem; |
333 | |
334 | /* declare port */ |
335 | memset(port, 0, sizeof(*port)); |
336 | port->addr.client = client->seq_client; |
337 | port->addr.port = device * (256 / SNDRV_RAWMIDI_DEVICES) + p; |
338 | port->flags = SNDRV_SEQ_PORT_FLG_GIVEN_PORT; |
339 | memset(info, 0, sizeof(*info)); |
340 | info->device = device; |
341 | if (p < output_count) |
342 | info->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; |
343 | else |
344 | info->stream = SNDRV_RAWMIDI_STREAM_INPUT; |
345 | info->subdevice = p; |
346 | if (snd_rawmidi_info_select(card, info) >= 0) |
347 | strcpy(p: port->name, q: info->subname); |
348 | if (! port->name[0]) { |
349 | if (info->name[0]) { |
350 | if (ports > 1) |
351 | scnprintf(buf: port->name, size: sizeof(port->name), fmt: "%s-%u" , info->name, p); |
352 | else |
353 | scnprintf(buf: port->name, size: sizeof(port->name), fmt: "%s" , info->name); |
354 | } else { |
355 | /* last resort */ |
356 | if (ports > 1) |
357 | sprintf(buf: port->name, fmt: "MIDI %d-%d-%u" , card->number, device, p); |
358 | else |
359 | sprintf(buf: port->name, fmt: "MIDI %d-%d" , card->number, device); |
360 | } |
361 | } |
362 | if ((info->flags & SNDRV_RAWMIDI_INFO_OUTPUT) && p < output_count) |
363 | port->capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SYNC_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE; |
364 | if ((info->flags & SNDRV_RAWMIDI_INFO_INPUT) && p < input_count) |
365 | port->capability |= SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SYNC_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ; |
366 | if ((port->capability & (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_READ)) == (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_READ) && |
367 | info->flags & SNDRV_RAWMIDI_INFO_DUPLEX) |
368 | port->capability |= SNDRV_SEQ_PORT_CAP_DUPLEX; |
369 | if (port->capability & SNDRV_SEQ_PORT_CAP_READ) |
370 | port->direction |= SNDRV_SEQ_PORT_DIR_INPUT; |
371 | if (port->capability & SNDRV_SEQ_PORT_CAP_WRITE) |
372 | port->direction |= SNDRV_SEQ_PORT_DIR_OUTPUT; |
373 | port->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
374 | | SNDRV_SEQ_PORT_TYPE_HARDWARE |
375 | | SNDRV_SEQ_PORT_TYPE_PORT; |
376 | port->midi_channels = 16; |
377 | memset(&pcallbacks, 0, sizeof(pcallbacks)); |
378 | pcallbacks.owner = THIS_MODULE; |
379 | pcallbacks.private_data = ms; |
380 | pcallbacks.subscribe = midisynth_subscribe; |
381 | pcallbacks.unsubscribe = midisynth_unsubscribe; |
382 | pcallbacks.use = midisynth_use; |
383 | pcallbacks.unuse = midisynth_unuse; |
384 | pcallbacks.event_input = event_process_midi; |
385 | port->kernel = &pcallbacks; |
386 | if (rmidi->ops && rmidi->ops->get_port_info) |
387 | rmidi->ops->get_port_info(rmidi, p, port); |
388 | if (snd_seq_kernel_client_ctl(client: client->seq_client, SNDRV_SEQ_IOCTL_CREATE_PORT, arg: port)<0) |
389 | goto __nomem; |
390 | ms->seq_client = client->seq_client; |
391 | ms->seq_port = port->addr.port; |
392 | } |
393 | client->ports_per_device[device] = ports; |
394 | client->ports[device] = msynth; |
395 | client->num_ports++; |
396 | if (newclient) |
397 | synths[card->number] = client; |
398 | return 0; /* success */ |
399 | |
400 | __nomem: |
401 | if (msynth != NULL) { |
402 | for (p = 0; p < ports; p++) |
403 | snd_seq_midisynth_delete(msynth: &msynth[p]); |
404 | kfree(objp: msynth); |
405 | } |
406 | if (newclient) { |
407 | snd_seq_delete_kernel_client(client: client->seq_client); |
408 | kfree(objp: client); |
409 | } |
410 | return -ENOMEM; |
411 | } |
412 | |
413 | /* release midi synth port */ |
414 | static int |
415 | snd_seq_midisynth_remove(struct device *_dev) |
416 | { |
417 | struct snd_seq_device *dev = to_seq_dev(_dev); |
418 | struct seq_midisynth_client *client; |
419 | struct seq_midisynth *msynth; |
420 | struct snd_card *card = dev->card; |
421 | int device = dev->device, p, ports; |
422 | |
423 | guard(mutex)(T: ®ister_mutex); |
424 | client = synths[card->number]; |
425 | if (client == NULL || client->ports[device] == NULL) |
426 | return -ENODEV; |
427 | ports = client->ports_per_device[device]; |
428 | client->ports_per_device[device] = 0; |
429 | msynth = client->ports[device]; |
430 | client->ports[device] = NULL; |
431 | for (p = 0; p < ports; p++) |
432 | snd_seq_midisynth_delete(msynth: &msynth[p]); |
433 | kfree(objp: msynth); |
434 | client->num_ports--; |
435 | if (client->num_ports <= 0) { |
436 | snd_seq_delete_kernel_client(client: client->seq_client); |
437 | synths[card->number] = NULL; |
438 | kfree(objp: client); |
439 | } |
440 | return 0; |
441 | } |
442 | |
443 | static struct snd_seq_driver seq_midisynth_driver = { |
444 | .driver = { |
445 | .name = KBUILD_MODNAME, |
446 | .probe = snd_seq_midisynth_probe, |
447 | .remove = snd_seq_midisynth_remove, |
448 | }, |
449 | .id = SNDRV_SEQ_DEV_ID_MIDISYNTH, |
450 | .argsize = 0, |
451 | }; |
452 | |
453 | module_snd_seq_driver(seq_midisynth_driver); |
454 | |