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);
40#else
41static inline int process_legacy_output(struct snd_ump_endpoint *ump,
42 u32 *buffer, int count)
43{
44 return 0;
45}
46static inline void process_legacy_input(struct snd_ump_endpoint *ump,
47 const u32 *src, int words)
48{
49}
50#endif
51
52static 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
59static 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
65static 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
72static 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 */
118int 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}
166EXPORT_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)
174static 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
182static 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
199static int snd_ump_dev_unregister(struct snd_rawmidi *rmidi)
200{
201 return 0;
202}
203
204static struct snd_ump_block *
205snd_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 */
219static 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
234static 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
244static 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
253static 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 */
262static 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 */
275int 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}
291EXPORT_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 */
303int 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}
326EXPORT_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 */
338int 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}
352EXPORT_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 */
363int 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}
407EXPORT_SYMBOL_GPL(snd_ump_block_new);
408
409static 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 */
428static 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
446static 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
460static 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 */
475static 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 */
532static 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
539static 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 */
548static 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 */
577static 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 */
606static 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 */
630static 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 */
654static 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 */
662static 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 */
671static 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 */
686int snd_ump_switch_protocol(struct snd_ump_endpoint *ump, unsigned int protocol)
687{
688 protocol &= ump->info.protocol_caps;
689 if (protocol == ump->info.protocol)
690 return 0;
691
692 ump->info.protocol = protocol;
693 ump_dbg(ump, "New protocol = %x (caps = %x)\n",
694 protocol, ump->info.protocol_caps);
695 seq_notify_protocol(ump);
696 return 1;
697}
698EXPORT_SYMBOL_GPL(snd_ump_switch_protocol);
699
700/* handle EP stream config message; update the UMP protocol */
701static int ump_handle_stream_cfg_msg(struct snd_ump_endpoint *ump,
702 const union snd_ump_stream_msg *buf)
703{
704 unsigned int protocol =
705 (buf->stream_cfg.protocol << 8) | buf->stream_cfg.jrts;
706
707 snd_ump_switch_protocol(ump, protocol);
708 return 1; /* finished */
709}
710
711/* Extract Function Block info from UMP packet */
712static void fill_fb_info(struct snd_ump_endpoint *ump,
713 struct snd_ump_block_info *info,
714 const union snd_ump_stream_msg *buf)
715{
716 info->direction = buf->fb_info.direction;
717 info->ui_hint = buf->fb_info.ui_hint;
718 info->first_group = buf->fb_info.first_group;
719 info->num_groups = buf->fb_info.num_groups;
720 info->flags = buf->fb_info.midi_10;
721 info->active = buf->fb_info.active;
722 info->midi_ci_version = buf->fb_info.midi_ci_version;
723 info->sysex8_streams = buf->fb_info.sysex8_streams;
724
725 ump_dbg(ump, "FB %d: dir=%d, active=%d, first_gp=%d, num_gp=%d, midici=%d, sysex8=%d, flags=0x%x\n",
726 info->block_id, info->direction, info->active,
727 info->first_group, info->num_groups, info->midi_ci_version,
728 info->sysex8_streams, info->flags);
729}
730
731/* check whether the FB info gets updated by the current message */
732static bool is_fb_info_updated(struct snd_ump_endpoint *ump,
733 struct snd_ump_block *fb,
734 const union snd_ump_stream_msg *buf)
735{
736 char tmpbuf[offsetof(struct snd_ump_block_info, name)];
737
738 if (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS) {
739 ump_info(ump, "Skipping static FB info update (blk#%d)\n",
740 fb->info.block_id);
741 return 0;
742 }
743
744 memcpy(tmpbuf, &fb->info, sizeof(tmpbuf));
745 fill_fb_info(ump, (struct snd_ump_block_info *)tmpbuf, buf);
746 return memcmp(&fb->info, tmpbuf, sizeof(tmpbuf)) != 0;
747}
748
749/* notify the FB info/name change to sequencer */
750static void seq_notify_fb_change(struct snd_ump_endpoint *ump,
751 struct snd_ump_block *fb)
752{
753#if IS_ENABLED(CONFIG_SND_SEQUENCER)
754 if (ump->seq_ops && ump->seq_ops->notify_fb_change)
755 ump->seq_ops->notify_fb_change(ump, fb);
756#endif
757}
758
759/* handle FB info message; update FB info if the block is present */
760static int ump_handle_fb_info_msg(struct snd_ump_endpoint *ump,
761 const union snd_ump_stream_msg *buf)
762{
763 unsigned char blk;
764 struct snd_ump_block *fb;
765
766 blk = buf->fb_info.function_block_id;
767 fb = snd_ump_get_block(ump, blk);
768
769 /* complain only if updated after parsing */
770 if (!fb && ump->parsed) {
771 ump_info(ump, "Function Block Info Update for non-existing block %d\n",
772 blk);
773 return -ENODEV;
774 }
775
776 /* When updated after the initial parse, check the FB info update */
777 if (ump->parsed && !is_fb_info_updated(ump, fb, buf))
778 return 1; /* no content change */
779
780 if (fb) {
781 fill_fb_info(ump, &fb->info, buf);
782 if (ump->parsed)
783 seq_notify_fb_change(ump, fb);
784 }
785
786 return 1; /* finished */
787}
788
789/* handle FB name message; update the FB name string */
790static int ump_handle_fb_name_msg(struct snd_ump_endpoint *ump,
791 const union snd_ump_stream_msg *buf)
792{
793 unsigned char blk;
794 struct snd_ump_block *fb;
795 int ret;
796
797 blk = buf->fb_name.function_block_id;
798 fb = snd_ump_get_block(ump, blk);
799 if (!fb)
800 return -ENODEV;
801
802 ret = ump_append_string(ump, fb->info.name, sizeof(fb->info.name),
803 buf->raw, 3);
804 /* notify the FB name update to sequencer, too */
805 if (ret > 0 && ump->parsed)
806 seq_notify_fb_change(ump, fb);
807 return ret;
808}
809
810static int create_block_from_fb_info(struct snd_ump_endpoint *ump, int blk)
811{
812 struct snd_ump_block *fb;
813 unsigned char direction, first_group, num_groups;
814 const union snd_ump_stream_msg *buf =
815 (const union snd_ump_stream_msg *)ump->input_buf;
816 u32 msg;
817 int err;
818
819 /* query the FB info once */
820 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_FB_DISCOVERY, 0) |
821 (blk << 8) | UMP_STREAM_MSG_REQUEST_FB_INFO;
822 err = ump_req_msg(ump, msg, 0, UMP_STREAM_MSG_STATUS_FB_INFO);
823 if (err < 0) {
824 ump_dbg(ump, "Unable to get FB info for block %d\n", blk);
825 return err;
826 }
827
828 /* the last input must be the FB info */
829 if (buf->fb_info.status != UMP_STREAM_MSG_STATUS_FB_INFO) {
830 ump_dbg(ump, "Inconsistent input: 0x%x\n", *buf->raw);
831 return -EINVAL;
832 }
833
834 direction = buf->fb_info.direction;
835 first_group = buf->fb_info.first_group;
836 num_groups = buf->fb_info.num_groups;
837
838 err = snd_ump_block_new(ump, blk, direction, first_group, num_groups,
839 &fb);
840 if (err < 0)
841 return err;
842
843 fill_fb_info(ump, &fb->info, buf);
844
845 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_FB_DISCOVERY, 0) |
846 (blk << 8) | UMP_STREAM_MSG_REQUEST_FB_NAME;
847 err = ump_req_msg(ump, msg, 0, UMP_STREAM_MSG_STATUS_FB_NAME);
848 if (err)
849 ump_dbg(ump, "Unable to get UMP FB name string #%d\n", blk);
850
851 return 0;
852}
853
854/* handle stream messages, called from snd_ump_receive() */
855static void ump_handle_stream_msg(struct snd_ump_endpoint *ump,
856 const u32 *buf, int size)
857{
858 const union snd_ump_stream_msg *msg;
859 unsigned int status;
860 int ret;
861
862 /* UMP stream message suppressed (for gadget UMP)? */
863 if (ump->no_process_stream)
864 return;
865
866 BUILD_BUG_ON(sizeof(*msg) != 16);
867 ump_dbg(ump, "Stream msg: %08x %08x %08x %08x\n",
868 buf[0], buf[1], buf[2], buf[3]);
869
870 if (size != 4 || ump_message_type(*buf) != UMP_MSG_TYPE_STREAM)
871 return;
872
873 msg = (const union snd_ump_stream_msg *)buf;
874 status = ump_stream_message_status(*buf);
875 switch (status) {
876 case UMP_STREAM_MSG_STATUS_EP_INFO:
877 ret = ump_handle_ep_info_msg(ump, msg);
878 break;
879 case UMP_STREAM_MSG_STATUS_DEVICE_INFO:
880 ret = ump_handle_device_info_msg(ump, msg);
881 break;
882 case UMP_STREAM_MSG_STATUS_EP_NAME:
883 ret = ump_handle_ep_name_msg(ump, msg);
884 break;
885 case UMP_STREAM_MSG_STATUS_PRODUCT_ID:
886 ret = ump_handle_product_id_msg(ump, msg);
887 break;
888 case UMP_STREAM_MSG_STATUS_STREAM_CFG:
889 ret = ump_handle_stream_cfg_msg(ump, msg);
890 break;
891 case UMP_STREAM_MSG_STATUS_FB_INFO:
892 ret = ump_handle_fb_info_msg(ump, msg);
893 break;
894 case UMP_STREAM_MSG_STATUS_FB_NAME:
895 ret = ump_handle_fb_name_msg(ump, msg);
896 break;
897 default:
898 return;
899 }
900
901 /* when the message has been processed fully, wake up */
902 if (ret > 0 && ump->stream_wait_for == status) {
903 WRITE_ONCE(ump->stream_finished, 1);
904 wake_up(&ump->stream_wait);
905 }
906}
907
908/**
909 * snd_ump_parse_endpoint - parse endpoint and create function blocks
910 * @ump: UMP object
911 *
912 * Returns 0 for successful parse, -ENODEV if device doesn't respond
913 * (or the query is unsupported), or other error code for serious errors.
914 */
915int snd_ump_parse_endpoint(struct snd_ump_endpoint *ump)
916{
917 int blk, err;
918 u32 msg;
919
920 if (!(ump->core.info_flags & SNDRV_RAWMIDI_INFO_DUPLEX))
921 return -ENODEV;
922
923 err = ump_request_open(ump);
924 if (err < 0) {
925 ump_dbg(ump, "Unable to open rawmidi device: %d\n", err);
926 return err;
927 }
928
929 /* Check Endpoint Information */
930 msg = ump_stream_compose(UMP_STREAM_MSG_STATUS_EP_DISCOVERY, 0) |
931 0x0101; /* UMP version 1.1 */
932 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_EP_INFO,
933 UMP_STREAM_MSG_STATUS_EP_INFO);
934 if (err < 0) {
935 ump_dbg(ump, "Unable to get UMP EP info\n");
936 goto error;
937 }
938
939 /* Request Endpoint Device Info */
940 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_DEVICE_INFO,
941 UMP_STREAM_MSG_STATUS_DEVICE_INFO);
942 if (err < 0)
943 ump_dbg(ump, "Unable to get UMP EP device info\n");
944
945 /* Request Endpoint Name */
946 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_EP_NAME,
947 UMP_STREAM_MSG_STATUS_EP_NAME);
948 if (err < 0)
949 ump_dbg(ump, "Unable to get UMP EP name string\n");
950
951 /* Request Endpoint Product ID */
952 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_PRODUCT_ID,
953 UMP_STREAM_MSG_STATUS_PRODUCT_ID);
954 if (err < 0)
955 ump_dbg(ump, "Unable to get UMP EP product ID string\n");
956
957 /* Get the current stream configuration */
958 err = ump_req_msg(ump, msg, UMP_STREAM_MSG_REQUEST_STREAM_CFG,
959 UMP_STREAM_MSG_STATUS_STREAM_CFG);
960 if (err < 0)
961 ump_dbg(ump, "Unable to get UMP EP stream config\n");
962
963 /* Query and create blocks from Function Blocks */
964 for (blk = 0; blk < ump->info.num_blocks; blk++) {
965 err = create_block_from_fb_info(ump, blk);
966 if (err < 0)
967 continue;
968 }
969
970 error:
971 ump->parsed = true;
972 ump_request_close(ump);
973 if (err == -ETIMEDOUT)
974 err = -ENODEV;
975 return err;
976}
977EXPORT_SYMBOL_GPL(snd_ump_parse_endpoint);
978
979#if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
980/*
981 * Legacy rawmidi support
982 */
983static int snd_ump_legacy_open(struct snd_rawmidi_substream *substream)
984{
985 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
986 int dir = substream->stream;
987 int group = ump->legacy_mapping[substream->number];
988 int err = 0;
989
990 mutex_lock(&ump->open_mutex);
991 if (ump->legacy_substreams[dir][group]) {
992 err = -EBUSY;
993 goto unlock;
994 }
995 if (dir == SNDRV_RAWMIDI_STREAM_OUTPUT) {
996 if (!ump->legacy_out_opens) {
997 err = snd_rawmidi_kernel_open(&ump->core, 0,
998 SNDRV_RAWMIDI_LFLG_OUTPUT |
999 SNDRV_RAWMIDI_LFLG_APPEND,
1000 &ump->legacy_out_rfile);
1001 if (err < 0)
1002 goto unlock;
1003 }
1004 ump->legacy_out_opens++;
1005 snd_ump_convert_reset(&ump->out_cvts[group]);
1006 }
1007 spin_lock_irq(&ump->legacy_locks[dir]);
1008 ump->legacy_substreams[dir][group] = substream;
1009 spin_unlock_irq(&ump->legacy_locks[dir]);
1010 unlock:
1011 mutex_unlock(&ump->open_mutex);
1012 return err;
1013}
1014
1015static int snd_ump_legacy_close(struct snd_rawmidi_substream *substream)
1016{
1017 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1018 int dir = substream->stream;
1019 int group = ump->legacy_mapping[substream->number];
1020
1021 mutex_lock(&ump->open_mutex);
1022 spin_lock_irq(&ump->legacy_locks[dir]);
1023 ump->legacy_substreams[dir][group] = NULL;
1024 spin_unlock_irq(&ump->legacy_locks[dir]);
1025 if (dir == SNDRV_RAWMIDI_STREAM_OUTPUT) {
1026 if (!--ump->legacy_out_opens)
1027 snd_rawmidi_kernel_release(&ump->legacy_out_rfile);
1028 }
1029 mutex_unlock(&ump->open_mutex);
1030 return 0;
1031}
1032
1033static void snd_ump_legacy_trigger(struct snd_rawmidi_substream *substream,
1034 int up)
1035{
1036 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1037 int dir = substream->stream;
1038
1039 ump->ops->trigger(ump, dir, up);
1040}
1041
1042static void snd_ump_legacy_drain(struct snd_rawmidi_substream *substream)
1043{
1044 struct snd_ump_endpoint *ump = substream->rmidi->private_data;
1045
1046 if (ump->ops->drain)
1047 ump->ops->drain(ump, SNDRV_RAWMIDI_STREAM_OUTPUT);
1048}
1049
1050static int snd_ump_legacy_dev_register(struct snd_rawmidi *rmidi)
1051{
1052 /* dummy, just for avoiding create superfluous seq clients */
1053 return 0;
1054}
1055
1056static const struct snd_rawmidi_ops snd_ump_legacy_input_ops = {
1057 .open = snd_ump_legacy_open,
1058 .close = snd_ump_legacy_close,
1059 .trigger = snd_ump_legacy_trigger,
1060};
1061
1062static const struct snd_rawmidi_ops snd_ump_legacy_output_ops = {
1063 .open = snd_ump_legacy_open,
1064 .close = snd_ump_legacy_close,
1065 .trigger = snd_ump_legacy_trigger,
1066 .drain = snd_ump_legacy_drain,
1067};
1068
1069static const struct snd_rawmidi_global_ops snd_ump_legacy_ops = {
1070 .dev_register = snd_ump_legacy_dev_register,
1071};
1072
1073static int process_legacy_output(struct snd_ump_endpoint *ump,
1074 u32 *buffer, int count)
1075{
1076 struct snd_rawmidi_substream *substream;
1077 struct ump_cvt_to_ump *ctx;
1078 const int dir = SNDRV_RAWMIDI_STREAM_OUTPUT;
1079 unsigned char c;
1080 int group, size = 0;
1081 unsigned long flags;
1082
1083 if (!ump->out_cvts || !ump->legacy_out_opens)
1084 return 0;
1085
1086 spin_lock_irqsave(&ump->legacy_locks[dir], flags);
1087 for (group = 0; group < SNDRV_UMP_MAX_GROUPS; group++) {
1088 substream = ump->legacy_substreams[dir][group];
1089 if (!substream)
1090 continue;
1091 ctx = &ump->out_cvts[group];
1092 while (!ctx->ump_bytes &&
1093 snd_rawmidi_transmit(substream, &c, 1) > 0)
1094 snd_ump_convert_to_ump(ctx, group, ump->info.protocol, c);
1095 if (ctx->ump_bytes && ctx->ump_bytes <= count) {
1096 size = ctx->ump_bytes;
1097 memcpy(buffer, ctx->ump, size);
1098 ctx->ump_bytes = 0;
1099 break;
1100 }
1101 }
1102 spin_unlock_irqrestore(&ump->legacy_locks[dir], flags);
1103 return size;
1104}
1105
1106static void process_legacy_input(struct snd_ump_endpoint *ump, const u32 *src,
1107 int words)
1108{
1109 struct snd_rawmidi_substream *substream;
1110 unsigned char buf[16];
1111 unsigned char group;
1112 unsigned long flags;
1113 const int dir = SNDRV_RAWMIDI_STREAM_INPUT;
1114 int size;
1115
1116 size = snd_ump_convert_from_ump(src, buf, &group);
1117 if (size <= 0)
1118 return;
1119 spin_lock_irqsave(&ump->legacy_locks[dir], flags);
1120 substream = ump->legacy_substreams[dir][group];
1121 if (substream)
1122 snd_rawmidi_receive(substream, buf, size);
1123 spin_unlock_irqrestore(&ump->legacy_locks[dir], flags);
1124}
1125
1126/* Fill ump->legacy_mapping[] for groups to be used for legacy rawmidi */
1127static int fill_legacy_mapping(struct snd_ump_endpoint *ump)
1128{
1129 struct snd_ump_block *fb;
1130 unsigned int group_maps = 0;
1131 int i, num;
1132
1133 if (ump->info.flags & SNDRV_UMP_EP_INFO_STATIC_BLOCKS) {
1134 list_for_each_entry(fb, &ump->block_list, list) {
1135 for (i = 0; i < fb->info.num_groups; i++)
1136 group_maps |= 1U << (fb->info.first_group + i);
1137 }
1138 if (!group_maps)
1139 ump_info(ump, "No UMP Group is found in FB\n");
1140 }
1141
1142 /* use all groups for non-static case */
1143 if (!group_maps)
1144 group_maps = (1U << SNDRV_UMP_MAX_GROUPS) - 1;
1145
1146 num = 0;
1147 for (i = 0; i < SNDRV_UMP_MAX_GROUPS; i++)
1148 if (group_maps & (1U << i))
1149 ump->legacy_mapping[num++] = i;
1150
1151 return num;
1152}
1153
1154static void fill_substream_names(struct snd_ump_endpoint *ump,
1155 struct snd_rawmidi *rmidi, int dir)
1156{
1157 struct snd_rawmidi_substream *s;
1158
1159 list_for_each_entry(s, &rmidi->streams[dir].substreams, list)
1160 snprintf(s->name, sizeof(s->name), "Group %d (%.16s)",
1161 ump->legacy_mapping[s->number] + 1, ump->info.name);
1162}
1163
1164int snd_ump_attach_legacy_rawmidi(struct snd_ump_endpoint *ump,
1165 char *id, int device)
1166{
1167 struct snd_rawmidi *rmidi;
1168 bool input, output;
1169 int err, num;
1170
1171 ump->out_cvts = kcalloc(SNDRV_UMP_MAX_GROUPS,
1172 sizeof(*ump->out_cvts), GFP_KERNEL);
1173 if (!ump->out_cvts)
1174 return -ENOMEM;
1175
1176 num = fill_legacy_mapping(ump);
1177
1178 input = ump->core.info_flags & SNDRV_RAWMIDI_INFO_INPUT;
1179 output = ump->core.info_flags & SNDRV_RAWMIDI_INFO_OUTPUT;
1180 err = snd_rawmidi_new(ump->core.card, id, device,
1181 output ? num : 0, input ? num : 0,
1182 &rmidi);
1183 if (err < 0) {
1184 kfree(ump->out_cvts);
1185 return err;
1186 }
1187
1188 if (input)
1189 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
1190 &snd_ump_legacy_input_ops);
1191 if (output)
1192 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
1193 &snd_ump_legacy_output_ops);
1194 snprintf(rmidi->name, sizeof(rmidi->name), "%.68s (MIDI 1.0)",
1195 ump->info.name);
1196 rmidi->info_flags = ump->core.info_flags & ~SNDRV_RAWMIDI_INFO_UMP;
1197 rmidi->ops = &snd_ump_legacy_ops;
1198 rmidi->private_data = ump;
1199 ump->legacy_rmidi = rmidi;
1200 if (input)
1201 fill_substream_names(ump, rmidi, SNDRV_RAWMIDI_STREAM_INPUT);
1202 if (output)
1203 fill_substream_names(ump, rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT);
1204
1205 ump_dbg(ump, "Created a legacy rawmidi #%d (%s)\n", device, id);
1206 return 0;
1207}
1208EXPORT_SYMBOL_GPL(snd_ump_attach_legacy_rawmidi);
1209#endif /* CONFIG_SND_UMP_LEGACY_RAWMIDI */
1210
1211MODULE_DESCRIPTION("Universal MIDI Packet (UMP) Core Driver");
1212MODULE_LICENSE("GPL");