projects/linux·blob master · refs

1400 lines · 39.3 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Universal MIDI Packet (UMP) support
4 */
5
6#include <linux/list.h>
7#include <linux/slab.h>
8#include <linux/module.h>
9#include <linux/export.h>
10#include <linux/mm.h>
11#include <sound/core.h>
12#include <sound/rawmidi.h>
13#include <sound/ump.h>
14#include <sound/ump_convert.h>
15
16#define ump_err(ump, fmt, args...) dev_err((ump)->core.dev, fmt, ##args)
17#define ump_warn(ump, fmt, args...) dev_warn((ump)->core.dev, fmt, ##args)
18#define ump_info(ump, fmt, args...) dev_info((ump)->core.dev, fmt, ##args)
19#define ump_dbg(ump, fmt, args...) dev_dbg((ump)->core.dev, fmt, ##args)
20
21static int snd_ump_dev_register(struct snd_rawmidi *rmidi);
22static int snd_ump_dev_unregister(struct snd_rawmidi *rmidi);
23static long snd_ump_ioctl(struct snd_rawmidi *rmidi, unsigned int cmd,
24 void __user *argp);
25static void snd_ump_proc_read(struct snd_info_entry *entry,
26 struct snd_info_buffer *buffer);
27static int snd_ump_rawmidi_open(struct snd_rawmidi_substream *substream);
28static int snd_ump_rawmidi_close(struct snd_rawmidi_substream *substream);
29static void snd_ump_rawmidi_trigger(struct snd_rawmidi_substream *substream,
30 int up);
31static void snd_ump_rawmidi_drain(struct snd_rawmidi_substream *substream);
32
33static void ump_handle_stream_msg(struct snd_ump_endpoint *ump,
34 const u32 *buf, int size);
35#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
36static int process_legacy_output(struct snd_ump_endpoint *ump,
37 u32 *buffer, int count);
38static void process_legacy_input(struct snd_ump_endpoint *ump, const u32 *src,
39 int words);
40static void ump_legacy_set_rawmidi_name(struct snd_ump_endpoint *ump);
41static void update_legacy_names(struct snd_ump_endpoint *ump);
42#else
43static inline int process_legacy_output(struct snd_ump_endpoint *ump,
44 u32 *buffer, int count)
45{
46 return 0;
47}
48static inline void process_legacy_input(struct snd_ump_endpoint *ump,
49 const u32 *src, int words)
50{
51}
52static inline void ump_legacy_set_rawmidi_name(struct snd_ump_endpoint *ump)
53{
54}
55static inline void update_legacy_names(struct snd_ump_endpoint *ump)
56{
57}
58#endif
59
60/* copy a string safely with stripping non-printable letters */
61static void safe_copy_string(void *dst, size_t max_dst_size,
62 const void *src, size_t max_src_size)
63{
64 const unsigned char *s = src;
65 unsigned char *d = dst;
66
67 if (!max_dst_size--)
68 return;
69 for (s = src; max_dst_size && *s && max_src_size--; s++) {
70 if (!isascii(*s) || !isprint(*s))
71 continue;
72 *d++ = *s;
73 max_dst_size--;
74 }
75 *d = 0;
76}
77
78/* append a string safely with stripping non-printable letters */
79static void safe_append_string(void *dst, size_t max_dst_size,
80 const void *src, size_t max_src_size)
81{
82 unsigned char *d = dst;
83 size_t len = strlen(d);
84
85 safe_copy_string(d + len, max_dst_size - len, src, max_src_size);
86}
87
88static const struct snd_rawmidi_global_ops snd_ump_rawmidi_ops = {
89 .dev_register = snd_ump_dev_register,
90 .dev_unregister = snd_ump_dev_unregister,
91 .ioctl = snd_ump_ioctl,
92 .proc_read = snd_ump_proc_read,
93};
94
95static const struct snd_rawmidi_ops snd_ump_rawmidi_input_ops = {
96 .open = snd_ump_rawmidi_open,
97 .close = snd_ump_rawmidi_close,
98 .trigger = snd_ump_rawmidi_trigger,
99};
100
101static const struct snd_rawmidi_ops snd_ump_rawmidi_output_ops = {
102 .open = snd_ump_rawmidi_open,
103 .close = snd_ump_rawmidi_close,
104 .trigger = snd_ump_rawmidi_trigger,
105 .drain = snd_ump_rawmidi_drain,
106};
107
108static void snd_ump_endpoint_free(struct snd_rawmidi *rmidi)
109{
110 struct snd_ump_endpoint *ump = rawmidi_to_ump(rmidi);
111 struct snd_ump_block *fb;
112
113 while (!list_empty(&ump->block_list)) {
114 fb = list_first_entry(&ump->block_list, struct snd_ump_block,
115 list);
116 list_del(&fb->list);
117 if (fb->private_free)
118 fb->private_free(fb);
119 kfree(fb);
120 }
121
122 if (ump->private_free)
123 ump->private_free(ump);
124
125#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
126 kfree(ump->out_cvts);
127#endif
128}
129
130/**
131 * snd_ump_endpoint_new - create a UMP Endpoint object
132 * @card: the card instance
133 * @id: the id string for rawmidi
134 * @device: the device index for rawmidi
135 * @output: 1 for enabling output
136 * @input: 1 for enabling input
137 * @ump_ret: the pointer to store the new UMP instance
138 *
139 * Creates a new UMP Endpoint object. A UMP Endpoint is tied with one rawmidi
140 * instance with one input and/or one output rawmidi stream (either uni-
141 * or bi-directional). A UMP Endpoint may contain one or multiple UMP Blocks
142 * that consist of one or multiple UMP Groups.
143 *
144 * Use snd_rawmidi_set_ops() to set the operators to the new instance.
145 * Unlike snd_rawmidi_new(), this function sets up the info_flags by itself
146 * depending on the given @output and @input.
147 *
148 * The device has SNDRV_RAWMIDI_INFO_UMP flag set and a different device
149 * file ("umpCxDx") than a standard MIDI 1.x device ("midiCxDx") is
150 * created.
151 *
152 * Return: Zero if successful, or a negative error code on failure.
153 */
154int snd_ump_endpoint_new(struct snd_card *card, char *id, int device,
155 int output, int input,
156 struct snd_ump_endpoint **ump_ret)
157{
158 unsigned int info_flags = SNDRV_RAWMIDI_INFO_UMP;
159 struct snd_ump_endpoint *ump;
160 int err;
161
162 if (input)
163 info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
164 if (output)
165 info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
166 if (input && output)
167 info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
168
169 ump = kzalloc_obj(*ump);
170 if (!ump)
171 return -ENOMEM;
172 INIT_LIST_HEAD(&ump->block_list);
173 mutex_init(&ump->open_mutex);
174 init_waitqueue_head(&ump->stream_wait);
175#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
176 spin_lock_init(&ump->legacy_locks[0]);
177 spin_lock_init(&ump->legacy_locks[1]);
178#endif
179 err = snd_rawmidi_init(&ump->core, card, id, device,
180 output, input, info_flags);
181 if (err < 0) {
182 snd_rawmidi_free(&ump->core);
183 return err;
184 }
185
186 ump->info.card = card->number;
187 ump->info.device = device;
188
189 ump->core.private_free = snd_ump_endpoint_free;
190 ump->core.ops = &snd_ump_rawmidi_ops;
191 if (input)
192 snd_rawmidi_set_ops(&ump->core, SNDRV_RAWMIDI_STREAM_INPUT,
193 &snd_ump_rawmidi_input_ops);
194 if (output)
195 snd_rawmidi_set_ops(&ump->core, SNDRV_RAWMIDI_STREAM_OUTPUT,
196 &snd_ump_rawmidi_output_ops);
197
198 ump_dbg(ump, "Created a UMP EP #%d (%s)\n", device, id);
199 *ump_ret = ump;
200 return 0;
201}
202EXPORT_SYMBOL_GPL(snd_ump_endpoint_new);
203
204/*
205 * Device register / unregister hooks;
206 * do nothing, placeholders for avoiding the default rawmidi handling
207 */
208
209#if IS_ENABLED(CONFIG_SND_SEQUENCER)
210static void snd_ump_dev_seq_free(struct snd_seq_device *device)
211{
212 struct snd_ump_endpoint *ump = device->private_data;
213
214 ump->seq_dev = NULL;
215}
216#endif
217
218static int snd_ump_dev_register(struct snd_rawmidi *rmidi)
219{
220#if IS_ENABLED(CONFIG_SND_SEQUENCER)
221 struct snd_ump_endpoint *ump = rawmidi_to_ump(rmidi);
222 int err;
223
224 err = snd_seq_device_new(ump->core.card, ump->core.device,
225 SNDRV_SEQ_DEV_ID_UMP, 0, &ump->seq_dev);
226 if (err < 0)
227 return err;
228 ump->seq_dev->private_data = ump;
229 ump->seq_dev->private_free = snd_ump_dev_seq_free;
230 snd_device_register(ump->core.card, ump->seq_dev);
231#endif
232 return 0;
233}
234
235static int snd_ump_dev_unregister(struct snd_rawmidi *rmidi)
236{
237 return 0;
238}
239
240static struct snd_ump_block *
241snd_ump_get_block(struct snd_ump_endpoint *ump, unsigned char id)
242{
243 struct snd_ump_block *fb;
244
245 list_for_each_entry(fb, &ump->block_list, list) {
246 if (fb->info.block_id == id)
247 return fb;
248 }
249 return NULL;
250}
251
252/*
253 * rawmidi ops for UMP endpoint
254 */
255static int snd_ump_rawmidi_open(struct snd_rawmidi_substream *substream)
256{
257 struct snd_ump_endpoint *ump = rawmidi_to_ump(substream->rmidi);
258 int dir = substream->stream;
259 int err;
260
261 if (ump->substreams[dir])
262 return -EBUSY;
263 err = ump->ops->open(ump, dir);
264 if (err < 0)
265 return err;
266 ump->substreams[dir] = substream;
267 return 0;
268}
269
270static int snd_ump_rawmidi_close(struct snd_rawmidi_substream *substream)
271{
272 struct snd_ump_endpoint *ump = rawmidi_to_ump(substream->rmidi);
273 int dir = substream->stream;
274
275 ump->substreams[dir] = NULL;
276 ump->ops->close(ump, dir);
277 return 0;
278}
279
280static void snd_ump_rawmidi_trigger(struct snd_rawmidi_substream *substream,
281 int up)
282{
283 struct snd_ump_endpoint *ump = rawmidi_to_ump(substream->rmidi);
284 int dir = substream->stream;
285
286 ump->ops->trigger(ump, dir, up);
287}
288
289static void snd_ump_rawmidi_drain(struct snd_rawmidi_substream *substream)
290{
291 struct snd_ump_endpoint *ump = rawmidi_to_ump(substream->rmidi);
292
293 if (ump->ops->drain)
294 ump->ops->drain(ump, SNDRV_RAWMIDI_STREAM_OUTPUT);
295}
296
297/* number of 32bit words per message type */
298static unsigned char ump_packet_words[0x10] = {
299 1, 1, 1, 2, 2, 4, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4
300};
301
302/**
303 * snd_ump_receive_ump_val - parse the UMP packet data
304 * @ump: UMP endpoint
305 * @val: UMP packet data
306 *
307 * The data is copied onto ump->input_buf[].
308 * When a full packet is completed, returns the number of words (from 1 to 4).
309 * OTOH, if the packet is incomplete, returns 0.
310 */
311int snd_ump_receive_ump_val(struct snd_ump_endpoint *ump, u32 val)
312{
313 int words;
314
315 if (!ump->input_pending)
316 ump->input_pending = ump_packet_words[ump_message_type(val)];
317
318 ump->input_buf[ump->input_buf_head++] = val;
319 ump->input_pending--;
320 if (!ump->input_pending) {
321 words = ump->input_buf_head;
322 ump->input_buf_head = 0;
323 return words;
324 }
325 return 0;
326}
327EXPORT_SYMBOL_GPL(snd_ump_receive_ump_val);
328
329/**
330 * snd_ump_receive - transfer UMP packets from the device
331 * @ump: the UMP endpoint
332 * @buffer: the buffer pointer to transfer
333 * @count: byte size to transfer
334 *
335 * Called from the driver to submit the received UMP packets from the device
336 * to user-space. It's essentially a wrapper of rawmidi_receive().
337 * The data to receive is in CPU-native endianness.
338 */
339int snd_ump_receive(struct snd_ump_endpoint *ump, const u32 *buffer, int count)
340{
341 struct snd_rawmidi_substream *substream;
342 const u32 *p = buffer;
343 int n, words = count >> 2;
344
345 while (words--) {
346 n = snd_ump_receive_ump_val(ump, *p++);
347 if (!n)
348 continue;
349 ump_handle_stream_msg(ump, ump->input_buf, n);
350#if IS_ENABLED(CONFIG_SND_SEQUENCER)
351 if (ump->seq_ops)
352 ump->seq_ops->input_receive(ump, ump->input_buf, n);
353#endif
354 process_legacy_input(ump, ump->input_buf, n);
355 }
356
357 substream = ump->substreams[SNDRV_RAWMIDI_STREAM_INPUT];
358 if (!substream)
359 return 0;
360 return snd_rawmidi_receive(substream, (const char *)buffer, count);
361}
362EXPORT_SYMBOL_GPL(snd_ump_receive);
363
364/**
365 * snd_ump_transmit - transmit UMP packets
366 * @ump: the UMP endpoint
367 * @buffer: the buffer pointer to transfer
368 * @count: byte size to transfer
369 *
370 * Called from the driver to obtain the UMP packets from user-space to the
371 * device. It's essentially a wrapper of rawmidi_transmit().
372 * The data to transmit is in CPU-native endianness.
373 */
374int snd_ump_transmit(struct snd_ump_endpoint *ump, u32 *buffer, int count)
375{
376 struct snd_rawmidi_substream *substream =
377 ump->substreams[SNDRV_RAWMIDI_STREAM_OUTPUT];
378 int err;
379
380 if (!substream)
381 return -ENODEV;
382 err = snd_rawmidi_transmit(substream, (char *)buffer, count);
383 /* received either data or an error? */
384 if (err)
385 return err;
386 return process_legacy_output(ump, buffer, count);
387}
388EXPORT_SYMBOL_GPL(snd_ump_transmit);
389
390/**
391 * snd_ump_block_new - Create a UMP block
392 * @ump: UMP object
393 * @blk: block ID number to create
394 * @direction: direction (in/out/bidirection)
395 * @first_group: the first group ID (0-based)
396 * @num_groups: the number of groups in this block
397 * @blk_ret: the pointer to store the resultant block object
398 */
399int snd_ump_block_new(struct snd_ump_endpoint *ump, unsigned int blk,
400 unsigned int direction, unsigned int first_group,
401 unsigned int num_groups, struct snd_ump_block **blk_ret)
402{
403 struct snd_ump_block *fb, *p;
404
405 if (blk >= SNDRV_UMP_MAX_BLOCKS)
406 return -EINVAL;
407
408 if (snd_ump_get_block(ump, blk))
409 return -EBUSY;
410
411 fb = kzalloc_obj(*fb);
412 if (!fb)
413 return -ENOMEM;
414
415 fb->ump = ump;
416 fb->info.card = ump->info.card;
417 fb->info.device = ump->info.device;
418 fb->info.block_id = blk;
419 if (blk >= ump->info.num_blocks)
420 ump->info.num_blocks = blk + 1;
421 fb->info.direction = direction;
422 fb->info.active = 1;
423 fb->info.first_group = first_group;
424 fb->info.num_groups = num_groups;
425 /* fill the default name, may be overwritten to a better name */
426 snprintf(fb->info.name, sizeof(fb->info.name), "Group %u-%u",
427 first_group + 1, first_group + num_groups);
428
429 /* put the entry in the ordered list */
430 list_for_each_entry(p, &ump->block_list, list) {
431 if (p->info.block_id > blk) {
432 list_add_tail(&fb->list, &p->list);
433 goto added;
434 }
435 }
436 list_add_tail(&fb->list, &ump->block_list);
437
438 added:
439 ump_dbg(ump, "Created a UMP Block #%d (%s)\n", blk, fb->info.name);
440 *blk_ret = fb;
441 return 0;
442}
443EXPORT_SYMBOL_GPL(snd_ump_block_new);
444
445static int snd_ump_ioctl_block(struct snd_ump_endpoint *ump,
446 struct snd_ump_block_info __user *argp)
447{
448 struct snd_ump_block *fb;
449 unsigned char id;
450
451 if (get_user(id, &argp->block_id))
452 return -EFAULT;
453 fb = snd_ump_get_block(ump, id);
454 if (!fb)
455 return -ENOENT;
456 if (copy_to_user(argp, &fb->info, sizeof(fb->info)))
457 return -EFAULT;
458 return 0;
459}
460
461/*
462 * Handle UMP-specific ioctls; called from snd_rawmidi_ioctl()
463 */
464static long snd_ump_ioctl(struct snd_rawmidi *rmidi, unsigned int cmd,
465 void __user *argp)
466{
467 struct snd_ump_endpoint *ump = rawmidi_to_ump(rmidi);
468
469 switch (cmd) {
470 case SNDRV_UMP_IOCTL_ENDPOINT_INFO:
471 if (copy_to_user(argp, &ump->info, sizeof(ump->info)))
472 return -EFAULT;
473 return 0;
474 case SNDRV_UMP_IOCTL_BLOCK_INFO:
475 return snd_ump_ioctl_block(ump, argp);
476 default:
477 ump_dbg(ump, "rawmidi: unknown command = 0x%x\n", cmd);
478 return -ENOTTY;
479 }
480}
481
482static const char *ump_direction_string(int dir)
483{
484 switch (dir) {
485 case SNDRV_UMP_DIR_INPUT:
486 return "input";
487 case SNDRV_UMP_DIR_OUTPUT:
488 return "output";
489 case SNDRV_UMP_DIR_BIDIRECTION:
490 return "bidirection";
491 default:
492 return "unknown";
493 }
494}
495
496static const char *ump_ui_hint_string(int dir)
497{
498 switch (dir) {
499 case SNDRV_UMP_BLOCK_UI_HINT_RECEIVER:
500 return "receiver";
501 case SNDRV_UMP_BLOCK_UI_HINT_SENDER:
502 return "sender";
503 case SNDRV_UMP_BLOCK_UI_HINT_BOTH:
504 return "both";
505 default:
506 return "unknown";
507 }
508}
509
510/* Additional proc file output */
511static void snd_ump_proc_read(struct snd_info_entry *entry,
512 struct snd_info_buffer *buffer)
513{
514 struct snd_rawmidi *rmidi = entry->private_data;
515 struct snd_ump_endpoint *ump = rawmidi_to_ump(rmidi);
516 struct snd_ump_block *fb;
517
518 snd_iprintf(buffer, "EP Name: %s\n", ump->info.name);
519 snd_iprintf(buffer, "EP Product ID: %s\n", ump->info.product_id);
520 snd_iprintf(buffer, "UMP Version: 0x%04x\n", ump->info.version);
521 snd_iprintf(buffer, "Protocol Caps: 0x%08x\n", ump->info.protocol_caps);
522 snd_iprintf(buffer, "Protocol: 0x%08x\n", ump->info.protocol);
523 if (ump->info.version) {
524 snd_iprintf(buffer, "Manufacturer ID: 0x%08x\n",
525 ump->info.manufacturer_id);
526 snd_iprintf(buffer, "Family ID: 0x%04x\n", ump->info.family_id);
527 snd_iprintf(buffer, "Model ID: 0x%04x\n", ump->info.model_id);
528 snd_iprintf(buffer, "SW Revision: 0x%4phN\n", ump->info.sw_revision);
529 }
530 snd_iprintf(buffer, "Static Blocks: %s\n",
531 (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS) ? "Yes" : "No");
532 snd_iprintf(buffer, "Num Blocks: %d\n\n", ump->info.num_blocks);
533
534 list_for_each_entry(fb, &ump->block_list, list) {
535 snd_iprintf(buffer, "Block %d (%s)\n", fb->info.block_id,
536 fb->info.name);
537 snd_iprintf(buffer, " Direction: %s\n",
538 ump_direction_string(fb->info.direction));
539 snd_iprintf(buffer, " Active: %s\n",
540 fb->info.active ? "Yes" : "No");
541 snd_iprintf(buffer, " Groups: %d-%d\n",
542 fb->info.first_group + 1,
543 fb->info.first_group + fb->info.num_groups);
544 snd_iprintf(buffer, " Is MIDI1: %s%s\n",
545 (fb->info.flags & SNDRV_UMP_BLOCK_IS_MIDI1) ? "Yes" : "No",
546 (fb->info.flags & SNDRV_UMP_BLOCK_IS_LOWSPEED) ? " (Low Speed)" : "");
547 if (ump->info.version) {
548 snd_iprintf(buffer, " MIDI-CI Version: %d\n",
549 fb->info.midi_ci_version);
550 snd_iprintf(buffer, " Sysex8 Streams: %d\n",
551 fb->info.sysex8_streams);
552 snd_iprintf(buffer, " UI Hint: %s\n",
553 ump_ui_hint_string(fb->info.ui_hint));
554 }
555 snd_iprintf(buffer, "\n");
556 }
557}
558
559/* update dir_bits and active flag for all groups in the client */
560void snd_ump_update_group_attrs(struct snd_ump_endpoint *ump)
561{
562 struct snd_ump_block *fb;
563 struct snd_ump_group *group;
564 int i;
565
566 for (i = 0; i < SNDRV_UMP_MAX_GROUPS; i++) {
567 group = &ump->groups[i];
568 *group->name = 0;
569 group->dir_bits = 0;
570 group->active = 0;
571 group->group = i;
572 group->valid = false;
573 group->is_midi1 = false;
574 }
575
576 list_for_each_entry(fb, &ump->block_list, list) {
577 if (fb->info.first_group + fb->info.num_groups > SNDRV_UMP_MAX_GROUPS)
578 break;
579 group = &ump->groups[fb->info.first_group];
580 for (i = 0; i < fb->info.num_groups; i++, group++) {
581 group->valid = true;
582 if (fb->info.active)
583 group->active = 1;
584 if (fb->info.flags & SNDRV_UMP_BLOCK_IS_MIDI1)
585 group->is_midi1 = true;
586 switch (fb->info.direction) {
587 case SNDRV_UMP_DIR_INPUT:
588 group->dir_bits |= (1 << SNDRV_RAWMIDI_STREAM_INPUT);
589 break;
590 case SNDRV_UMP_DIR_OUTPUT:
591 group->dir_bits |= (1 << SNDRV_RAWMIDI_STREAM_OUTPUT);
592 break;
593 case SNDRV_UMP_DIR_BIDIRECTION:
594 group->dir_bits |= (1 << SNDRV_RAWMIDI_STREAM_INPUT) |
595 (1 << SNDRV_RAWMIDI_STREAM_OUTPUT);
596 break;
597 }
598 if (!*fb->info.name)
599 continue;
600 if (*group->name)
601 strlcat(group->name, ", ", sizeof(group->name));
602 safe_append_string(group->name, sizeof(group->name),
603 fb->info.name, sizeof(fb->info.name));
604 }
605 }
606}
607EXPORT_SYMBOL_GPL(snd_ump_update_group_attrs);
608
609/*
610 * UMP endpoint and function block handling
611 */
612
613/* open / close UMP streams for the internal stream msg communication */
614static int ump_request_open(struct snd_ump_endpoint *ump)
615{
616 return snd_rawmidi_kernel_open(&ump->core, 0,
617 SNDRV_RAWMIDI_LFLG_OUTPUT,
618 &ump->stream_rfile);
619}
620
621static void ump_request_close(struct snd_ump_endpoint *ump)
622{
623 snd_rawmidi_kernel_release(&ump->stream_rfile);
624}
625
626/* request a command and wait for the given response;
627 * @req1 and @req2 are u32 commands
628 * @reply is the expected UMP stream status
629 */
630static int ump_req_msg(struct snd_ump_endpoint *ump, u32 req1, u32 req2,
631 u32 reply)
632{
633 u32 buf[4];
634
635 ump_dbg(ump, "%s: request %08x %08x, wait-for %08x\n",
636 __func__, req1, req2, reply);
637 memset(buf, 0, sizeof(buf));
638 buf[0] = req1;
639 buf[1] = req2;
640 ump->stream_finished = 0;
641 ump->stream_wait_for = reply;
642 snd_rawmidi_kernel_write(ump->stream_rfile.output,
643 (unsigned char *)&buf, 16);
644 wait_event_timeout(ump->stream_wait, ump->stream_finished,
645 msecs_to_jiffies(500));
646 if (!READ_ONCE(ump->stream_finished)) {
647 ump_dbg(ump, "%s: request timed out\n", __func__);
648 return -ETIMEDOUT;
649 }
650 ump->stream_finished = 0;
651 ump_dbg(ump, "%s: reply: %08x %08x %08x %08x\n",
652 __func__, buf[0], buf[1], buf[2], buf[3]);
653 return 0;
654}
655
656/* append the received letters via UMP packet to the given string buffer;
657 * return 1 if the full string is received or 0 to continue
658 */
659static int ump_append_string(struct snd_ump_endpoint *ump, char *dest,
660 int maxsize, const u32 *buf, int offset)
661{
662 unsigned char format;
663 int c;
664
665 format = ump_stream_message_format(buf[0]);
666 if (format == UMP_STREAM_MSG_FORMAT_SINGLE ||
667 format == UMP_STREAM_MSG_FORMAT_START) {
668 c = 0;
669 } else {
670 c = strlen(dest);
671 if (c >= maxsize - 1)
672 return 1;
673 }
674
675 for (; offset < 16; offset++) {
676 dest[c] = buf[offset / 4] >> (3 - (offset % 4)) * 8;
677 if (!dest[c])
678 break;
679 if (++c >= maxsize - 1)
680 break;
681 }
682 dest[c] = 0;
683 return (format == UMP_STREAM_MSG_FORMAT_SINGLE ||
684 format == UMP_STREAM_MSG_FORMAT_END);
685}
686
687/* Choose the default protocol */
688static void choose_default_protocol(struct snd_ump_endpoint *ump)
689{
690 if (ump->info.protocol & SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK)
691 return;
692 if (ump->info.protocol_caps & SNDRV_UMP_EP_INFO_PROTO_MIDI2)
693 ump->info.protocol |= SNDRV_UMP_EP_INFO_PROTO_MIDI2;
694 else
695 ump->info.protocol |= SNDRV_UMP_EP_INFO_PROTO_MIDI1;
696}
697
698/* notify the EP info/name change to sequencer */
699static void seq_notify_ep_change(struct snd_ump_endpoint *ump)
700{
701#if IS_ENABLED(CONFIG_SND_SEQUENCER)
702 if (ump->parsed && ump->seq_ops && ump->seq_ops->notify_ep_change)
703 ump->seq_ops->notify_ep_change(ump);
704#endif
705}
706
707/* handle EP info stream message; update the UMP attributes */
708static int ump_handle_ep_info_msg(struct snd_ump_endpoint *ump,
709 const union snd_ump_stream_msg *buf)
710{
711 ump->info.version = (buf->ep_info.ump_version_major << 8) |
712 buf->ep_info.ump_version_minor;
713 ump->info.num_blocks = buf->ep_info.num_function_blocks;
714 if (ump->info.num_blocks > SNDRV_UMP_MAX_BLOCKS) {
715 ump_info(ump, "Invalid function blocks %d, fallback to 1\n",
716 ump->info.num_blocks);
717 ump->info.num_blocks = 1;
718 }
719
720 if (buf->ep_info.static_function_block)
721 ump->info.flags |= SNDRV_UMP_EP_INFO_STATIC_BLOCKS;
722
723 ump->info.protocol_caps = (buf->ep_info.protocol << 8) |
724 buf->ep_info.jrts;
725
726 ump_dbg(ump, "EP info: version=%x, num_blocks=%x, proto_caps=%x\n",
727 ump->info.version, ump->info.num_blocks, ump->info.protocol_caps);
728
729 ump->info.protocol &= ump->info.protocol_caps;
730 choose_default_protocol(ump);
731 seq_notify_ep_change(ump);
732
733 return 1; /* finished */
734}
735
736/* handle EP device info stream message; update the UMP attributes */
737static int ump_handle_device_info_msg(struct snd_ump_endpoint *ump,
738 const union snd_ump_stream_msg *buf)
739{
740 ump->info.manufacturer_id = buf->device_info.manufacture_id & 0x7f7f7f;
741 ump->info.family_id = (buf->device_info.family_msb << 8) |
742 buf->device_info.family_lsb;
743 ump->info.model_id = (buf->device_info.model_msb << 8) |
744 buf->device_info.model_lsb;
745 ump->info.sw_revision[0] = (buf->device_info.sw_revision >> 24) & 0x7f;
746 ump->info.sw_revision[1] = (buf->device_info.sw_revision >> 16) & 0x7f;
747 ump->info.sw_revision[2] = (buf->device_info.sw_revision >> 8) & 0x7f;
748 ump->info.sw_revision[3] = buf->device_info.sw_revision & 0x7f;
749 ump_dbg(ump, "EP devinfo: manid=%08x, family=%04x, model=%04x, sw=%4phN\n",
750 ump->info.manufacturer_id,
751 ump->info.family_id,
752 ump->info.model_id,
753 ump->info.sw_revision);
754 seq_notify_ep_change(ump);
755 return 1; /* finished */
756}
757
758/* set up the core rawmidi name from UMP EP name string */
759static void ump_set_rawmidi_name(struct snd_ump_endpoint *ump)
760{
761 safe_copy_string(ump->core.name, sizeof(ump->core.name),
762 ump->info.name, sizeof(ump->info.name));
763}
764
765/* handle EP name stream message; update the UMP name string */
766static int ump_handle_ep_name_msg(struct snd_ump_endpoint *ump,
767 const union snd_ump_stream_msg *buf)
768{
769 int ret;
770
771 ret = ump_append_string(ump, ump->info.name, sizeof(ump->info.name),
772 buf->raw, 2);
773 if (ret && ump->parsed) {
774 ump_set_rawmidi_name(ump);
775 ump_legacy_set_rawmidi_name(ump);
776 seq_notify_ep_change(ump);
777 }
778
779 return ret;
780}
781
782/* handle EP product id stream message; update the UMP product_id string */
783static int ump_handle_product_id_msg(struct snd_ump_endpoint *ump,
784 const union snd_ump_stream_msg *buf)
785{
786 int ret;
787
788 ret = ump_append_string(ump, ump->info.product_id,
789 sizeof(ump->info.product_id),
790 buf->raw, 2);
791 if (ret)
792 seq_notify_ep_change(ump);
793 return ret;
794}
795
796/* notify the protocol change to sequencer */
797static void seq_notify_protocol(struct snd_ump_endpoint *ump)
798{
799#if IS_ENABLED(CONFIG_SND_SEQUENCER)
800 if (ump->seq_ops && ump->seq_ops->switch_protocol)
801 ump->seq_ops->switch_protocol(ump);
802#endif /* CONFIG_SND_SEQUENCER */
803}
804
805/**
806 * snd_ump_switch_protocol - switch MIDI protocol
807 * @ump: UMP endpoint
808 * @protocol: protocol to switch to
809 *
810 * Returns 1 if the protocol is actually switched, 0 if unchanged
811 */
812int snd_ump_switch_protocol(struct snd_ump_endpoint *ump, unsigned int protocol)
813{
814 unsigned int type;
815
816 protocol &= ump->info.protocol_caps;
817 if (protocol == ump->info.protocol)
818 return 0;
819
820 type = protocol & SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK;
821 if (type != SNDRV_UMP_EP_INFO_PROTO_MIDI1 &&
822 type != SNDRV_UMP_EP_INFO_PROTO_MIDI2)
823 return 0;
824
825 ump->info.protocol = protocol;
826 ump_dbg(ump, "New protocol = %x (caps = %x)\n",
827 protocol, ump->info.protocol_caps);
828 seq_notify_protocol(ump);
829 return 1;
830}
831EXPORT_SYMBOL_GPL(snd_ump_switch_protocol);
832
833/* handle EP stream config message; update the UMP protocol */
834static int ump_handle_stream_cfg_msg(struct snd_ump_endpoint *ump,
835 const union snd_ump_stream_msg *buf)
836{
837 unsigned int protocol =
838 (buf->stream_cfg.protocol << 8) | buf->stream_cfg.jrts;
839
840 snd_ump_switch_protocol(ump, protocol);
841 return 1; /* finished */
842}
843
844/* Extract Function Block info from UMP packet */
845static void fill_fb_info(struct snd_ump_endpoint *ump,
846 struct snd_ump_block_info *info,
847 const union snd_ump_stream_msg *buf)
848{
849 info->direction = buf->fb_info.direction;
850 info->ui_hint = buf->fb_info.ui_hint;
851 info->first_group = buf->fb_info.first_group;
852 info->num_groups = buf->fb_info.num_groups;
853 if (buf->fb_info.midi_10 < 2)
854 info->flags = buf->fb_info.midi_10;
855 else
856 info->flags = SNDRV_UMP_BLOCK_IS_MIDI1 | SNDRV_UMP_BLOCK_IS_LOWSPEED;
857 info->active = buf->fb_info.active;
858 info->midi_ci_version = buf->fb_info.midi_ci_version;
859 info->sysex8_streams = buf->fb_info.sysex8_streams;
860
861 ump_dbg(ump, "FB %d: dir=%d, active=%d, first_gp=%d, num_gp=%d, midici=%d, sysex8=%d, flags=0x%x\n",
862 info->block_id, info->direction, info->active,
863 info->first_group, info->num_groups, info->midi_ci_version,
864 info->sysex8_streams, info->flags);
865
866 if ((info->flags & SNDRV_UMP_BLOCK_IS_MIDI1) && info->num_groups != 1) {
867 info->num_groups = 1;
868 ump_dbg(ump, "FB %d: corrected groups to 1 for MIDI1\n",
869 info->block_id);
870 }
871}
872
873/* check whether the FB info gets updated by the current message */
874static bool is_fb_info_updated(struct snd_ump_endpoint *ump,
875 struct snd_ump_block *fb,
876 const union snd_ump_stream_msg *buf)
877{
878 char tmpbuf[offsetof(struct snd_ump_block_info, name)];
879
880 if (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS) {
881 ump_info(ump, "Skipping static FB info update (blk#%d)\n",
882 fb->info.block_id);
883 return 0;
884 }
885
886 memcpy(tmpbuf, &fb->info, sizeof(tmpbuf));
887 fill_fb_info(ump, (struct snd_ump_block_info *)tmpbuf, buf);
888 return memcmp(&fb->info, tmpbuf, sizeof(tmpbuf)) != 0;
889}
890
891/* notify the FB info/name change to sequencer */
892static void seq_notify_fb_change(struct snd_ump_endpoint *ump,
893 struct snd_ump_block *fb)
894{
895#if IS_ENABLED(CONFIG_SND_SEQUENCER)
896 if (ump->seq_ops && ump->seq_ops->notify_fb_change)
897 ump->seq_ops->notify_fb_change(ump, fb);
898#endif
899}
900
901/* handle FB info message; update FB info if the block is present */
902static int ump_handle_fb_info_msg(struct snd_ump_endpoint *ump,
903 const union snd_ump_stream_msg *buf)
904{
905 unsigned char blk;
906 struct snd_ump_block *fb;
907
908 blk = buf->fb_info.function_block_id;
909 fb = snd_ump_get_block(ump, blk);
910
911 /* complain only if updated after parsing */
912 if (!fb && ump->parsed) {
913 ump_info(ump, "Function Block Info Update for non-existing block %d\n",
914 blk);
915 return -ENODEV;
916 }
917
918 /* When updated after the initial parse, check the FB info update */
919 if (ump->parsed && !is_fb_info_updated(ump, fb, buf))
920 return 1; /* no content change */
921
922 if (fb) {
923 fill_fb_info(ump, &fb->info, buf);
924 if (ump->parsed) {
925 snd_ump_update_group_attrs(ump);
926 update_legacy_names(ump);
927 seq_notify_fb_change(ump, fb);
928 }
929 }
930
931 return 1; /* finished */
932}
933
934/* handle FB name message; update the FB name string */
935static int ump_handle_fb_name_msg(struct snd_ump_endpoint *ump,
936 const union snd_ump_stream_msg *buf)
937{
938 unsigned char blk;
939 struct snd_ump_block *fb;
940 int ret;
941
942 blk = buf->fb_name.function_block_id;
943 fb = snd_ump_get_block(ump, blk);
944 if (!fb)
945 return -ENODEV;
946
947 if (ump->parsed &&
948 (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS)) {
949 ump_dbg(ump, "Skipping static FB name update (blk#%d)\n",
950 fb->info.block_id);
951 return 0;
952 }
953
954 ret = ump_append_string(ump, fb->info.name, sizeof(fb->info.name),
955 buf->raw, 3);
956 /* notify the FB name update to sequencer, too */
957 if (ret > 0 && ump->parsed) {
958 snd_ump_update_group_attrs(ump);
959 update_legacy_names(ump);
960 seq_notify_fb_change(ump, fb);
961 }
962 return ret;
963}
964
965static int create_block_from_fb_info(struct snd_ump_endpoint *ump, int blk)
966{
967 struct snd_ump_block *fb;
968 unsigned char direction, first_group, num_groups;
969 const union snd_ump_stream_msg *buf =
970 (const union snd_ump_stream_msg *)ump->input_buf;
971 u32 msg;
972 int err;
973
974 /* query the FB info once */
975 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_FB_DISCOVERY, 0) |
976 (blk << 8) | UMP_STREAM_MSG_REQUEST_FB_INFO;
977 err = ump_req_msg(ump, msg, 0, UMP_STREAM_MSG_STATUS_FB_INFO);
978 if (err < 0) {
979 ump_dbg(ump, "Unable to get FB info for block %d\n", blk);
980 return err;
981 }
982
983 /* the last input must be the FB info */
984 if (buf->fb_info.status != UMP_STREAM_MSG_STATUS_FB_INFO) {
985 ump_dbg(ump, "Inconsistent input: 0x%x\n", *buf->raw);
986 return -EINVAL;
987 }
988
989 direction = buf->fb_info.direction;
990 first_group = buf->fb_info.first_group;
991 num_groups = buf->fb_info.num_groups;
992
993 err = snd_ump_block_new(ump, blk, direction, first_group, num_groups,
994 &fb);
995 if (err < 0)
996 return err;
997
998 fill_fb_info(ump, &fb->info, buf);
999
1000 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_FB_DISCOVERY, 0) |
1001 (blk << 8) | UMP_STREAM_MSG_REQUEST_FB_NAME;
1002 err = ump_req_msg(ump, msg, 0, UMP_STREAM_MSG_STATUS_FB_NAME);
1003 if (err)
1004 ump_dbg(ump, "Unable to get UMP FB name string #%d\n", blk);
1005
1006 return 0;
1007}
1008
1009/* handle stream messages, called from snd_ump_receive() */
1010static void ump_handle_stream_msg(struct snd_ump_endpoint *ump,
1011 const u32 *buf, int size)
1012{
1013 const union snd_ump_stream_msg *msg;
1014 unsigned int status;
1015 int ret;
1016
1017 /* UMP stream message suppressed (for gadget UMP)? */
1018 if (ump->no_process_stream)
1019 return;
1020
1021 BUILD_BUG_ON(sizeof(*msg) != 16);
1022 ump_dbg(ump, "Stream msg: %08x %08x %08x %08x\n",
1023 buf[0], buf[1], buf[2], buf[3]);
1024
1025 if (size != 4 || ump_message_type(*buf) != UMP_MSG_TYPE_STREAM)
1026 return;
1027
1028 msg = (const union snd_ump_stream_msg *)buf;
1029 status = ump_stream_message_status(*buf);
1030 switch (status) {
1031 case UMP_STREAM_MSG_STATUS_EP_INFO:
1032 ret = ump_handle_ep_info_msg(ump, msg);
1033 break;
1034 case UMP_STREAM_MSG_STATUS_DEVICE_INFO:
1035 ret = ump_handle_device_info_msg(ump, msg);
1036 break;
1037 case UMP_STREAM_MSG_STATUS_EP_NAME:
1038 ret = ump_handle_ep_name_msg(ump, msg);
1039 break;
1040 case UMP_STREAM_MSG_STATUS_PRODUCT_ID:
1041 ret = ump_handle_product_id_msg(ump, msg);
1042 break;
1043 case UMP_STREAM_MSG_STATUS_STREAM_CFG:
1044 ret = ump_handle_stream_cfg_msg(ump, msg);
1045 break;
1046 case UMP_STREAM_MSG_STATUS_FB_INFO:
1047 ret = ump_handle_fb_info_msg(ump, msg);
1048 break;
1049 case UMP_STREAM_MSG_STATUS_FB_NAME:
1050 ret = ump_handle_fb_name_msg(ump, msg);
1051 break;
1052 default:
1053 return;
1054 }
1055
1056 /* when the message has been processed fully, wake up */
1057 if (ret > 0 && ump->stream_wait_for == status) {
1058 WRITE_ONCE(ump->stream_finished, 1);
1059 wake_up(&ump->stream_wait);
1060 }
1061}
1062
1063/**
1064 * snd_ump_parse_endpoint - parse endpoint and create function blocks
1065 * @ump: UMP object
1066 *
1067 * Returns 0 for successful parse, -ENODEV if device doesn't respond
1068 * (or the query is unsupported), or other error code for serious errors.
1069 */
1070int snd_ump_parse_endpoint(struct snd_ump_endpoint *ump)
1071{
1072 int blk, err;
1073 u32 msg;
1074
1075 if (!(ump->core.info_flags & SNDRV_RAWMIDI_INFO_DUPLEX))
1076 return -ENODEV;
1077
1078 err = ump_request_open(ump);
1079 if (err < 0) {
1080 ump_dbg(ump, "Unable to open rawmidi device: %d\n", err);
1081 return err;
1082 }
1083
1084 /* Check Endpoint Information */
1085 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_EP_DISCOVERY, 0) |
1086 0x0101; /* UMP version 1.1 */
1087 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_EP_INFO,
1088 UMP_STREAM_MSG_STATUS_EP_INFO);
1089 if (err < 0) {
1090 ump_dbg(ump, "Unable to get UMP EP info\n");
1091 goto error;
1092 }
1093
1094 /* Request Endpoint Device Info */
1095 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_DEVICE_INFO,
1096 UMP_STREAM_MSG_STATUS_DEVICE_INFO);
1097 if (err < 0)
1098 ump_dbg(ump, "Unable to get UMP EP device info\n");
1099
1100 /* Request Endpoint Name */
1101 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_EP_NAME,
1102 UMP_STREAM_MSG_STATUS_EP_NAME);
1103 if (err < 0)
1104 ump_dbg(ump, "Unable to get UMP EP name string\n");
1105
1106 ump_set_rawmidi_name(ump);
1107
1108 /* Request Endpoint Product ID */
1109 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_PRODUCT_ID,
1110 UMP_STREAM_MSG_STATUS_PRODUCT_ID);
1111 if (err < 0)
1112 ump_dbg(ump, "Unable to get UMP EP product ID string\n");
1113
1114 /* Get the current stream configuration */
1115 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_STREAM_CFG,
1116 UMP_STREAM_MSG_STATUS_STREAM_CFG);
1117 if (err < 0)
1118 ump_dbg(ump, "Unable to get UMP EP stream config\n");
1119
1120 /* If no protocol is set by some reason, assume the valid one */
1121 choose_default_protocol(ump);
1122
1123 /* Query and create blocks from Function Blocks */
1124 for (blk = 0; blk < ump->info.num_blocks; blk++) {
1125 err = create_block_from_fb_info(ump, blk);
1126 if (err < 0)
1127 continue;
1128 }
1129
1130 /* initialize group attributions */
1131 snd_ump_update_group_attrs(ump);
1132
1133 error:
1134 ump->parsed = true;
1135 ump_request_close(ump);
1136 if (err == -ETIMEDOUT)
1137 err = -ENODEV;
1138 return err;
1139}
1140EXPORT_SYMBOL_GPL(snd_ump_parse_endpoint);
1141
1142#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
1143/*
1144 * Legacy rawmidi support
1145 */
1146static int snd_ump_legacy_open(struct snd_rawmidi_substream *substream)
1147{
1148 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1149 int dir = substream->stream;
1150 int group = ump->legacy_mapping[substream->number];
1151 int err;
1152
1153 guard(mutex)(&ump->open_mutex);
1154 if (ump->legacy_substreams[dir][group])
1155 return -EBUSY;
1156 if (!ump->groups[group].active)
1157 return -ENODEV;
1158 if (dir == SNDRV_RAWMIDI_STREAM_OUTPUT) {
1159 if (!ump->legacy_out_opens) {
1160 err = snd_rawmidi_kernel_open_nested(&ump->core, 0,
1161 SNDRV_RAWMIDI_LFLG_OUTPUT |
1162 SNDRV_RAWMIDI_LFLG_APPEND,
1163 &ump->legacy_out_rfile,
1164 SINGLE_DEPTH_NESTING);
1165 if (err < 0)
1166 return err;
1167 }
1168 ump->legacy_out_opens++;
1169 snd_ump_convert_reset(&ump->out_cvts[group]);
1170 }
1171 guard(spinlock_irq)(&ump->legacy_locks[dir]);
1172 ump->legacy_substreams[dir][group] = substream;
1173 return 0;
1174}
1175
1176static int snd_ump_legacy_close(struct snd_rawmidi_substream *substream)
1177{
1178 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1179 int dir = substream->stream;
1180 int group = ump->legacy_mapping[substream->number];
1181
1182 guard(mutex)(&ump->open_mutex);
1183 scoped_guard(spinlock_irq, &ump->legacy_locks[dir])
1184 ump->legacy_substreams[dir][group] = NULL;
1185 if (dir == SNDRV_RAWMIDI_STREAM_OUTPUT) {
1186 if (!--ump->legacy_out_opens)
1187 snd_rawmidi_kernel_release_nested(&ump->legacy_out_rfile,
1188 SINGLE_DEPTH_NESTING);
1189 }
1190 return 0;
1191}
1192
1193static void snd_ump_legacy_trigger(struct snd_rawmidi_substream *substream,
1194 int up)
1195{
1196 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1197 int dir = substream->stream;
1198
1199 ump->ops->trigger(ump, dir, up);
1200}
1201
1202static void snd_ump_legacy_drain(struct snd_rawmidi_substream *substream)
1203{
1204 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1205
1206 if (ump->ops->drain)
1207 ump->ops->drain(ump, SNDRV_RAWMIDI_STREAM_OUTPUT);
1208}
1209
1210static int snd_ump_legacy_dev_register(struct snd_rawmidi *rmidi)
1211{
1212 /* dummy, just for avoiding create superfluous seq clients */
1213 return 0;
1214}
1215
1216static const struct snd_rawmidi_ops snd_ump_legacy_input_ops = {
1217 .open = snd_ump_legacy_open,
1218 .close = snd_ump_legacy_close,
1219 .trigger = snd_ump_legacy_trigger,
1220};
1221
1222static const struct snd_rawmidi_ops snd_ump_legacy_output_ops = {
1223 .open = snd_ump_legacy_open,
1224 .close = snd_ump_legacy_close,
1225 .trigger = snd_ump_legacy_trigger,
1226 .drain = snd_ump_legacy_drain,
1227};
1228
1229static const struct snd_rawmidi_global_ops snd_ump_legacy_ops = {
1230 .dev_register = snd_ump_legacy_dev_register,
1231};
1232
1233static int process_legacy_output(struct snd_ump_endpoint *ump,
1234 u32 *buffer, int count)
1235{
1236 struct snd_rawmidi_substream *substream;
1237 struct ump_cvt_to_ump *ctx;
1238 const int dir = SNDRV_RAWMIDI_STREAM_OUTPUT;
1239 unsigned int protocol;
1240 unsigned char c;
1241 int group, size = 0;
1242
1243 if (!ump->out_cvts || !ump->legacy_out_opens)
1244 return 0;
1245
1246 guard(spinlock_irqsave)(&ump->legacy_locks[dir]);
1247 for (group = 0; group < SNDRV_UMP_MAX_GROUPS; group++) {
1248 substream = ump->legacy_substreams[dir][group];
1249 if (!substream)
1250 continue;
1251 ctx = &ump->out_cvts[group];
1252 protocol = ump->info.protocol;
1253 if ((protocol & SNDRV_UMP_EP_INFO_PROTO_MIDI2) &&
1254 ump->groups[group].is_midi1)
1255 protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI1;
1256 while (!ctx->ump_bytes &&
1257 snd_rawmidi_transmit(substream, &c, 1) > 0)
1258 snd_ump_convert_to_ump(ctx, group, protocol, c);
1259 if (ctx->ump_bytes && ctx->ump_bytes <= count) {
1260 size = ctx->ump_bytes;
1261 memcpy(buffer, ctx->ump, size);
1262 ctx->ump_bytes = 0;
1263 break;
1264 }
1265 }
1266 return size;
1267}
1268
1269static void process_legacy_input(struct snd_ump_endpoint *ump, const u32 *src,
1270 int words)
1271{
1272 struct snd_rawmidi_substream *substream;
1273 unsigned char buf[16];
1274 unsigned char group;
1275 const int dir = SNDRV_RAWMIDI_STREAM_INPUT;
1276 int size;
1277
1278 size = snd_ump_convert_from_ump(src, buf, &group);
1279 if (size <= 0)
1280 return;
1281 guard(spinlock_irqsave)(&ump->legacy_locks[dir]);
1282 substream = ump->legacy_substreams[dir][group];
1283 if (substream)
1284 snd_rawmidi_receive(substream, buf, size);
1285}
1286
1287/* Fill ump->legacy_mapping[] for groups to be used for legacy rawmidi */
1288static int fill_legacy_mapping(struct snd_ump_endpoint *ump)
1289{
1290 struct snd_ump_block *fb;
1291 unsigned int group_maps = 0;
1292 int i, num;
1293
1294 if (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS) {
1295 list_for_each_entry(fb, &ump->block_list, list) {
1296 for (i = 0; i < fb->info.num_groups; i++)
1297 group_maps |= 1U << (fb->info.first_group + i);
1298 }
1299 if (!group_maps)
1300 ump_info(ump, "No UMP Group is found in FB\n");
1301 }
1302
1303 /* use all groups for non-static case */
1304 if (!group_maps)
1305 group_maps = (1U << SNDRV_UMP_MAX_GROUPS) - 1;
1306
1307 num = 0;
1308 for (i = 0; i < SNDRV_UMP_MAX_GROUPS; i++)
1309 if (group_maps & (1U << i))
1310 ump->legacy_mapping[num++] = i;
1311
1312 return num;
1313}
1314
1315static void update_legacy_substreams(struct snd_ump_endpoint *ump,
1316 struct snd_rawmidi *rmidi, int dir)
1317{
1318 struct snd_rawmidi_substream *s;
1319 const char *name;
1320 int idx;
1321
1322 list_for_each_entry(s, &rmidi->streams[dir].substreams, list) {
1323 idx = ump->legacy_mapping[s->number];
1324 name = ump->groups[idx].name;
1325 if (!*name)
1326 name = ump->core.name;
1327 scnprintf(s->name, sizeof(s->name), "Group %d (%.16s)%s",
1328 idx + 1, name,
1329 ump->groups[idx].active ? "" : " [Inactive]");
1330 s->inactive = !ump->groups[idx].active;
1331 }
1332}
1333
1334static void update_legacy_names(struct snd_ump_endpoint *ump)
1335{
1336 struct snd_rawmidi *rmidi = ump->legacy_rmidi;
1337
1338 if (!rmidi)
1339 return;
1340 update_legacy_substreams(ump, rmidi, SNDRV_RAWMIDI_STREAM_INPUT);
1341 update_legacy_substreams(ump, rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT);
1342}
1343
1344static void ump_legacy_set_rawmidi_name(struct snd_ump_endpoint *ump)
1345{
1346 struct snd_rawmidi *rmidi = ump->legacy_rmidi;
1347
1348 if (!rmidi)
1349 return;
1350 snprintf(rmidi->name, sizeof(rmidi->name), "%.68s (MIDI 1.0)",
1351 ump->core.name);
1352}
1353
1354int snd_ump_attach_legacy_rawmidi(struct snd_ump_endpoint *ump,
1355 char *id, int device)
1356{
1357 struct snd_rawmidi *rmidi;
1358 bool input, output;
1359 int err, num;
1360
1361 ump->out_cvts = kzalloc_objs(*ump->out_cvts, SNDRV_UMP_MAX_GROUPS);
1362 if (!ump->out_cvts)
1363 return -ENOMEM;
1364
1365 num = fill_legacy_mapping(ump);
1366
1367 input = ump->core.info_flags & SNDRV_RAWMIDI_INFO_INPUT;
1368 output = ump->core.info_flags & SNDRV_RAWMIDI_INFO_OUTPUT;
1369 err = snd_rawmidi_new(ump->core.card, id, device,
1370 output ? num : 0, input ? num : 0,
1371 &rmidi);
1372 if (err < 0) {
1373 kfree(ump->out_cvts);
1374 ump->out_cvts = NULL;
1375 return err;
1376 }
1377
1378 if (input)
1379 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
1380 &snd_ump_legacy_input_ops);
1381 if (output)
1382 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
1383 &snd_ump_legacy_output_ops);
1384 rmidi->info_flags = ump->core.info_flags & ~SNDRV_RAWMIDI_INFO_UMP;
1385 rmidi->ops = &snd_ump_legacy_ops;
1386 rmidi->private_data = ump;
1387 ump->legacy_rmidi = rmidi;
1388 ump_legacy_set_rawmidi_name(ump);
1389 update_legacy_names(ump);
1390
1391 snd_rawmidi_tie_devices(rmidi, &ump->core);
1392
1393 ump_dbg(ump, "Created a legacy rawmidi #%d (%s)\n", device, id);
1394 return 0;
1395}
1396EXPORT_SYMBOL_GPL(snd_ump_attach_legacy_rawmidi);
1397#endif /* CONFIG_SND_UMP_LEGACY_RAWMIDI */
1398
1399MODULE_DESCRIPTION("Universal MIDI Packet (UMP) Core Driver");
1400MODULE_LICENSE("GPL");