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