sound/core/ump.c

   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         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 }
 698 EXPORT_SYMBOL_GPL(snd_ump_switch_protocol);
 699
 700 /* handle EP stream config message; update the UMP protocol */
 701 static 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 */
 712 static 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 */
 732 static 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 */
 750 static 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 */
 760 static 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 */
 790 static 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
 810 static 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() */
 855 static 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  */
 915 int 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 }
 977 EXPORT_SYMBOL_GPL(snd_ump_parse_endpoint);
 978
 979 #if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI)
 980 /*
 981  * Legacy rawmidi support
 982  */
 983 static 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;
 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 0;
1013 }
1014
1015 static 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
1033 static 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
1042 static 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
1050 static 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
1056 static 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
1062 static 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
1069 static const struct snd_rawmidi_global_ops snd_ump_legacy_ops = {
1070         .dev_register = snd_ump_legacy_dev_register,
1071 };
1072
1073 static 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
1106 static 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 */
1127 static 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
1154 static 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
1164 int 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 }
1208 EXPORT_SYMBOL_GPL(snd_ump_attach_legacy_rawmidi);
1209 #endif /* CONFIG_SND_UMP_LEGACY_RAWMIDI */
1210
1211 MODULE_DESCRIPTION("Universal MIDI Packet (UMP) Core Driver");
1212 MODULE_LICENSE("GPL");