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