drivers/usb/gadget/function/f_midi2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * f_midi2.c -- USB MIDI 2.0 class function driver
   4  */
   5
   6 #include <linux/device.h>
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/slab.h>
  10
  11 #include <sound/core.h>
  12 #include <sound/control.h>
  13 #include <sound/ump.h>
  14 #include <sound/ump_msg.h>
  15 #include <sound/ump_convert.h>
  16
  17 #include <linux/usb/ch9.h>
  18 #include <linux/usb/func_utils.h>
  19 #include <linux/usb/gadget.h>
  20 #include <linux/usb/audio.h>
  21 #include <linux/usb/midi-v2.h>
  22
  23 #include "u_midi2.h"
  24
  25 struct f_midi2;
  26 struct f_midi2_ep;
  27 struct f_midi2_usb_ep;
  28
  29 /* Context for each USB request */
  30 struct f_midi2_req_ctx {
  31         struct f_midi2_usb_ep *usb_ep;  /* belonging USB EP */
  32         unsigned int index;             /* array index: 0-31 */
  33         struct usb_request *req;        /* assigned request */
  34 };
  35
  36 /* Resources for a USB Endpoint */
  37 struct f_midi2_usb_ep {
  38         struct f_midi2 *card;           /* belonging card */
  39         struct f_midi2_ep *ep;          /* belonging UMP EP (optional) */
  40         struct usb_ep *usb_ep;          /* assigned USB EP */
  41         void (*complete)(struct usb_ep *usb_ep, struct usb_request *req);
  42         unsigned long free_reqs;        /* bitmap for unused requests */
  43         unsigned int num_reqs;          /* number of allocated requests */
  44         struct f_midi2_req_ctx *reqs;   /* request context array */
  45 };
  46
  47 /* Resources for UMP Function Block (and USB Group Terminal Block) */
  48 struct f_midi2_block {
  49         struct f_midi2_block_info info; /* FB info, copied from configfs */
  50         struct snd_ump_block *fb;       /* assigned FB */
  51         unsigned int gtb_id;            /* assigned GTB id */
  52         unsigned int string_id;         /* assigned string id */
  53 };
  54
  55 /* Temporary buffer for altset 0 MIDI 1.0 handling */
  56 struct f_midi2_midi1_port {
  57         unsigned int pending; /* pending bytes on the input buffer */
  58         u8 buf[32];     /* raw MIDI 1.0 byte input */
  59         u8 state;       /* running status */
  60         u8 data[2];     /* rendered USB MIDI 1.0 packet data */
  61 };
  62
  63 /* MIDI 1.0 message states */
  64 enum {
  65         STATE_INITIAL = 0,      /* pseudo state */
  66         STATE_1PARAM,
  67         STATE_2PARAM_1,
  68         STATE_2PARAM_2,
  69         STATE_SYSEX_0,
  70         STATE_SYSEX_1,
  71         STATE_SYSEX_2,
  72         STATE_REAL_TIME,
  73         STATE_FINISHED,         /* pseudo state */
  74 };
  75
  76 /* Resources for UMP Endpoint */
  77 struct f_midi2_ep {
  78         struct snd_ump_endpoint *ump;   /* assigned UMP EP */
  79         struct f_midi2 *card;           /* belonging MIDI 2.0 device */
  80
  81         struct f_midi2_ep_info info;    /* UMP EP info, copied from configfs */
  82         unsigned int num_blks;          /* number of FBs */
  83         struct f_midi2_block blks[SNDRV_UMP_MAX_BLOCKS];        /* UMP FBs */
  84
  85         struct f_midi2_usb_ep ep_in;    /* USB MIDI EP-in */
  86         struct f_midi2_usb_ep ep_out;   /* USB MIDI EP-out */
  87
  88         u8 in_group_to_cable[SNDRV_UMP_MAX_GROUPS]; /* map to cable; 1-based! */
  89 };
  90
  91 /* indices for USB strings */
  92 enum {
  93         STR_IFACE = 0,
  94         STR_GTB1 = 1,
  95 };
  96
  97 /* 1-based GTB id to string id */
  98 #define gtb_to_str_id(id)       (STR_GTB1 + (id) - 1)
  99
 100 /* mapping from MIDI 1.0 cable to UMP group */
 101 struct midi1_cable_mapping {
 102         struct f_midi2_ep *ep;
 103         unsigned char block;
 104         unsigned char group;
 105 };
 106
 107 /* operation mode */
 108 enum {
 109         MIDI_OP_MODE_UNSET,     /* no altset set yet */
 110         MIDI_OP_MODE_MIDI1,     /* MIDI 1.0 (altset 0) is used */
 111         MIDI_OP_MODE_MIDI2,     /* MIDI 2.0 (altset 1) is used */
 112 };
 113
 114 /* Resources for MIDI 2.0 Device */
 115 struct f_midi2 {
 116         struct usb_function func;
 117         struct usb_gadget *gadget;
 118         struct snd_card *card;
 119
 120         /* MIDI 1.0 in/out USB EPs */
 121         struct f_midi2_usb_ep midi1_ep_in;
 122         struct f_midi2_usb_ep midi1_ep_out;
 123
 124         /* number of MIDI 1.0 I/O cables */
 125         unsigned int num_midi1_in;
 126         unsigned int num_midi1_out;
 127
 128         /* conversion for MIDI 1.0 EP-in */
 129         struct f_midi2_midi1_port midi1_port[MAX_CABLES];
 130         /* conversion for MIDI 1.0 EP-out */
 131         struct ump_cvt_to_ump midi1_ump_cvt;
 132         /* mapping between cables and UMP groups */
 133         struct midi1_cable_mapping in_cable_mapping[MAX_CABLES];
 134         struct midi1_cable_mapping out_cable_mapping[MAX_CABLES];
 135
 136         int midi_if;                    /* USB MIDI interface number */
 137         int operation_mode;             /* current operation mode */
 138
 139         spinlock_t queue_lock;
 140
 141         struct f_midi2_card_info info;  /* card info, copied from configfs */
 142
 143         unsigned int num_eps;
 144         struct f_midi2_ep midi2_eps[MAX_UMP_EPS];
 145
 146         unsigned int total_blocks;      /* total number of blocks of all EPs */
 147         struct usb_string *string_defs;
 148         struct usb_string *strings;
 149 };
 150
 151 #define func_to_midi2(f)        container_of(f, struct f_midi2, func)
 152
 153 /* convert from MIDI protocol number (1 or 2) to SNDRV_UMP_EP_INFO_PROTO_* */
 154 #define to_ump_protocol(v)      (((v) & 3) << 8)
 155
 156 /* get EP name string */
 157 static const char *ump_ep_name(const struct f_midi2_ep *ep)
 158 {
 159         return ep->info.ep_name ? ep->info.ep_name : "MIDI 2.0 Gadget";
 160 }
 161
 162 /* get EP product ID string */
 163 static const char *ump_product_id(const struct f_midi2_ep *ep)
 164 {
 165         return ep->info.product_id ? ep->info.product_id : "Unique Product ID";
 166 }
 167
 168 /* get FB name string */
 169 static const char *ump_fb_name(const struct f_midi2_block_info *info)
 170 {
 171         return info->name ? info->name : "MIDI 2.0 Gadget I/O";
 172 }
 173
 174 /*
 175  * USB Descriptor Definitions
 176  */
 177 /* GTB header descriptor */
 178 static struct usb_ms20_gr_trm_block_header_descriptor gtb_header_desc = {
 179         .bLength =              sizeof(gtb_header_desc),
 180         .bDescriptorType =      USB_DT_CS_GR_TRM_BLOCK,
 181         .bDescriptorSubtype =   USB_MS_GR_TRM_BLOCK_HEADER,
 182         .wTotalLength =         __cpu_to_le16(0x12), // to be filled
 183 };
 184
 185 /* GTB descriptor template: most items are replaced dynamically */
 186 static struct usb_ms20_gr_trm_block_descriptor gtb_desc = {
 187         .bLength =              sizeof(gtb_desc),
 188         .bDescriptorType =      USB_DT_CS_GR_TRM_BLOCK,
 189         .bDescriptorSubtype =   USB_MS_GR_TRM_BLOCK,
 190         .bGrpTrmBlkID =         0x01,
 191         .bGrpTrmBlkType =       USB_MS_GR_TRM_BLOCK_TYPE_BIDIRECTIONAL,
 192         .nGroupTrm =            0x00,
 193         .nNumGroupTrm =         1,
 194         .iBlockItem =           0,
 195         .bMIDIProtocol =        USB_MS_MIDI_PROTO_1_0_64,
 196         .wMaxInputBandwidth =   0,
 197         .wMaxOutputBandwidth =  0,
 198 };
 199
 200 DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
 201 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
 202 DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
 203 DECLARE_USB_MS20_ENDPOINT_DESCRIPTOR(32);
 204
 205 #define EP_MAX_PACKET_INT       8
 206
 207 /* Audio Control Interface */
 208 static struct usb_interface_descriptor midi2_audio_if_desc = {
 209         .bLength =              USB_DT_INTERFACE_SIZE,
 210         .bDescriptorType =      USB_DT_INTERFACE,
 211         .bInterfaceNumber =     0, // to be filled
 212         .bNumEndpoints =        0,
 213         .bInterfaceClass =      USB_CLASS_AUDIO,
 214         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOCONTROL,
 215         .bInterfaceProtocol =   0,
 216         .iInterface =           0,
 217 };
 218
 219 static struct uac1_ac_header_descriptor_1 midi2_audio_class_desc = {
 220         .bLength =              0x09,
 221         .bDescriptorType =      USB_DT_CS_INTERFACE,
 222         .bDescriptorSubtype =   0x01,
 223         .bcdADC =               __cpu_to_le16(0x0100),
 224         .wTotalLength =         __cpu_to_le16(0x0009),
 225         .bInCollection =        0x01,
 226         .baInterfaceNr =        { 0x01 }, // to be filled
 227 };
 228
 229 /* MIDI 1.0 Streaming Interface (altset 0) */
 230 static struct usb_interface_descriptor midi2_midi1_if_desc = {
 231         .bLength =              USB_DT_INTERFACE_SIZE,
 232         .bDescriptorType =      USB_DT_INTERFACE,
 233         .bInterfaceNumber =     0, // to be filled
 234         .bAlternateSetting =    0,
 235         .bNumEndpoints =        2, // to be filled
 236         .bInterfaceClass =      USB_CLASS_AUDIO,
 237         .bInterfaceSubClass =   USB_SUBCLASS_MIDISTREAMING,
 238         .bInterfaceProtocol =   0,
 239         .iInterface =           0, // to be filled
 240 };
 241
 242 static struct usb_ms_header_descriptor midi2_midi1_class_desc = {
 243         .bLength =              0x07,
 244         .bDescriptorType =      USB_DT_CS_INTERFACE,
 245         .bDescriptorSubtype =   USB_MS_HEADER,
 246         .bcdMSC =               __cpu_to_le16(0x0100),
 247         .wTotalLength =         __cpu_to_le16(0x41), // to be calculated
 248 };
 249
 250 /* MIDI 1.0 EP OUT */
 251 static struct usb_endpoint_descriptor midi2_midi1_ep_out_desc = {
 252         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
 253         .bDescriptorType =      USB_DT_ENDPOINT,
 254         .bEndpointAddress =     USB_DIR_OUT | 0, // set up dynamically
 255         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 256 };
 257
 258 static struct usb_ss_ep_comp_descriptor midi2_midi1_ep_out_ss_comp_desc = {
 259         .bLength                = sizeof(midi2_midi1_ep_out_ss_comp_desc),
 260         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 261 };
 262
 263 static struct usb_ms_endpoint_descriptor_16 midi2_midi1_ep_out_class_desc = {
 264         .bLength =              0x05, // to be filled
 265         .bDescriptorType =      USB_DT_CS_ENDPOINT,
 266         .bDescriptorSubtype =   USB_MS_GENERAL,
 267         .bNumEmbMIDIJack =      1,
 268         .baAssocJackID =        { 0x01 },
 269 };
 270
 271 /* MIDI 1.0 EP IN */
 272 static struct usb_endpoint_descriptor midi2_midi1_ep_in_desc = {
 273         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
 274         .bDescriptorType =      USB_DT_ENDPOINT,
 275         .bEndpointAddress =     USB_DIR_IN | 0, // set up dynamically
 276         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 277 };
 278
 279 static struct usb_ss_ep_comp_descriptor midi2_midi1_ep_in_ss_comp_desc = {
 280         .bLength                = sizeof(midi2_midi1_ep_in_ss_comp_desc),
 281         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 282 };
 283
 284 static struct usb_ms_endpoint_descriptor_16 midi2_midi1_ep_in_class_desc = {
 285         .bLength =              0x05, // to be filled
 286         .bDescriptorType =      USB_DT_CS_ENDPOINT,
 287         .bDescriptorSubtype =   USB_MS_GENERAL,
 288         .bNumEmbMIDIJack =      1,
 289         .baAssocJackID =        { 0x03 },
 290 };
 291
 292 /* MIDI 2.0 Streaming Interface (altset 1) */
 293 static struct usb_interface_descriptor midi2_midi2_if_desc = {
 294         .bLength =              USB_DT_INTERFACE_SIZE,
 295         .bDescriptorType =      USB_DT_INTERFACE,
 296         .bInterfaceNumber =     0, // to be filled
 297         .bAlternateSetting =    1,
 298         .bNumEndpoints =        2, // to be filled
 299         .bInterfaceClass =      USB_CLASS_AUDIO,
 300         .bInterfaceSubClass =   USB_SUBCLASS_MIDISTREAMING,
 301         .bInterfaceProtocol =   0,
 302         .iInterface =           0, // to be filled
 303 };
 304
 305 static struct usb_ms_header_descriptor midi2_midi2_class_desc = {
 306         .bLength =              0x07,
 307         .bDescriptorType =      USB_DT_CS_INTERFACE,
 308         .bDescriptorSubtype =   USB_MS_HEADER,
 309         .bcdMSC =               __cpu_to_le16(0x0200),
 310         .wTotalLength =         __cpu_to_le16(0x07),
 311 };
 312
 313 /* MIDI 2.0 EP OUT */
 314 static struct usb_endpoint_descriptor midi2_midi2_ep_out_desc[MAX_UMP_EPS];
 315
 316 static struct usb_ss_ep_comp_descriptor midi2_midi2_ep_out_ss_comp_desc = {
 317         .bLength                = sizeof(midi2_midi1_ep_out_ss_comp_desc),
 318         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 319 };
 320
 321 static struct usb_ms20_endpoint_descriptor_32 midi2_midi2_ep_out_class_desc[MAX_UMP_EPS];
 322
 323 /* MIDI 2.0 EP IN */
 324 static struct usb_endpoint_descriptor midi2_midi2_ep_in_desc[MAX_UMP_EPS];
 325
 326 static struct usb_ss_ep_comp_descriptor midi2_midi2_ep_in_ss_comp_desc = {
 327         .bLength                = sizeof(midi2_midi2_ep_in_ss_comp_desc),
 328         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 329 };
 330
 331 static struct usb_ms20_endpoint_descriptor_32 midi2_midi2_ep_in_class_desc[MAX_UMP_EPS];
 332
 333 /* Arrays of descriptors to be created */
 334 static void *midi2_audio_descs[] = {
 335         &midi2_audio_if_desc,
 336         &midi2_audio_class_desc,
 337         NULL
 338 };
 339
 340 static void *midi2_midi1_descs[] = {
 341         &midi2_midi1_if_desc,
 342         &midi2_midi1_class_desc,
 343         NULL
 344 };
 345
 346 static void *midi2_midi1_ep_out_descs[] = {
 347         &midi2_midi1_ep_out_desc,
 348         &midi2_midi1_ep_out_class_desc,
 349         NULL
 350 };
 351
 352 static void *midi2_midi1_ep_in_descs[] = {
 353         &midi2_midi1_ep_in_desc,
 354         &midi2_midi1_ep_in_class_desc,
 355         NULL
 356 };
 357
 358 static void *midi2_midi1_ep_out_ss_descs[] = {
 359         &midi2_midi1_ep_out_desc,
 360         &midi2_midi1_ep_out_ss_comp_desc,
 361         &midi2_midi1_ep_out_class_desc,
 362         NULL
 363 };
 364
 365 static void *midi2_midi1_ep_in_ss_descs[] = {
 366         &midi2_midi1_ep_in_desc,
 367         &midi2_midi1_ep_in_ss_comp_desc,
 368         &midi2_midi1_ep_in_class_desc,
 369         NULL
 370 };
 371
 372 static void *midi2_midi2_descs[] = {
 373         &midi2_midi2_if_desc,
 374         &midi2_midi2_class_desc,
 375         NULL
 376 };
 377
 378 /*
 379  * USB request handling
 380  */
 381
 382 /* get an empty request for the given EP */
 383 static struct usb_request *get_empty_request(struct f_midi2_usb_ep *usb_ep)
 384 {
 385         struct usb_request *req = NULL;
 386         unsigned long flags;
 387         int index;
 388
 389         spin_lock_irqsave(&usb_ep->card->queue_lock, flags);
 390         if (!usb_ep->free_reqs)
 391                 goto unlock;
 392         index = find_first_bit(&usb_ep->free_reqs, usb_ep->num_reqs);
 393         if (index >= usb_ep->num_reqs)
 394                 goto unlock;
 395         req = usb_ep->reqs[index].req;
 396         if (!req)
 397                 goto unlock;
 398         clear_bit(index, &usb_ep->free_reqs);
 399         req->length = 0;
 400  unlock:
 401         spin_unlock_irqrestore(&usb_ep->card->queue_lock, flags);
 402         return req;
 403 }
 404
 405 /* put the empty request back */
 406 static void put_empty_request(struct usb_request *req)
 407 {
 408         struct f_midi2_req_ctx *ctx = req->context;
 409         unsigned long flags;
 410
 411         spin_lock_irqsave(&ctx->usb_ep->card->queue_lock, flags);
 412         set_bit(ctx->index, &ctx->usb_ep->free_reqs);
 413         spin_unlock_irqrestore(&ctx->usb_ep->card->queue_lock, flags);
 414 }
 415
 416 /*
 417  * UMP v1.1 Stream message handling
 418  */
 419
 420 /* queue a request to UMP EP; request is either queued or freed after this */
 421 static int queue_request_ep_raw(struct usb_request *req)
 422 {
 423         struct f_midi2_req_ctx *ctx = req->context;
 424         int err;
 425
 426         req->complete = ctx->usb_ep->complete;
 427         err = usb_ep_queue(ctx->usb_ep->usb_ep, req, GFP_ATOMIC);
 428         if (err) {
 429                 put_empty_request(req);
 430                 return err;
 431         }
 432         return 0;
 433 }
 434
 435 /* queue a request with endianness conversion */
 436 static int queue_request_ep_in(struct usb_request *req)
 437 {
 438         /* UMP packets have to be converted to little-endian */
 439         cpu_to_le32_array((u32 *)req->buf, req->length >> 2);
 440         return queue_request_ep_raw(req);
 441 }
 442
 443 /* reply a UMP packet via EP-in */
 444 static int reply_ep_in(struct f_midi2_ep *ep, const void *buf, int len)
 445 {
 446         struct f_midi2_usb_ep *usb_ep = &ep->ep_in;
 447         struct usb_request *req;
 448
 449         req = get_empty_request(usb_ep);
 450         if (!req)
 451                 return -ENOSPC;
 452
 453         req->length = len;
 454         memcpy(req->buf, buf, len);
 455         return queue_request_ep_in(req);
 456 }
 457
 458 /* reply a UMP stream EP info */
 459 static void reply_ump_stream_ep_info(struct f_midi2_ep *ep)
 460 {
 461         struct snd_ump_stream_msg_ep_info rep = {
 462                 .type = UMP_MSG_TYPE_STREAM,
 463                 .status = UMP_STREAM_MSG_STATUS_EP_INFO,
 464                 .ump_version_major = 0x01,
 465                 .ump_version_minor = 0x01,
 466                 .num_function_blocks = ep->num_blks,
 467                 .static_function_block = !!ep->card->info.static_block,
 468                 .protocol = (UMP_STREAM_MSG_EP_INFO_CAP_MIDI1 |
 469                              UMP_STREAM_MSG_EP_INFO_CAP_MIDI2) >> 8,
 470         };
 471
 472         reply_ep_in(ep, &rep, sizeof(rep));
 473 }
 474
 475 /* reply a UMP EP device info */
 476 static void reply_ump_stream_ep_device(struct f_midi2_ep *ep)
 477 {
 478         struct snd_ump_stream_msg_devince_info rep = {
 479                 .type = UMP_MSG_TYPE_STREAM,
 480                 .status = UMP_STREAM_MSG_STATUS_DEVICE_INFO,
 481                 .manufacture_id = ep->info.manufacturer,
 482                 .family_lsb = ep->info.family & 0xff,
 483                 .family_msb = (ep->info.family >> 8) & 0xff,
 484                 .model_lsb = ep->info.model & 0xff,
 485                 .model_msb = (ep->info.model >> 8) & 0xff,
 486                 .sw_revision = ep->info.sw_revision,
 487         };
 488
 489         reply_ep_in(ep, &rep, sizeof(rep));
 490 }
 491
 492 #define UMP_STREAM_PKT_BYTES    16      /* UMP stream packet size = 16 bytes*/
 493 #define UMP_STREAM_EP_STR_OFF   2       /* offset of name string for EP info */
 494 #define UMP_STREAM_FB_STR_OFF   3       /* offset of name string for FB info */
 495
 496 /* Helper to replay a string */
 497 static void reply_ump_stream_string(struct f_midi2_ep *ep, const u8 *name,
 498                                     unsigned int type, unsigned int extra,
 499                                     unsigned int start_ofs)
 500 {
 501         struct f_midi2_usb_ep *usb_ep = &ep->ep_in;
 502         struct f_midi2 *midi2 = ep->card;
 503         struct usb_request *req;
 504         unsigned int pos;
 505         u32 *buf;
 506
 507         if (!*name)
 508                 return;
 509         req = get_empty_request(usb_ep);
 510         if (!req)
 511                 return;
 512
 513         buf = (u32 *)req->buf;
 514         pos = start_ofs;
 515         for (;;) {
 516                 if (pos == start_ofs) {
 517                         memset(buf, 0, UMP_STREAM_PKT_BYTES);
 518                         buf[0] = ump_stream_compose(type, 0) | extra;
 519                 }
 520                 buf[pos / 4] |= *name++ << ((3 - (pos % 4)) * 8);
 521                 if (!*name) {
 522                         if (req->length)
 523                                 buf[0] |= UMP_STREAM_MSG_FORMAT_END << 26;
 524                         req->length += UMP_STREAM_PKT_BYTES;
 525                         break;
 526                 }
 527                 if (++pos == UMP_STREAM_PKT_BYTES) {
 528                         if (!req->length)
 529                                 buf[0] |= UMP_STREAM_MSG_FORMAT_START << 26;
 530                         else
 531                                 buf[0] |= UMP_STREAM_MSG_FORMAT_CONTINUE << 26;
 532                         req->length += UMP_STREAM_PKT_BYTES;
 533                         if (midi2->info.req_buf_size - req->length < UMP_STREAM_PKT_BYTES)
 534                                 break;
 535                         buf += 4;
 536                         pos = start_ofs;
 537                 }
 538         }
 539
 540         if (req->length)
 541                 queue_request_ep_in(req);
 542         else
 543                 put_empty_request(req);
 544 }
 545
 546 /* Reply a UMP EP name string */
 547 static void reply_ump_stream_ep_name(struct f_midi2_ep *ep)
 548 {
 549         reply_ump_stream_string(ep, ump_ep_name(ep),
 550                                 UMP_STREAM_MSG_STATUS_EP_NAME, 0,
 551                                 UMP_STREAM_EP_STR_OFF);
 552 }
 553
 554 /* Reply a UMP EP product ID string */
 555 static void reply_ump_stream_ep_pid(struct f_midi2_ep *ep)
 556 {
 557         reply_ump_stream_string(ep, ump_product_id(ep),
 558                                 UMP_STREAM_MSG_STATUS_PRODUCT_ID, 0,
 559                                 UMP_STREAM_EP_STR_OFF);
 560 }
 561
 562 /* Reply a UMP EP stream config */
 563 static void reply_ump_stream_ep_config(struct f_midi2_ep *ep)
 564 {
 565         struct snd_ump_stream_msg_stream_cfg rep = {
 566                 .type = UMP_MSG_TYPE_STREAM,
 567                 .status = UMP_STREAM_MSG_STATUS_STREAM_CFG,
 568         };
 569
 570         if (ep->info.protocol == 2)
 571                 rep.protocol = UMP_STREAM_MSG_EP_INFO_CAP_MIDI2 >> 8;
 572         else
 573                 rep.protocol = UMP_STREAM_MSG_EP_INFO_CAP_MIDI1 >> 8;
 574
 575         reply_ep_in(ep, &rep, sizeof(rep));
 576 }
 577
 578 /* Reply a UMP FB info */
 579 static void reply_ump_stream_fb_info(struct f_midi2_ep *ep, int blk)
 580 {
 581         struct f_midi2_block_info *b = &ep->blks[blk].info;
 582         struct snd_ump_stream_msg_fb_info rep = {
 583                 .type = UMP_MSG_TYPE_STREAM,
 584                 .status = UMP_STREAM_MSG_STATUS_FB_INFO,
 585                 .active = !!b->active,
 586                 .function_block_id = blk,
 587                 .ui_hint = b->ui_hint,
 588                 .midi_10 = b->is_midi1,
 589                 .direction = b->direction,
 590                 .first_group = b->first_group,
 591                 .num_groups = b->num_groups,
 592                 .midi_ci_version = b->midi_ci_version,
 593                 .sysex8_streams = b->sysex8_streams,
 594         };
 595
 596         reply_ep_in(ep, &rep, sizeof(rep));
 597 }
 598
 599 /* Reply a FB name string */
 600 static void reply_ump_stream_fb_name(struct f_midi2_ep *ep, unsigned int blk)
 601 {
 602         reply_ump_stream_string(ep, ump_fb_name(&ep->blks[blk].info),
 603                                 UMP_STREAM_MSG_STATUS_FB_NAME, blk << 8,
 604                                 UMP_STREAM_FB_STR_OFF);
 605 }
 606
 607 /* Process a UMP Stream message */
 608 static void process_ump_stream_msg(struct f_midi2_ep *ep, const u32 *data)
 609 {
 610         struct f_midi2 *midi2 = ep->card;
 611         unsigned int format, status, blk;
 612
 613         format = ump_stream_message_format(*data);
 614         status = ump_stream_message_status(*data);
 615         switch (status) {
 616         case UMP_STREAM_MSG_STATUS_EP_DISCOVERY:
 617                 if (format)
 618                         return; // invalid
 619                 if (data[1] & UMP_STREAM_MSG_REQUEST_EP_INFO)
 620                         reply_ump_stream_ep_info(ep);
 621                 if (data[1] & UMP_STREAM_MSG_REQUEST_DEVICE_INFO)
 622                         reply_ump_stream_ep_device(ep);
 623                 if (data[1] & UMP_STREAM_MSG_REQUEST_EP_NAME)
 624                         reply_ump_stream_ep_name(ep);
 625                 if (data[1] & UMP_STREAM_MSG_REQUEST_PRODUCT_ID)
 626                         reply_ump_stream_ep_pid(ep);
 627                 if (data[1] & UMP_STREAM_MSG_REQUEST_STREAM_CFG)
 628                         reply_ump_stream_ep_config(ep);
 629                 return;
 630         case UMP_STREAM_MSG_STATUS_STREAM_CFG_REQUEST:
 631                 if (*data & UMP_STREAM_MSG_EP_INFO_CAP_MIDI2) {
 632                         ep->info.protocol = 2;
 633                         DBG(midi2, "Switching Protocol to MIDI2\n");
 634                 } else {
 635                         ep->info.protocol = 1;
 636                         DBG(midi2, "Switching Protocol to MIDI1\n");
 637                 }
 638                 snd_ump_switch_protocol(ep->ump, to_ump_protocol(ep->info.protocol));
 639                 reply_ump_stream_ep_config(ep);
 640                 return;
 641         case UMP_STREAM_MSG_STATUS_FB_DISCOVERY:
 642                 if (format)
 643                         return; // invalid
 644                 blk = (*data >> 8) & 0xff;
 645                 if (blk == 0xff) {
 646                         /* inquiry for all blocks */
 647                         for (blk = 0; blk < ep->num_blks; blk++) {
 648                                 if (*data & UMP_STREAM_MSG_REQUEST_FB_INFO)
 649                                         reply_ump_stream_fb_info(ep, blk);
 650                                 if (*data & UMP_STREAM_MSG_REQUEST_FB_NAME)
 651                                         reply_ump_stream_fb_name(ep, blk);
 652                         }
 653                 } else if (blk < ep->num_blks) {
 654                         /* only the specified block */
 655                         if (*data & UMP_STREAM_MSG_REQUEST_FB_INFO)
 656                                 reply_ump_stream_fb_info(ep, blk);
 657                         if (*data & UMP_STREAM_MSG_REQUEST_FB_NAME)
 658                                 reply_ump_stream_fb_name(ep, blk);
 659                 }
 660                 return;
 661         }
 662 }
 663
 664 /* Process UMP messages included in a USB request */
 665 static void process_ump(struct f_midi2_ep *ep, const struct usb_request *req)
 666 {
 667         const u32 *data = (u32 *)req->buf;
 668         int len = req->actual >> 2;
 669         const u32 *in_buf = ep->ump->input_buf;
 670
 671         for (; len > 0; len--, data++) {
 672                 if (snd_ump_receive_ump_val(ep->ump, *data) <= 0)
 673                         continue;
 674                 if (ump_message_type(*in_buf) == UMP_MSG_TYPE_STREAM)
 675                         process_ump_stream_msg(ep, in_buf);
 676         }
 677 }
 678
 679 /*
 680  * MIDI 2.0 UMP USB request handling
 681  */
 682
 683 /* complete handler for UMP EP-out requests */
 684 static void f_midi2_ep_out_complete(struct usb_ep *usb_ep,
 685                                     struct usb_request *req)
 686 {
 687         struct f_midi2_req_ctx *ctx = req->context;
 688         struct f_midi2_ep *ep = ctx->usb_ep->ep;
 689         struct f_midi2 *midi2 = ep->card;
 690         int status = req->status;
 691
 692         if (status) {
 693                 DBG(midi2, "%s complete error %d: %d/%d\n",
 694                     usb_ep->name, status, req->actual, req->length);
 695                 goto error;
 696         }
 697
 698         /* convert to UMP packet in native endianness */
 699         le32_to_cpu_array((u32 *)req->buf, req->actual >> 2);
 700
 701         if (midi2->info.process_ump)
 702                 process_ump(ep, req);
 703
 704         snd_ump_receive(ep->ump, req->buf, req->actual & ~3);
 705
 706         if (midi2->operation_mode != MIDI_OP_MODE_MIDI2)
 707                 goto error;
 708
 709         if (queue_request_ep_raw(req))
 710                 goto error;
 711         return;
 712
 713  error:
 714         put_empty_request(req);
 715 }
 716
 717 /* Transmit UMP packets received from user-space to the gadget */
 718 static void process_ump_transmit(struct f_midi2_ep *ep)
 719 {
 720         struct f_midi2_usb_ep *usb_ep = &ep->ep_in;
 721         struct f_midi2 *midi2 = ep->card;
 722         struct usb_request *req;
 723         int len;
 724
 725         if (!usb_ep->usb_ep->enabled)
 726                 return;
 727
 728         for (;;) {
 729                 req = get_empty_request(usb_ep);
 730                 if (!req)
 731                         break;
 732                 len = snd_ump_transmit(ep->ump, (u32 *)req->buf,
 733                                        midi2->info.req_buf_size);
 734                 if (len <= 0) {
 735                         put_empty_request(req);
 736                         break;
 737                 }
 738
 739                 req->length = len;
 740                 if (queue_request_ep_in(req) < 0)
 741                         break;
 742         }
 743 }
 744
 745 /* Complete handler for UMP EP-in requests */
 746 static void f_midi2_ep_in_complete(struct usb_ep *usb_ep,
 747                                    struct usb_request *req)
 748 {
 749         struct f_midi2_req_ctx *ctx = req->context;
 750         struct f_midi2_ep *ep = ctx->usb_ep->ep;
 751         struct f_midi2 *midi2 = ep->card;
 752         int status = req->status;
 753
 754         put_empty_request(req);
 755
 756         if (status) {
 757                 DBG(midi2, "%s complete error %d: %d/%d\n",
 758                     usb_ep->name, status, req->actual, req->length);
 759                 return;
 760         }
 761
 762         process_ump_transmit(ep);
 763 }
 764
 765 /*
 766  * MIDI1 (altset 0) USB request handling
 767  */
 768
 769 /* process one MIDI byte -- copied from f_midi.c
 770  *
 771  * fill the packet or request if needed
 772  * returns true if the request became empty (queued)
 773  */
 774 static bool process_midi1_byte(struct f_midi2 *midi2, u8 cable, u8 b,
 775                                struct usb_request **req_p)
 776 {
 777         struct f_midi2_midi1_port *port = &midi2->midi1_port[cable];
 778         u8 p[4] = { cable << 4, 0, 0, 0 };
 779         int next_state = STATE_INITIAL;
 780         struct usb_request *req = *req_p;
 781
 782         switch (b) {
 783         case 0xf8 ... 0xff:
 784                 /* System Real-Time Messages */
 785                 p[0] |= 0x0f;
 786                 p[1] = b;
 787                 next_state = port->state;
 788                 port->state = STATE_REAL_TIME;
 789                 break;
 790
 791         case 0xf7:
 792                 /* End of SysEx */
 793                 switch (port->state) {
 794                 case STATE_SYSEX_0:
 795                         p[0] |= 0x05;
 796                         p[1] = 0xf7;
 797                         next_state = STATE_FINISHED;
 798                         break;
 799                 case STATE_SYSEX_1:
 800                         p[0] |= 0x06;
 801                         p[1] = port->data[0];
 802                         p[2] = 0xf7;
 803                         next_state = STATE_FINISHED;
 804                         break;
 805                 case STATE_SYSEX_2:
 806                         p[0] |= 0x07;
 807                         p[1] = port->data[0];
 808                         p[2] = port->data[1];
 809                         p[3] = 0xf7;
 810                         next_state = STATE_FINISHED;
 811                         break;
 812                 default:
 813                         /* Ignore byte */
 814                         next_state = port->state;
 815                         port->state = STATE_INITIAL;
 816                 }
 817                 break;
 818
 819         case 0xf0 ... 0xf6:
 820                 /* System Common Messages */
 821                 port->data[0] = port->data[1] = 0;
 822                 port->state = STATE_INITIAL;
 823                 switch (b) {
 824                 case 0xf0:
 825                         port->data[0] = b;
 826                         port->data[1] = 0;
 827                         next_state = STATE_SYSEX_1;
 828                         break;
 829                 case 0xf1:
 830                 case 0xf3:
 831                         port->data[0] = b;
 832                         next_state = STATE_1PARAM;
 833                         break;
 834                 case 0xf2:
 835                         port->data[0] = b;
 836                         next_state = STATE_2PARAM_1;
 837                         break;
 838                 case 0xf4:
 839                 case 0xf5:
 840                         next_state = STATE_INITIAL;
 841                         break;
 842                 case 0xf6:
 843                         p[0] |= 0x05;
 844                         p[1] = 0xf6;
 845                         next_state = STATE_FINISHED;
 846                         break;
 847                 }
 848                 break;
 849
 850         case 0x80 ... 0xef:
 851                 /*
 852                  * Channel Voice Messages, Channel Mode Messages
 853                  * and Control Change Messages.
 854                  */
 855                 port->data[0] = b;
 856                 port->data[1] = 0;
 857                 port->state = STATE_INITIAL;
 858                 if (b >= 0xc0 && b <= 0xdf)
 859                         next_state = STATE_1PARAM;
 860                 else
 861                         next_state = STATE_2PARAM_1;
 862                 break;
 863
 864         case 0x00 ... 0x7f:
 865                 /* Message parameters */
 866                 switch (port->state) {
 867                 case STATE_1PARAM:
 868                         if (port->data[0] < 0xf0)
 869                                 p[0] |= port->data[0] >> 4;
 870                         else
 871                                 p[0] |= 0x02;
 872
 873                         p[1] = port->data[0];
 874                         p[2] = b;
 875                         /* This is to allow Running State Messages */
 876                         next_state = STATE_1PARAM;
 877                         break;
 878                 case STATE_2PARAM_1:
 879                         port->data[1] = b;
 880                         next_state = STATE_2PARAM_2;
 881                         break;
 882                 case STATE_2PARAM_2:
 883                         if (port->data[0] < 0xf0)
 884                                 p[0] |= port->data[0] >> 4;
 885                         else
 886                                 p[0] |= 0x03;
 887
 888                         p[1] = port->data[0];
 889                         p[2] = port->data[1];
 890                         p[3] = b;
 891                         /* This is to allow Running State Messages */
 892                         next_state = STATE_2PARAM_1;
 893                         break;
 894                 case STATE_SYSEX_0:
 895                         port->data[0] = b;
 896                         next_state = STATE_SYSEX_1;
 897                         break;
 898                 case STATE_SYSEX_1:
 899                         port->data[1] = b;
 900                         next_state = STATE_SYSEX_2;
 901                         break;
 902                 case STATE_SYSEX_2:
 903                         p[0] |= 0x04;
 904                         p[1] = port->data[0];
 905                         p[2] = port->data[1];
 906                         p[3] = b;
 907                         next_state = STATE_SYSEX_0;
 908                         break;
 909                 }
 910                 break;
 911         }
 912
 913         /* States where we have to write into the USB request */
 914         if (next_state == STATE_FINISHED ||
 915             port->state == STATE_SYSEX_2 ||
 916             port->state == STATE_1PARAM ||
 917             port->state == STATE_2PARAM_2 ||
 918             port->state == STATE_REAL_TIME) {
 919                 memcpy(req->buf + req->length, p, sizeof(p));
 920                 req->length += sizeof(p);
 921
 922                 if (next_state == STATE_FINISHED) {
 923                         next_state = STATE_INITIAL;
 924                         port->data[0] = port->data[1] = 0;
 925                 }
 926
 927                 if (midi2->info.req_buf_size - req->length <= 4) {
 928                         queue_request_ep_raw(req);
 929                         *req_p = NULL;
 930                         return true;
 931                 }
 932         }
 933
 934         port->state = next_state;
 935         return false;
 936 }
 937
 938 /* process all pending MIDI bytes in the internal buffer;
 939  * returns true if the request gets empty
 940  * returns false if all have been processed
 941  */
 942 static bool process_midi1_pending_buf(struct f_midi2 *midi2,
 943                                       struct usb_request **req_p)
 944 {
 945         unsigned int cable, c;
 946
 947         for (cable = 0; cable < midi2->num_midi1_in; cable++) {
 948                 struct f_midi2_midi1_port *port = &midi2->midi1_port[cable];
 949
 950                 if (!port->pending)
 951                         continue;
 952                 for (c = 0; c < port->pending; c++) {
 953                         if (process_midi1_byte(midi2, cable, port->buf[c],
 954                                                req_p)) {
 955                                 port->pending -= c;
 956                                 if (port->pending)
 957                                         memmove(port->buf, port->buf + c,
 958                                                 port->pending);
 959                                 return true;
 960                         }
 961                 }
 962                 port->pending = 0;
 963         }
 964
 965         return false;
 966 }
 967
 968 /* fill the MIDI bytes onto the temporary buffer
 969  */
 970 static void fill_midi1_pending_buf(struct f_midi2 *midi2, u8 cable, u8 *buf,
 971                                    unsigned int size)
 972 {
 973         struct f_midi2_midi1_port *port = &midi2->midi1_port[cable];
 974
 975         if (port->pending + size > sizeof(port->buf))
 976                 return;
 977         memcpy(port->buf + port->pending, buf, size);
 978         port->pending += size;
 979 }
 980
 981 /* try to process data given from the associated UMP stream */
 982 static void process_midi1_transmit(struct f_midi2 *midi2)
 983 {
 984         struct f_midi2_usb_ep *usb_ep = &midi2->midi1_ep_in;
 985         struct f_midi2_ep *ep = &midi2->midi2_eps[0];
 986         struct usb_request *req = NULL;
 987         /* 12 is the largest outcome (4 MIDI1 cmds) for a single UMP packet */
 988         unsigned char outbuf[12];
 989         unsigned char group, cable;
 990         int len, size;
 991         u32 ump;
 992
 993         if (!usb_ep->usb_ep || !usb_ep->usb_ep->enabled)
 994                 return;
 995
 996         for (;;) {
 997                 if (!req) {
 998                         req = get_empty_request(usb_ep);
 999                         if (!req)
1000                                 break;
1001                 }
1002
1003                 if (process_midi1_pending_buf(midi2, &req))
1004                         continue;
1005
1006                 len = snd_ump_transmit(ep->ump, &ump, 4);
1007                 if (len <= 0)
1008                         break;
1009                 if (snd_ump_receive_ump_val(ep->ump, ump) <= 0)
1010                         continue;
1011                 size = snd_ump_convert_from_ump(ep->ump->input_buf, outbuf,
1012                                                 &group);
1013                 if (size <= 0)
1014                         continue;
1015                 cable = ep->in_group_to_cable[group];
1016                 if (!cable)
1017                         continue;
1018                 cable--; /* to 0-base */
1019                 fill_midi1_pending_buf(midi2, cable, outbuf, size);
1020         }
1021
1022         if (req) {
1023                 if (req->length)
1024                         queue_request_ep_raw(req);
1025                 else
1026                         put_empty_request(req);
1027         }
1028 }
1029
1030 /* complete handler for MIDI1 EP-in requests */
1031 static void f_midi2_midi1_ep_in_complete(struct usb_ep *usb_ep,
1032                                          struct usb_request *req)
1033 {
1034         struct f_midi2_req_ctx *ctx = req->context;
1035         struct f_midi2 *midi2 = ctx->usb_ep->card;
1036         int status = req->status;
1037
1038         put_empty_request(req);
1039
1040         if (status) {
1041                 DBG(midi2, "%s complete error %d: %d/%d\n",
1042                     usb_ep->name, status, req->actual, req->length);
1043                 return;
1044         }
1045
1046         process_midi1_transmit(midi2);
1047 }
1048
1049 /* complete handler for MIDI1 EP-out requests */
1050 static void f_midi2_midi1_ep_out_complete(struct usb_ep *usb_ep,
1051                                           struct usb_request *req)
1052 {
1053         struct f_midi2_req_ctx *ctx = req->context;
1054         struct f_midi2 *midi2 = ctx->usb_ep->card;
1055         struct f_midi2_ep *ep;
1056         struct ump_cvt_to_ump *cvt = &midi2->midi1_ump_cvt;
1057         static const u8 midi1_packet_bytes[16] = {
1058                 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
1059         };
1060         unsigned int group, cable, bytes, c, len;
1061         int status = req->status;
1062         const u8 *buf = req->buf;
1063
1064         if (status) {
1065                 DBG(midi2, "%s complete error %d: %d/%d\n",
1066                     usb_ep->name, status, req->actual, req->length);
1067                 goto error;
1068         }
1069
1070         len = req->actual >> 2;
1071         for (; len; len--, buf += 4) {
1072                 cable = *buf >> 4;
1073                 ep = midi2->out_cable_mapping[cable].ep;
1074                 if (!ep)
1075                         continue;
1076                 group = midi2->out_cable_mapping[cable].group;
1077                 bytes = midi1_packet_bytes[*buf & 0x0f];
1078                 for (c = 0; c < bytes; c++) {
1079                         snd_ump_convert_to_ump(cvt, group,
1080                                                to_ump_protocol(ep->info.protocol),
1081                                                buf[c + 1]);
1082                         if (cvt->ump_bytes) {
1083                                 snd_ump_receive(ep->ump, cvt->ump,
1084                                                 cvt->ump_bytes);
1085                                 cvt->ump_bytes = 0;
1086                         }
1087                 }
1088         }
1089
1090         if (midi2->operation_mode != MIDI_OP_MODE_MIDI1)
1091                 goto error;
1092
1093         if (queue_request_ep_raw(req))
1094                 goto error;
1095         return;
1096
1097  error:
1098         put_empty_request(req);
1099 }
1100
1101 /*
1102  * Common EP handling helpers
1103  */
1104
1105 /* Start MIDI EP */
1106 static int f_midi2_start_ep(struct f_midi2_usb_ep *usb_ep,
1107                             struct usb_function *fn)
1108 {
1109         int err;
1110
1111         if (!usb_ep->usb_ep)
1112                 return 0;
1113
1114         usb_ep_disable(usb_ep->usb_ep);
1115         err = config_ep_by_speed(usb_ep->card->gadget, fn, usb_ep->usb_ep);
1116         if (err)
1117                 return err;
1118         return usb_ep_enable(usb_ep->usb_ep);
1119 }
1120
1121 /* Drop pending requests */
1122 static void f_midi2_drop_reqs(struct f_midi2_usb_ep *usb_ep)
1123 {
1124         int i;
1125
1126         if (!usb_ep->usb_ep || !usb_ep->num_reqs)
1127                 return;
1128
1129         for (i = 0; i < usb_ep->num_reqs; i++) {
1130                 if (!test_bit(i, &usb_ep->free_reqs) && usb_ep->reqs[i].req) {
1131                         usb_ep_dequeue(usb_ep->usb_ep, usb_ep->reqs[i].req);
1132                         set_bit(i, &usb_ep->free_reqs);
1133                 }
1134         }
1135 }
1136
1137 /* Allocate requests for the given EP */
1138 static int f_midi2_alloc_ep_reqs(struct f_midi2_usb_ep *usb_ep)
1139 {
1140         struct f_midi2 *midi2 = usb_ep->card;
1141         int i;
1142
1143         if (!usb_ep->usb_ep)
1144                 return 0;
1145         if (!usb_ep->reqs)
1146                 return -EINVAL;
1147
1148         for (i = 0; i < midi2->info.num_reqs; i++) {
1149                 if (usb_ep->reqs[i].req)
1150                         continue;
1151                 usb_ep->reqs[i].req = alloc_ep_req(usb_ep->usb_ep,
1152                                                    midi2->info.req_buf_size);
1153                 if (!usb_ep->reqs[i].req)
1154                         return -ENOMEM;
1155                 usb_ep->reqs[i].req->context = &usb_ep->reqs[i];
1156         }
1157         return 0;
1158 }
1159
1160 /* Free allocated requests */
1161 static void f_midi2_free_ep_reqs(struct f_midi2_usb_ep *usb_ep)
1162 {
1163         struct f_midi2 *midi2 = usb_ep->card;
1164         int i;
1165
1166         for (i = 0; i < midi2->info.num_reqs; i++) {
1167                 if (!usb_ep->reqs[i].req)
1168                         continue;
1169                 free_ep_req(usb_ep->usb_ep, usb_ep->reqs[i].req);
1170                 usb_ep->reqs[i].req = NULL;
1171         }
1172 }
1173
1174 /* Initialize EP */
1175 static int f_midi2_init_ep(struct f_midi2 *midi2, struct f_midi2_ep *ep,
1176                            struct f_midi2_usb_ep *usb_ep,
1177                            void *desc,
1178                            void (*complete)(struct usb_ep *usb_ep,
1179                                             struct usb_request *req))
1180 {
1181         int i;
1182
1183         usb_ep->card = midi2;
1184         usb_ep->ep = ep;
1185         usb_ep->usb_ep = usb_ep_autoconfig(midi2->gadget, desc);
1186         if (!usb_ep->usb_ep)
1187                 return -ENODEV;
1188         usb_ep->complete = complete;
1189
1190         usb_ep->reqs = kcalloc(midi2->info.num_reqs, sizeof(*usb_ep->reqs),
1191                                GFP_KERNEL);
1192         if (!usb_ep->reqs)
1193                 return -ENOMEM;
1194         for (i = 0; i < midi2->info.num_reqs; i++) {
1195                 usb_ep->reqs[i].index = i;
1196                 usb_ep->reqs[i].usb_ep = usb_ep;
1197                 set_bit(i, &usb_ep->free_reqs);
1198                 usb_ep->num_reqs++;
1199         }
1200
1201         return 0;
1202 }
1203
1204 /* Free EP */
1205 static void f_midi2_free_ep(struct f_midi2_usb_ep *usb_ep)
1206 {
1207         f_midi2_drop_reqs(usb_ep);
1208
1209         f_midi2_free_ep_reqs(usb_ep);
1210
1211         kfree(usb_ep->reqs);
1212         usb_ep->num_reqs = 0;
1213         usb_ep->free_reqs = 0;
1214         usb_ep->reqs = NULL;
1215 }
1216
1217 /* Queue requests for EP-out at start */
1218 static void f_midi2_queue_out_reqs(struct f_midi2_usb_ep *usb_ep)
1219 {
1220         int i, err;
1221
1222         if (!usb_ep->usb_ep)
1223                 return;
1224
1225         for (i = 0; i < usb_ep->num_reqs; i++) {
1226                 if (!test_bit(i, &usb_ep->free_reqs) || !usb_ep->reqs[i].req)
1227                         continue;
1228                 usb_ep->reqs[i].req->complete = usb_ep->complete;
1229                 err = usb_ep_queue(usb_ep->usb_ep, usb_ep->reqs[i].req,
1230                                    GFP_ATOMIC);
1231                 if (!err)
1232                         clear_bit(i, &usb_ep->free_reqs);
1233         }
1234 }
1235
1236 /*
1237  * Gadget Function callbacks
1238  */
1239
1240 /* stop both IN and OUT EPs */
1241 static void f_midi2_stop_eps(struct f_midi2_usb_ep *ep_in,
1242                              struct f_midi2_usb_ep *ep_out)
1243 {
1244         f_midi2_drop_reqs(ep_in);
1245         f_midi2_drop_reqs(ep_out);
1246         f_midi2_free_ep_reqs(ep_in);
1247         f_midi2_free_ep_reqs(ep_out);
1248 }
1249
1250 /* start/queue both IN and OUT EPs */
1251 static int f_midi2_start_eps(struct f_midi2_usb_ep *ep_in,
1252                              struct f_midi2_usb_ep *ep_out,
1253                              struct usb_function *fn)
1254 {
1255         int err;
1256
1257         err = f_midi2_start_ep(ep_in, fn);
1258         if (err)
1259                 return err;
1260         err = f_midi2_start_ep(ep_out, fn);
1261         if (err)
1262                 return err;
1263
1264         err = f_midi2_alloc_ep_reqs(ep_in);
1265         if (err)
1266                 return err;
1267         err = f_midi2_alloc_ep_reqs(ep_out);
1268         if (err)
1269                 return err;
1270
1271         f_midi2_queue_out_reqs(ep_out);
1272         return 0;
1273 }
1274
1275 /* gadget function set_alt callback */
1276 static int f_midi2_set_alt(struct usb_function *fn, unsigned int intf,
1277                            unsigned int alt)
1278 {
1279         struct f_midi2 *midi2 = func_to_midi2(fn);
1280         struct f_midi2_ep *ep;
1281         int i, op_mode, err;
1282
1283         if (intf != midi2->midi_if || alt > 1)
1284                 return 0;
1285
1286         if (alt == 0)
1287                 op_mode = MIDI_OP_MODE_MIDI1;
1288         else
1289                 op_mode = MIDI_OP_MODE_MIDI2;
1290
1291         if (midi2->operation_mode == op_mode)
1292                 return 0;
1293
1294         midi2->operation_mode = op_mode;
1295
1296         if (op_mode != MIDI_OP_MODE_MIDI1)
1297                 f_midi2_stop_eps(&midi2->midi1_ep_in, &midi2->midi1_ep_out);
1298
1299         if (op_mode != MIDI_OP_MODE_MIDI2) {
1300                 for (i = 0; i < midi2->num_eps; i++) {
1301                         ep = &midi2->midi2_eps[i];
1302                         f_midi2_stop_eps(&ep->ep_in, &ep->ep_out);
1303                 }
1304         }
1305
1306         if (op_mode == MIDI_OP_MODE_MIDI1)
1307                 return f_midi2_start_eps(&midi2->midi1_ep_in,
1308                                          &midi2->midi1_ep_out, fn);
1309
1310         if (op_mode == MIDI_OP_MODE_MIDI2) {
1311                 for (i = 0; i < midi2->num_eps; i++) {
1312                         ep = &midi2->midi2_eps[i];
1313
1314                         err = f_midi2_start_eps(&ep->ep_in, &ep->ep_out, fn);
1315                         if (err)
1316                                 return err;
1317                 }
1318         }
1319
1320         return 0;
1321 }
1322
1323 /* gadget function get_alt callback */
1324 static int f_midi2_get_alt(struct usb_function *fn, unsigned int intf)
1325 {
1326         struct f_midi2 *midi2 = func_to_midi2(fn);
1327
1328         if (intf == midi2->midi_if &&
1329             midi2->operation_mode == MIDI_OP_MODE_MIDI2)
1330                 return 1;
1331         return 0;
1332 }
1333
1334 /* convert UMP direction to USB MIDI 2.0 direction */
1335 static unsigned int ump_to_usb_dir(unsigned int ump_dir)
1336 {
1337         switch (ump_dir) {
1338         case SNDRV_UMP_DIR_INPUT:
1339                 return USB_MS_GR_TRM_BLOCK_TYPE_INPUT_ONLY;
1340         case SNDRV_UMP_DIR_OUTPUT:
1341                 return USB_MS_GR_TRM_BLOCK_TYPE_OUTPUT_ONLY;
1342         default:
1343                 return USB_MS_GR_TRM_BLOCK_TYPE_BIDIRECTIONAL;
1344         }
1345 }
1346
1347 /* assign GTB descriptors (for the given request) */
1348 static void assign_block_descriptors(struct f_midi2 *midi2,
1349                                      struct usb_request *req,
1350                                      int max_len)
1351 {
1352         struct usb_ms20_gr_trm_block_header_descriptor header;
1353         struct usb_ms20_gr_trm_block_descriptor *desc;
1354         struct f_midi2_block_info *b;
1355         struct f_midi2_ep *ep;
1356         int i, blk, len;
1357         char *data;
1358
1359         len = sizeof(gtb_header_desc) + sizeof(gtb_desc) * midi2->total_blocks;
1360         if (WARN_ON(len > midi2->info.req_buf_size))
1361                 return;
1362
1363         header = gtb_header_desc;
1364         header.wTotalLength = cpu_to_le16(len);
1365         if (max_len < len) {
1366                 len = min_t(int, len, sizeof(header));
1367                 memcpy(req->buf, &header, len);
1368                 req->length = len;
1369                 req->zero = len < max_len;
1370                 return;
1371         }
1372
1373         memcpy(req->buf, &header, sizeof(header));
1374         data = req->buf + sizeof(header);
1375         for (i = 0; i < midi2->num_eps; i++) {
1376                 ep = &midi2->midi2_eps[i];
1377                 for (blk = 0; blk < ep->num_blks; blk++) {
1378                         b = &ep->blks[blk].info;
1379                         desc = (struct usb_ms20_gr_trm_block_descriptor *)data;
1380
1381                         *desc = gtb_desc;
1382                         desc->bGrpTrmBlkID = ep->blks[blk].gtb_id;
1383                         desc->bGrpTrmBlkType = ump_to_usb_dir(b->direction);
1384                         desc->nGroupTrm = b->first_group;
1385                         desc->nNumGroupTrm = b->num_groups;
1386                         desc->iBlockItem = ep->blks[blk].string_id;
1387
1388                         if (ep->info.protocol == 2)
1389                                 desc->bMIDIProtocol = USB_MS_MIDI_PROTO_2_0;
1390                         else
1391                                 desc->bMIDIProtocol = USB_MS_MIDI_PROTO_1_0_128;
1392
1393                         if (b->is_midi1 == 2) {
1394                                 desc->wMaxInputBandwidth = cpu_to_le16(1);
1395                                 desc->wMaxOutputBandwidth = cpu_to_le16(1);
1396                         }
1397
1398                         data += sizeof(*desc);
1399                 }
1400         }
1401
1402         req->length = len;
1403         req->zero = len < max_len;
1404 }
1405
1406 /* gadget function setup callback: handle GTB requests */
1407 static int f_midi2_setup(struct usb_function *fn,
1408                          const struct usb_ctrlrequest *ctrl)
1409 {
1410         struct f_midi2 *midi2 = func_to_midi2(fn);
1411         struct usb_composite_dev *cdev = fn->config->cdev;
1412         struct usb_request *req = cdev->req;
1413         u16 value, length;
1414
1415         if ((ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD ||
1416             ctrl->bRequest != USB_REQ_GET_DESCRIPTOR)
1417                 return -EOPNOTSUPP;
1418
1419         value = le16_to_cpu(ctrl->wValue);
1420         length = le16_to_cpu(ctrl->wLength);
1421
1422         if ((value >> 8) != USB_DT_CS_GR_TRM_BLOCK)
1423                 return -EOPNOTSUPP;
1424
1425         /* handle only altset 1 */
1426         if ((value & 0xff) != 1)
1427                 return -EOPNOTSUPP;
1428
1429         assign_block_descriptors(midi2, req, length);
1430         return usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1431 }
1432
1433 /* gadget function disable callback */
1434 static void f_midi2_disable(struct usb_function *fn)
1435 {
1436         struct f_midi2 *midi2 = func_to_midi2(fn);
1437
1438         midi2->operation_mode = MIDI_OP_MODE_UNSET;
1439 }
1440
1441 /*
1442  * ALSA UMP ops: most of them are NOPs, only trigger for write is needed
1443  */
1444 static int f_midi2_ump_open(struct snd_ump_endpoint *ump, int dir)
1445 {
1446         return 0;
1447 }
1448
1449 static void f_midi2_ump_close(struct snd_ump_endpoint *ump, int dir)
1450 {
1451 }
1452
1453 static void f_midi2_ump_trigger(struct snd_ump_endpoint *ump, int dir, int up)
1454 {
1455         struct f_midi2_ep *ep = ump->private_data;
1456         struct f_midi2 *midi2 = ep->card;
1457
1458         if (up && dir == SNDRV_RAWMIDI_STREAM_OUTPUT) {
1459                 switch (midi2->operation_mode) {
1460                 case MIDI_OP_MODE_MIDI1:
1461                         process_midi1_transmit(midi2);
1462                         break;
1463                 case MIDI_OP_MODE_MIDI2:
1464                         process_ump_transmit(ep);
1465                         break;
1466                 }
1467         }
1468 }
1469
1470 static void f_midi2_ump_drain(struct snd_ump_endpoint *ump, int dir)
1471 {
1472 }
1473
1474 static const struct snd_ump_ops f_midi2_ump_ops = {
1475         .open = f_midi2_ump_open,
1476         .close = f_midi2_ump_close,
1477         .trigger = f_midi2_ump_trigger,
1478         .drain = f_midi2_ump_drain,
1479 };
1480
1481 /*
1482  * "Operation Mode" control element
1483  */
1484 static int f_midi2_operation_mode_info(struct snd_kcontrol *kcontrol,
1485                                        struct snd_ctl_elem_info *uinfo)
1486 {
1487         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1488         uinfo->count = 1;
1489         uinfo->value.integer.min = MIDI_OP_MODE_UNSET;
1490         uinfo->value.integer.max = MIDI_OP_MODE_MIDI2;
1491         return 0;
1492 }
1493
1494 static int f_midi2_operation_mode_get(struct snd_kcontrol *kcontrol,
1495                                       struct snd_ctl_elem_value *ucontrol)
1496 {
1497         struct f_midi2 *midi2 = snd_kcontrol_chip(kcontrol);
1498
1499         ucontrol->value.integer.value[0] = midi2->operation_mode;
1500         return 0;
1501 }
1502
1503 static const struct snd_kcontrol_new operation_mode_ctl = {
1504         .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI,
1505         .name = "Operation Mode",
1506         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1507         .info = f_midi2_operation_mode_info,
1508         .get = f_midi2_operation_mode_get,
1509 };
1510
1511 /*
1512  * ALSA UMP instance creation / deletion
1513  */
1514 static void f_midi2_free_card(struct f_midi2 *midi2)
1515 {
1516         if (midi2->card) {
1517                 snd_card_free_when_closed(midi2->card);
1518                 midi2->card = NULL;
1519         }
1520 }
1521
1522 /* use a reverse direction for the gadget host */
1523 static int reverse_dir(int dir)
1524 {
1525         if (!dir || dir == SNDRV_UMP_DIR_BIDIRECTION)
1526                 return dir;
1527         return (dir == SNDRV_UMP_DIR_OUTPUT) ?
1528                 SNDRV_UMP_DIR_INPUT : SNDRV_UMP_DIR_OUTPUT;
1529 }
1530
1531 static int f_midi2_create_card(struct f_midi2 *midi2)
1532 {
1533         struct snd_card *card;
1534         struct snd_ump_endpoint *ump;
1535         struct f_midi2_ep *ep;
1536         int i, id, blk, err;
1537         __be32 sw;
1538
1539         err = snd_card_new(&midi2->gadget->dev, -1, NULL, THIS_MODULE, 0,
1540                            &card);
1541         if (err < 0)
1542                 return err;
1543         midi2->card = card;
1544
1545         strcpy(card->driver, "f_midi2");
1546         strcpy(card->shortname, "MIDI 2.0 Gadget");
1547         strcpy(card->longname, "MIDI 2.0 Gadget");
1548
1549         id = 0;
1550         for (i = 0; i < midi2->num_eps; i++) {
1551                 ep = &midi2->midi2_eps[i];
1552                 err = snd_ump_endpoint_new(card, "MIDI 2.0 Gadget", id,
1553                                            1, 1, &ump);
1554                 if (err < 0)
1555                         goto error;
1556                 id++;
1557
1558                 ep->ump = ump;
1559                 ump->no_process_stream = true;
1560                 ump->private_data = ep;
1561                 ump->ops = &f_midi2_ump_ops;
1562                 if (midi2->info.static_block)
1563                         ump->info.flags |= SNDRV_UMP_EP_INFO_STATIC_BLOCKS;
1564                 ump->info.protocol_caps = (ep->info.protocol_caps & 3) << 8;
1565                 ump->info.protocol = to_ump_protocol(ep->info.protocol);
1566                 ump->info.version = 0x0101;
1567                 ump->info.family_id = ep->info.family;
1568                 ump->info.model_id = ep->info.model;
1569                 ump->info.manufacturer_id = ep->info.manufacturer & 0xffffff;
1570                 sw = cpu_to_be32(ep->info.sw_revision);
1571                 memcpy(ump->info.sw_revision, &sw, 4);
1572
1573                 strscpy(ump->info.name, ump_ep_name(ep),
1574                         sizeof(ump->info.name));
1575                 strscpy(ump->info.product_id, ump_product_id(ep),
1576                         sizeof(ump->info.product_id));
1577                 strscpy(ump->core.name, ump->info.name, sizeof(ump->core.name));
1578
1579                 for (blk = 0; blk < ep->num_blks; blk++) {
1580                         const struct f_midi2_block_info *b = &ep->blks[blk].info;
1581                         struct snd_ump_block *fb;
1582
1583                         err = snd_ump_block_new(ump, blk,
1584                                                 reverse_dir(b->direction),
1585                                                 b->first_group, b->num_groups,
1586                                                 &ep->blks[blk].fb);
1587                         if (err < 0)
1588                                 goto error;
1589                         fb = ep->blks[blk].fb;
1590                         fb->info.active = !!b->active;
1591                         fb->info.midi_ci_version = b->midi_ci_version;
1592                         fb->info.ui_hint = reverse_dir(b->ui_hint);
1593                         fb->info.sysex8_streams = b->sysex8_streams;
1594                         if (b->is_midi1 < 2)
1595                                 fb->info.flags |= b->is_midi1;
1596                         else
1597                                 fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1 |
1598                                         SNDRV_UMP_BLOCK_IS_LOWSPEED;
1599                         strscpy(fb->info.name, ump_fb_name(b),
1600                                 sizeof(fb->info.name));
1601                 }
1602         }
1603
1604         for (i = 0; i < midi2->num_eps; i++) {
1605                 err = snd_ump_attach_legacy_rawmidi(midi2->midi2_eps[i].ump,
1606                                                     "Legacy MIDI", id);
1607                 if (err < 0)
1608                         goto error;
1609                 id++;
1610         }
1611
1612         err = snd_ctl_add(card, snd_ctl_new1(&operation_mode_ctl, midi2));
1613         if (err < 0)
1614                 goto error;
1615
1616         err = snd_card_register(card);
1617         if (err < 0)
1618                 goto error;
1619
1620         return 0;
1621
1622  error:
1623         f_midi2_free_card(midi2);
1624         return err;
1625 }
1626
1627 /*
1628  * Creation of USB descriptors
1629  */
1630 struct f_midi2_usb_config {
1631         struct usb_descriptor_header **list;
1632         unsigned int size;
1633         unsigned int alloc;
1634
1635         /* MIDI 1.0 jacks */
1636         unsigned char jack_in, jack_out, jack_id;
1637         struct usb_midi_in_jack_descriptor jack_ins[MAX_CABLES];
1638         struct usb_midi_out_jack_descriptor_1 jack_outs[MAX_CABLES];
1639 };
1640
1641 static int append_config(struct f_midi2_usb_config *config, void *d)
1642 {
1643         unsigned int size;
1644         void *buf;
1645
1646         if (config->size + 2 >= config->alloc) {
1647                 size = config->size + 16;
1648                 buf = krealloc(config->list, size * sizeof(void *), GFP_KERNEL);
1649                 if (!buf)
1650                         return -ENOMEM;
1651                 config->list = buf;
1652                 config->alloc = size;
1653         }
1654
1655         config->list[config->size] = d;
1656         config->size++;
1657         config->list[config->size] = NULL;
1658         return 0;
1659 }
1660
1661 static int append_configs(struct f_midi2_usb_config *config, void **d)
1662 {
1663         int err;
1664
1665         for (; *d; d++) {
1666                 err = append_config(config, *d);
1667                 if (err)
1668                         return err;
1669         }
1670         return 0;
1671 }
1672
1673 static int append_midi1_in_jack(struct f_midi2 *midi2,
1674                                 struct f_midi2_usb_config *config,
1675                                 struct midi1_cable_mapping *map,
1676                                 unsigned int type)
1677 {
1678         struct usb_midi_in_jack_descriptor *jack =
1679                 &config->jack_ins[config->jack_in++];
1680         int id = ++config->jack_id;
1681         int err;
1682
1683         jack->bLength = 0x06;
1684         jack->bDescriptorType = USB_DT_CS_INTERFACE;
1685         jack->bDescriptorSubtype = USB_MS_MIDI_IN_JACK;
1686         jack->bJackType = type;
1687         jack->bJackID = id;
1688         /* use the corresponding block name as jack name */
1689         if (map->ep)
1690                 jack->iJack = map->ep->blks[map->block].string_id;
1691
1692         err = append_config(config, jack);
1693         if (err < 0)
1694                 return err;
1695         return id;
1696 }
1697
1698 static int append_midi1_out_jack(struct f_midi2 *midi2,
1699                                  struct f_midi2_usb_config *config,
1700                                  struct midi1_cable_mapping *map,
1701                                  unsigned int type, unsigned int source)
1702 {
1703         struct usb_midi_out_jack_descriptor_1 *jack =
1704                 &config->jack_outs[config->jack_out++];
1705         int id = ++config->jack_id;
1706         int err;
1707
1708         jack->bLength = 0x09;
1709         jack->bDescriptorType = USB_DT_CS_INTERFACE;
1710         jack->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK;
1711         jack->bJackType = type;
1712         jack->bJackID = id;
1713         jack->bNrInputPins = 1;
1714         jack->pins[0].baSourceID = source;
1715         jack->pins[0].baSourcePin = 0x01;
1716         /* use the corresponding block name as jack name */
1717         if (map->ep)
1718                 jack->iJack = map->ep->blks[map->block].string_id;
1719
1720         err = append_config(config, jack);
1721         if (err < 0)
1722                 return err;
1723         return id;
1724 }
1725
1726 static int f_midi2_create_usb_configs(struct f_midi2 *midi2,
1727                                       struct f_midi2_usb_config *config,
1728                                       int speed)
1729 {
1730         void **midi1_in_eps, **midi1_out_eps;
1731         int i, jack, total;
1732         int err;
1733
1734         switch (speed) {
1735         default:
1736         case USB_SPEED_HIGH:
1737                 midi2_midi1_ep_out_desc.wMaxPacketSize = cpu_to_le16(512);
1738                 midi2_midi1_ep_in_desc.wMaxPacketSize = cpu_to_le16(512);
1739                 for (i = 0; i < midi2->num_eps; i++)
1740                         midi2_midi2_ep_out_desc[i].wMaxPacketSize =
1741                                 cpu_to_le16(512);
1742                 fallthrough;
1743         case USB_SPEED_FULL:
1744                 midi1_in_eps = midi2_midi1_ep_in_descs;
1745                 midi1_out_eps = midi2_midi1_ep_out_descs;
1746                 break;
1747         case USB_SPEED_SUPER:
1748                 midi2_midi1_ep_out_desc.wMaxPacketSize = cpu_to_le16(1024);
1749                 midi2_midi1_ep_in_desc.wMaxPacketSize = cpu_to_le16(1024);
1750                 for (i = 0; i < midi2->num_eps; i++)
1751                         midi2_midi2_ep_out_desc[i].wMaxPacketSize =
1752                                 cpu_to_le16(1024);
1753                 midi1_in_eps = midi2_midi1_ep_in_ss_descs;
1754                 midi1_out_eps = midi2_midi1_ep_out_ss_descs;
1755                 break;
1756         }
1757
1758         err = append_configs(config, midi2_audio_descs);
1759         if (err < 0)
1760                 return err;
1761
1762         if (midi2->num_midi1_in && midi2->num_midi1_out)
1763                 midi2_midi1_if_desc.bNumEndpoints = 2;
1764         else
1765                 midi2_midi1_if_desc.bNumEndpoints = 1;
1766
1767         err = append_configs(config, midi2_midi1_descs);
1768         if (err < 0)
1769                 return err;
1770
1771         total = USB_DT_MS_HEADER_SIZE;
1772         if (midi2->num_midi1_out) {
1773                 midi2_midi1_ep_out_class_desc.bLength =
1774                         USB_DT_MS_ENDPOINT_SIZE(midi2->num_midi1_out);
1775                 total += midi2_midi1_ep_out_class_desc.bLength;
1776                 midi2_midi1_ep_out_class_desc.bNumEmbMIDIJack =
1777                         midi2->num_midi1_out;
1778                 total += midi2->num_midi1_out *
1779                         (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
1780                 for (i = 0; i < midi2->num_midi1_out; i++) {
1781                         jack = append_midi1_in_jack(midi2, config,
1782                                                     &midi2->in_cable_mapping[i],
1783                                                     USB_MS_EMBEDDED);
1784                         if (jack < 0)
1785                                 return jack;
1786                         midi2_midi1_ep_out_class_desc.baAssocJackID[i] = jack;
1787                         jack = append_midi1_out_jack(midi2, config,
1788                                                      &midi2->in_cable_mapping[i],
1789                                                      USB_MS_EXTERNAL, jack);
1790                         if (jack < 0)
1791                                 return jack;
1792                 }
1793         }
1794
1795         if (midi2->num_midi1_in) {
1796                 midi2_midi1_ep_in_class_desc.bLength =
1797                         USB_DT_MS_ENDPOINT_SIZE(midi2->num_midi1_in);
1798                 total += midi2_midi1_ep_in_class_desc.bLength;
1799                 midi2_midi1_ep_in_class_desc.bNumEmbMIDIJack =
1800                         midi2->num_midi1_in;
1801                 total += midi2->num_midi1_in *
1802                         (USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
1803                 for (i = 0; i < midi2->num_midi1_in; i++) {
1804                         jack = append_midi1_in_jack(midi2, config,
1805                                                     &midi2->out_cable_mapping[i],
1806                                                     USB_MS_EXTERNAL);
1807                         if (jack < 0)
1808                                 return jack;
1809                         jack = append_midi1_out_jack(midi2, config,
1810                                                      &midi2->out_cable_mapping[i],
1811                                                      USB_MS_EMBEDDED, jack);
1812                         if (jack < 0)
1813                                 return jack;
1814                         midi2_midi1_ep_in_class_desc.baAssocJackID[i] = jack;
1815                 }
1816         }
1817
1818         midi2_midi1_class_desc.wTotalLength = cpu_to_le16(total);
1819
1820         if (midi2->num_midi1_out) {
1821                 err = append_configs(config, midi1_out_eps);
1822                 if (err < 0)
1823                         return err;
1824         }
1825         if (midi2->num_midi1_in) {
1826                 err = append_configs(config, midi1_in_eps);
1827                 if (err < 0)
1828                         return err;
1829         }
1830
1831         err = append_configs(config, midi2_midi2_descs);
1832         if (err < 0)
1833                 return err;
1834
1835         for (i = 0; i < midi2->num_eps; i++) {
1836                 err = append_config(config, &midi2_midi2_ep_out_desc[i]);
1837                 if (err < 0)
1838                         return err;
1839                 if (speed == USB_SPEED_SUPER || speed == USB_SPEED_SUPER_PLUS) {
1840                         err = append_config(config, &midi2_midi2_ep_out_ss_comp_desc);
1841                         if (err < 0)
1842                                 return err;
1843                 }
1844                 err = append_config(config, &midi2_midi2_ep_out_class_desc[i]);
1845                 if (err < 0)
1846                         return err;
1847                 err = append_config(config, &midi2_midi2_ep_in_desc[i]);
1848                 if (err < 0)
1849                         return err;
1850                 if (speed == USB_SPEED_SUPER || speed == USB_SPEED_SUPER_PLUS) {
1851                         err = append_config(config, &midi2_midi2_ep_in_ss_comp_desc);
1852                         if (err < 0)
1853                                 return err;
1854                 }
1855                 err = append_config(config, &midi2_midi2_ep_in_class_desc[i]);
1856                 if (err < 0)
1857                         return err;
1858         }
1859
1860         return 0;
1861 }
1862
1863 static void f_midi2_free_usb_configs(struct f_midi2_usb_config *config)
1864 {
1865         kfree(config->list);
1866         memset(config, 0, sizeof(*config));
1867 }
1868
1869 /* as we use the static descriptors for simplicity, serialize bind call */
1870 static DEFINE_MUTEX(f_midi2_desc_mutex);
1871
1872 /* fill MIDI2 EP class-specific descriptor */
1873 static void fill_midi2_class_desc(struct f_midi2_ep *ep,
1874                                   struct usb_ms20_endpoint_descriptor_32 *cdesc)
1875 {
1876         int blk;
1877
1878         cdesc->bLength = USB_DT_MS20_ENDPOINT_SIZE(ep->num_blks);
1879         cdesc->bDescriptorType = USB_DT_CS_ENDPOINT;
1880         cdesc->bDescriptorSubtype = USB_MS_GENERAL_2_0;
1881         cdesc->bNumGrpTrmBlock = ep->num_blks;
1882         for (blk = 0; blk < ep->num_blks; blk++)
1883                 cdesc->baAssoGrpTrmBlkID[blk] = ep->blks[blk].gtb_id;
1884 }
1885
1886 /* initialize MIDI2 EP-in */
1887 static int f_midi2_init_midi2_ep_in(struct f_midi2 *midi2, int index)
1888 {
1889         struct f_midi2_ep *ep = &midi2->midi2_eps[index];
1890         struct usb_endpoint_descriptor *desc = &midi2_midi2_ep_in_desc[index];
1891
1892         desc->bLength = USB_DT_ENDPOINT_SIZE;
1893         desc->bDescriptorType = USB_DT_ENDPOINT;
1894         desc->bEndpointAddress = USB_DIR_IN;
1895         desc->bmAttributes = USB_ENDPOINT_XFER_INT;
1896         desc->wMaxPacketSize = cpu_to_le16(EP_MAX_PACKET_INT);
1897         desc->bInterval = 1;
1898
1899         fill_midi2_class_desc(ep, &midi2_midi2_ep_in_class_desc[index]);
1900
1901         return f_midi2_init_ep(midi2, ep, &ep->ep_in, desc,
1902                                f_midi2_ep_in_complete);
1903 }
1904
1905 /* initialize MIDI2 EP-out */
1906 static int f_midi2_init_midi2_ep_out(struct f_midi2 *midi2, int index)
1907 {
1908         struct f_midi2_ep *ep = &midi2->midi2_eps[index];
1909         struct usb_endpoint_descriptor *desc = &midi2_midi2_ep_out_desc[index];
1910
1911         desc->bLength = USB_DT_ENDPOINT_SIZE;
1912         desc->bDescriptorType = USB_DT_ENDPOINT;
1913         desc->bEndpointAddress = USB_DIR_OUT;
1914         desc->bmAttributes = USB_ENDPOINT_XFER_BULK;
1915
1916         fill_midi2_class_desc(ep, &midi2_midi2_ep_out_class_desc[index]);
1917
1918         return f_midi2_init_ep(midi2, ep, &ep->ep_out, desc,
1919                                f_midi2_ep_out_complete);
1920 }
1921
1922 /* gadget function bind callback */
1923 static int f_midi2_bind(struct usb_configuration *c, struct usb_function *f)
1924 {
1925         struct usb_composite_dev *cdev = c->cdev;
1926         struct f_midi2 *midi2 = func_to_midi2(f);
1927         struct f_midi2_ep *ep;
1928         struct f_midi2_usb_config config = {};
1929         struct usb_gadget_strings string_fn = {
1930                 .language = 0x0409,     /* en-us */
1931                 .strings = midi2->string_defs,
1932         };
1933         struct usb_gadget_strings *strings[] = {
1934                 &string_fn,
1935                 NULL,
1936         };
1937         int i, blk, status;
1938
1939         midi2->gadget = cdev->gadget;
1940         midi2->operation_mode = MIDI_OP_MODE_UNSET;
1941
1942         status = f_midi2_create_card(midi2);
1943         if (status < 0)
1944                 goto fail_register;
1945
1946         /* maybe allocate device-global string ID */
1947         midi2->strings = usb_gstrings_attach(c->cdev, strings,
1948                                              midi2->total_blocks + 1);
1949         if (IS_ERR(midi2->strings)) {
1950                 status = PTR_ERR(midi2->strings);
1951                 goto fail_string;
1952         }
1953
1954         mutex_lock(&f_midi2_desc_mutex);
1955         midi2_midi1_if_desc.iInterface = midi2->strings[STR_IFACE].id;
1956         midi2_midi2_if_desc.iInterface = midi2->strings[STR_IFACE].id;
1957         for (i = 0; i < midi2->num_eps; i++) {
1958                 ep = &midi2->midi2_eps[i];
1959                 for (blk = 0; blk < ep->num_blks; blk++)
1960                         ep->blks[blk].string_id =
1961                                 midi2->strings[gtb_to_str_id(ep->blks[blk].gtb_id)].id;
1962         }
1963
1964         midi2_midi2_if_desc.bNumEndpoints = midi2->num_eps * 2;
1965
1966         /* audio interface */
1967         status = usb_interface_id(c, f);
1968         if (status < 0)
1969                 goto fail;
1970         midi2_audio_if_desc.bInterfaceNumber = status;
1971
1972         /* MIDI streaming */
1973         status = usb_interface_id(c, f);
1974         if (status < 0)
1975                 goto fail;
1976         midi2->midi_if = status;
1977         midi2_midi1_if_desc.bInterfaceNumber = status;
1978         midi2_midi2_if_desc.bInterfaceNumber = status;
1979         midi2_audio_class_desc.baInterfaceNr[0] = status;
1980
1981         /* allocate instance-specific endpoints */
1982         if (midi2->midi2_eps[0].blks[0].info.direction != SNDRV_UMP_DIR_OUTPUT) {
1983                 status = f_midi2_init_ep(midi2, NULL, &midi2->midi1_ep_in,
1984                                          &midi2_midi1_ep_in_desc,
1985                                          f_midi2_midi1_ep_in_complete);
1986                 if (status)
1987                         goto fail;
1988         }
1989
1990         if (midi2->midi2_eps[0].blks[0].info.direction != SNDRV_UMP_DIR_INPUT) {
1991                 status = f_midi2_init_ep(midi2, NULL, &midi2->midi1_ep_out,
1992                                          &midi2_midi1_ep_out_desc,
1993                                          f_midi2_midi1_ep_out_complete);
1994                 if (status)
1995                         goto fail;
1996         }
1997
1998         for (i = 0; i < midi2->num_eps; i++) {
1999                 status = f_midi2_init_midi2_ep_in(midi2, i);
2000                 if (status)
2001                         goto fail;
2002                 status = f_midi2_init_midi2_ep_out(midi2, i);
2003                 if (status)
2004                         goto fail;
2005         }
2006
2007         status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_FULL);
2008         if (status < 0)
2009                 goto fail;
2010         f->fs_descriptors = usb_copy_descriptors(config.list);
2011         if (!f->fs_descriptors) {
2012                 status = -ENOMEM;
2013                 goto fail;
2014         }
2015         f_midi2_free_usb_configs(&config);
2016
2017         status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_HIGH);
2018         if (status < 0)
2019                 goto fail;
2020         f->hs_descriptors = usb_copy_descriptors(config.list);
2021         if (!f->hs_descriptors) {
2022                 status = -ENOMEM;
2023                 goto fail;
2024         }
2025         f_midi2_free_usb_configs(&config);
2026
2027         status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_SUPER);
2028         if (status < 0)
2029                 goto fail;
2030         f->ss_descriptors = usb_copy_descriptors(config.list);
2031         if (!f->ss_descriptors) {
2032                 status = -ENOMEM;
2033                 goto fail;
2034         }
2035         f_midi2_free_usb_configs(&config);
2036
2037         mutex_unlock(&f_midi2_desc_mutex);
2038         return 0;
2039
2040 fail:
2041         f_midi2_free_usb_configs(&config);
2042         mutex_unlock(&f_midi2_desc_mutex);
2043         usb_free_all_descriptors(f);
2044 fail_string:
2045         f_midi2_free_card(midi2);
2046 fail_register:
2047         ERROR(midi2, "%s: can't bind, err %d\n", f->name, status);
2048         return status;
2049 }
2050
2051 /* gadget function unbind callback */
2052 static void f_midi2_unbind(struct usb_configuration *c, struct usb_function *f)
2053 {
2054         struct f_midi2 *midi2 = func_to_midi2(f);
2055         int i;
2056
2057         f_midi2_free_card(midi2);
2058
2059         f_midi2_free_ep(&midi2->midi1_ep_in);
2060         f_midi2_free_ep(&midi2->midi1_ep_out);
2061         for (i = 0; i < midi2->num_eps; i++) {
2062                 f_midi2_free_ep(&midi2->midi2_eps[i].ep_in);
2063                 f_midi2_free_ep(&midi2->midi2_eps[i].ep_out);
2064         }
2065
2066         usb_free_all_descriptors(f);
2067 }
2068
2069 /*
2070  * ConfigFS interface
2071  */
2072
2073 /* type conversion helpers */
2074 static inline struct f_midi2_opts *to_f_midi2_opts(struct config_item *item)
2075 {
2076         return container_of(to_config_group(item), struct f_midi2_opts,
2077                             func_inst.group);
2078 }
2079
2080 static inline struct f_midi2_ep_opts *
2081 to_f_midi2_ep_opts(struct config_item *item)
2082 {
2083         return container_of(to_config_group(item), struct f_midi2_ep_opts,
2084                             group);
2085 }
2086
2087 static inline struct f_midi2_block_opts *
2088 to_f_midi2_block_opts(struct config_item *item)
2089 {
2090         return container_of(to_config_group(item), struct f_midi2_block_opts,
2091                             group);
2092 }
2093
2094 /* trim the string to be usable for EP and FB name strings */
2095 static void make_name_string(char *s)
2096 {
2097         char *p;
2098
2099         p = strchr(s, '\n');
2100         if (p)
2101                 *p = 0;
2102
2103         p = s + strlen(s);
2104         for (; p > s && isspace(*p); p--)
2105                 *p = 0;
2106 }
2107
2108 /* configfs helpers: generic show/store for unisnged int */
2109 static ssize_t f_midi2_opts_uint_show(struct f_midi2_opts *opts,
2110                                       u32 val, const char *format, char *page)
2111 {
2112         int result;
2113
2114         mutex_lock(&opts->lock);
2115         result = sprintf(page, format, val);
2116         mutex_unlock(&opts->lock);
2117         return result;
2118 }
2119
2120 static ssize_t f_midi2_opts_uint_store(struct f_midi2_opts *opts,
2121                                        u32 *valp, u32 minval, u32 maxval,
2122                                        const char *page, size_t len)
2123 {
2124         int ret;
2125         u32 val;
2126
2127         mutex_lock(&opts->lock);
2128         if (opts->refcnt) {
2129                 ret = -EBUSY;
2130                 goto end;
2131         }
2132
2133         ret = kstrtou32(page, 0, &val);
2134         if (ret)
2135                 goto end;
2136         if (val < minval || val > maxval) {
2137                 ret = -EINVAL;
2138                 goto end;
2139         }
2140
2141         *valp = val;
2142         ret = len;
2143
2144 end:
2145         mutex_unlock(&opts->lock);
2146         return ret;
2147 }
2148
2149 /* generic store for bool */
2150 static ssize_t f_midi2_opts_bool_store(struct f_midi2_opts *opts,
2151                                        bool *valp, const char *page, size_t len)
2152 {
2153         int ret;
2154         bool val;
2155
2156         mutex_lock(&opts->lock);
2157         if (opts->refcnt) {
2158                 ret = -EBUSY;
2159                 goto end;
2160         }
2161
2162         ret = kstrtobool(page, &val);
2163         if (ret)
2164                 goto end;
2165         *valp = val;
2166         ret = len;
2167
2168 end:
2169         mutex_unlock(&opts->lock);
2170         return ret;
2171 }
2172
2173 /* generic show/store for string */
2174 static ssize_t f_midi2_opts_str_show(struct f_midi2_opts *opts,
2175                                      const char *str, char *page)
2176 {
2177         int result = 0;
2178
2179         mutex_lock(&opts->lock);
2180         if (str)
2181                 result = scnprintf(page, PAGE_SIZE, "%s\n", str);
2182         mutex_unlock(&opts->lock);
2183         return result;
2184 }
2185
2186 static ssize_t f_midi2_opts_str_store(struct f_midi2_opts *opts,
2187                                       const char **strp, size_t maxlen,
2188                                       const char *page, size_t len)
2189 {
2190         char *c;
2191         int ret;
2192
2193         mutex_lock(&opts->lock);
2194         if (opts->refcnt) {
2195                 ret = -EBUSY;
2196                 goto end;
2197         }
2198
2199         c = kstrndup(page, min(len, maxlen), GFP_KERNEL);
2200         if (!c) {
2201                 ret = -ENOMEM;
2202                 goto end;
2203         }
2204
2205         kfree(*strp);
2206         make_name_string(c);
2207         *strp = c;
2208         ret = len;
2209
2210 end:
2211         mutex_unlock(&opts->lock);
2212         return ret;
2213 }
2214
2215 /*
2216  * Definitions for UMP Block config
2217  */
2218
2219 /* define an uint option for block */
2220 #define F_MIDI2_BLOCK_OPT(name, format, minval, maxval)                 \
2221 static ssize_t f_midi2_block_opts_##name##_show(struct config_item *item,\
2222                                           char *page)                   \
2223 {                                                                       \
2224         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);  \
2225         return f_midi2_opts_uint_show(opts->ep->opts, opts->info.name,  \
2226                                       format "\n", page);               \
2227 }                                                                       \
2228                                                                         \
2229 static ssize_t f_midi2_block_opts_##name##_store(struct config_item *item,\
2230                                          const char *page, size_t len)  \
2231 {                                                                       \
2232         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);  \
2233         return f_midi2_opts_uint_store(opts->ep->opts, &opts->info.name,\
2234                                        minval, maxval, page, len);      \
2235 }                                                                       \
2236                                                                         \
2237 CONFIGFS_ATTR(f_midi2_block_opts_, name)
2238
2239 /* define a boolean option for block */
2240 #define F_MIDI2_BLOCK_BOOL_OPT(name)                                    \
2241 static ssize_t f_midi2_block_opts_##name##_show(struct config_item *item,\
2242                                           char *page)                   \
2243 {                                                                       \
2244         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);  \
2245         return f_midi2_opts_uint_show(opts->ep->opts, opts->info.name,  \
2246                                       "%u\n", page);                    \
2247 }                                                                       \
2248                                                                         \
2249 static ssize_t f_midi2_block_opts_##name##_store(struct config_item *item,\
2250                                          const char *page, size_t len)  \
2251 {                                                                       \
2252         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);  \
2253         return f_midi2_opts_bool_store(opts->ep->opts, &opts->info.name,\
2254                                        page, len);                      \
2255 }                                                                       \
2256                                                                         \
2257 CONFIGFS_ATTR(f_midi2_block_opts_, name)
2258
2259 F_MIDI2_BLOCK_OPT(direction, "0x%x", 1, 3);
2260 F_MIDI2_BLOCK_OPT(first_group, "0x%x", 0, 15);
2261 F_MIDI2_BLOCK_OPT(num_groups, "0x%x", 1, 16);
2262 F_MIDI2_BLOCK_OPT(midi1_first_group, "0x%x", 0, 15);
2263 F_MIDI2_BLOCK_OPT(midi1_num_groups, "0x%x", 0, 16);
2264 F_MIDI2_BLOCK_OPT(ui_hint, "0x%x", 0, 3);
2265 F_MIDI2_BLOCK_OPT(midi_ci_version, "%u", 0, 1);
2266 F_MIDI2_BLOCK_OPT(sysex8_streams, "%u", 0, 255);
2267 F_MIDI2_BLOCK_OPT(is_midi1, "%u", 0, 2);
2268 F_MIDI2_BLOCK_BOOL_OPT(active);
2269
2270 static ssize_t f_midi2_block_opts_name_show(struct config_item *item,
2271                                             char *page)
2272 {
2273         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2274
2275         return f_midi2_opts_str_show(opts->ep->opts, opts->info.name, page);
2276 }
2277
2278 static ssize_t f_midi2_block_opts_name_store(struct config_item *item,
2279                                              const char *page, size_t len)
2280 {
2281         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2282
2283         return f_midi2_opts_str_store(opts->ep->opts, &opts->info.name, 128,
2284                                       page, len);
2285 }
2286
2287 CONFIGFS_ATTR(f_midi2_block_opts_, name);
2288
2289 static struct configfs_attribute *f_midi2_block_attrs[] = {
2290         &f_midi2_block_opts_attr_direction,
2291         &f_midi2_block_opts_attr_first_group,
2292         &f_midi2_block_opts_attr_num_groups,
2293         &f_midi2_block_opts_attr_midi1_first_group,
2294         &f_midi2_block_opts_attr_midi1_num_groups,
2295         &f_midi2_block_opts_attr_ui_hint,
2296         &f_midi2_block_opts_attr_midi_ci_version,
2297         &f_midi2_block_opts_attr_sysex8_streams,
2298         &f_midi2_block_opts_attr_is_midi1,
2299         &f_midi2_block_opts_attr_active,
2300         &f_midi2_block_opts_attr_name,
2301         NULL,
2302 };
2303
2304 static void f_midi2_block_opts_release(struct config_item *item)
2305 {
2306         struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2307
2308         kfree(opts->info.name);
2309         kfree(opts);
2310 }
2311
2312 static struct configfs_item_operations f_midi2_block_item_ops = {
2313         .release        = f_midi2_block_opts_release,
2314 };
2315
2316 static const struct config_item_type f_midi2_block_type = {
2317         .ct_item_ops    = &f_midi2_block_item_ops,
2318         .ct_attrs       = f_midi2_block_attrs,
2319         .ct_owner       = THIS_MODULE,
2320 };
2321
2322 /* create a f_midi2_block_opts instance for the given block number */
2323 static int f_midi2_block_opts_create(struct f_midi2_ep_opts *ep_opts,
2324                                      unsigned int blk,
2325                                      struct f_midi2_block_opts **block_p)
2326 {
2327         struct f_midi2_block_opts *block_opts;
2328         int ret = 0;
2329
2330         mutex_lock(&ep_opts->opts->lock);
2331         if (ep_opts->opts->refcnt || ep_opts->blks[blk]) {
2332                 ret = -EBUSY;
2333                 goto out;
2334         }
2335
2336         block_opts = kzalloc(sizeof(*block_opts), GFP_KERNEL);
2337         if (!block_opts) {
2338                 ret = -ENOMEM;
2339                 goto out;
2340         }
2341
2342         block_opts->ep = ep_opts;
2343         block_opts->id = blk;
2344
2345         /* set up the default values */
2346         block_opts->info.direction = SNDRV_UMP_DIR_BIDIRECTION;
2347         block_opts->info.first_group = 0;
2348         block_opts->info.num_groups = 1;
2349         block_opts->info.ui_hint = SNDRV_UMP_BLOCK_UI_HINT_BOTH;
2350         block_opts->info.active = 1;
2351
2352         ep_opts->blks[blk] = block_opts;
2353         *block_p = block_opts;
2354
2355  out:
2356         mutex_unlock(&ep_opts->opts->lock);
2357         return ret;
2358 }
2359
2360 /* make_group callback for a block */
2361 static struct config_group *
2362 f_midi2_opts_block_make(struct config_group *group, const char *name)
2363 {
2364         struct f_midi2_ep_opts *ep_opts;
2365         struct f_midi2_block_opts *block_opts;
2366         unsigned int blk;
2367         int ret;
2368
2369         if (strncmp(name, "block.", 6))
2370                 return ERR_PTR(-EINVAL);
2371         ret = kstrtouint(name + 6, 10, &blk);
2372         if (ret)
2373                 return ERR_PTR(ret);
2374
2375         ep_opts = to_f_midi2_ep_opts(&group->cg_item);
2376
2377         if (blk >= SNDRV_UMP_MAX_BLOCKS)
2378                 return ERR_PTR(-EINVAL);
2379         if (ep_opts->blks[blk])
2380                 return ERR_PTR(-EBUSY);
2381         ret = f_midi2_block_opts_create(ep_opts, blk, &block_opts);
2382         if (ret)
2383                 return ERR_PTR(ret);
2384
2385         config_group_init_type_name(&block_opts->group, name,
2386                                     &f_midi2_block_type);
2387         return &block_opts->group;
2388 }
2389
2390 /* drop_item callback for a block */
2391 static void
2392 f_midi2_opts_block_drop(struct config_group *group, struct config_item *item)
2393 {
2394         struct f_midi2_block_opts *block_opts = to_f_midi2_block_opts(item);
2395
2396         mutex_lock(&block_opts->ep->opts->lock);
2397         block_opts->ep->blks[block_opts->id] = NULL;
2398         mutex_unlock(&block_opts->ep->opts->lock);
2399         config_item_put(item);
2400 }
2401
2402 /*
2403  * Definitions for UMP Endpoint config
2404  */
2405
2406 /* define an uint option for EP */
2407 #define F_MIDI2_EP_OPT(name, format, minval, maxval)                    \
2408 static ssize_t f_midi2_ep_opts_##name##_show(struct config_item *item,  \
2409                                              char *page)                \
2410 {                                                                       \
2411         struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);        \
2412         return f_midi2_opts_uint_show(opts->opts, opts->info.name,      \
2413                                       format "\n", page);               \
2414 }                                                                       \
2415                                                                         \
2416 static ssize_t f_midi2_ep_opts_##name##_store(struct config_item *item, \
2417                                            const char *page, size_t len)\
2418 {                                                                       \
2419         struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);        \
2420         return f_midi2_opts_uint_store(opts->opts, &opts->info.name,    \
2421                                        minval, maxval, page, len);      \
2422 }                                                                       \
2423                                                                         \
2424 CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2425
2426 /* define a string option for EP */
2427 #define F_MIDI2_EP_STR_OPT(name, maxlen)                                \
2428 static ssize_t f_midi2_ep_opts_##name##_show(struct config_item *item,  \
2429                                              char *page)                \
2430 {                                                                       \
2431         struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);        \
2432         return f_midi2_opts_str_show(opts->opts, opts->info.name, page);\
2433 }                                                                       \
2434                                                                         \
2435 static ssize_t f_midi2_ep_opts_##name##_store(struct config_item *item, \
2436                                          const char *page, size_t len)  \
2437 {                                                                       \
2438         struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);        \
2439         return f_midi2_opts_str_store(opts->opts, &opts->info.name, maxlen,\
2440                                       page, len);                       \
2441 }                                                                       \
2442                                                                         \
2443 CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2444
2445 F_MIDI2_EP_OPT(protocol, "0x%x", 1, 2);
2446 F_MIDI2_EP_OPT(protocol_caps, "0x%x", 1, 3);
2447 F_MIDI2_EP_OPT(manufacturer, "0x%x", 0, 0xffffff);
2448 F_MIDI2_EP_OPT(family, "0x%x", 0, 0xffff);
2449 F_MIDI2_EP_OPT(model, "0x%x", 0, 0xffff);
2450 F_MIDI2_EP_OPT(sw_revision, "0x%x", 0, 0xffffffff);
2451 F_MIDI2_EP_STR_OPT(ep_name, 128);
2452 F_MIDI2_EP_STR_OPT(product_id, 128);
2453
2454 static struct configfs_attribute *f_midi2_ep_attrs[] = {
2455         &f_midi2_ep_opts_attr_protocol,
2456         &f_midi2_ep_opts_attr_protocol_caps,
2457         &f_midi2_ep_opts_attr_ep_name,
2458         &f_midi2_ep_opts_attr_product_id,
2459         &f_midi2_ep_opts_attr_manufacturer,
2460         &f_midi2_ep_opts_attr_family,
2461         &f_midi2_ep_opts_attr_model,
2462         &f_midi2_ep_opts_attr_sw_revision,
2463         NULL,
2464 };
2465
2466 static void f_midi2_ep_opts_release(struct config_item *item)
2467 {
2468         struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);
2469
2470         kfree(opts->info.ep_name);
2471         kfree(opts->info.product_id);
2472         kfree(opts);
2473 }
2474
2475 static struct configfs_item_operations f_midi2_ep_item_ops = {
2476         .release        = f_midi2_ep_opts_release,
2477 };
2478
2479 static struct configfs_group_operations f_midi2_ep_group_ops = {
2480         .make_group     = f_midi2_opts_block_make,
2481         .drop_item      = f_midi2_opts_block_drop,
2482 };
2483
2484 static const struct config_item_type f_midi2_ep_type = {
2485         .ct_item_ops    = &f_midi2_ep_item_ops,
2486         .ct_group_ops   = &f_midi2_ep_group_ops,
2487         .ct_attrs       = f_midi2_ep_attrs,
2488         .ct_owner       = THIS_MODULE,
2489 };
2490
2491 /* create a f_midi2_ep_opts instance */
2492 static int f_midi2_ep_opts_create(struct f_midi2_opts *opts,
2493                                   unsigned int index,
2494                                   struct f_midi2_ep_opts **ep_p)
2495 {
2496         struct f_midi2_ep_opts *ep_opts;
2497
2498         ep_opts = kzalloc(sizeof(*ep_opts), GFP_KERNEL);
2499         if (!ep_opts)
2500                 return -ENOMEM;
2501
2502         ep_opts->opts = opts;
2503         ep_opts->index = index;
2504
2505         /* set up the default values */
2506         ep_opts->info.protocol = 2;
2507         ep_opts->info.protocol_caps = 3;
2508
2509         opts->eps[index] = ep_opts;
2510         *ep_p = ep_opts;
2511         return 0;
2512 }
2513
2514 /* make_group callback for an EP */
2515 static struct config_group *
2516 f_midi2_opts_ep_make(struct config_group *group, const char *name)
2517 {
2518         struct f_midi2_opts *opts;
2519         struct f_midi2_ep_opts *ep_opts;
2520         unsigned int index;
2521         int ret;
2522
2523         if (strncmp(name, "ep.", 3))
2524                 return ERR_PTR(-EINVAL);
2525         ret = kstrtouint(name + 3, 10, &index);
2526         if (ret)
2527                 return ERR_PTR(ret);
2528
2529         opts = to_f_midi2_opts(&group->cg_item);
2530         if (index >= MAX_UMP_EPS)
2531                 return ERR_PTR(-EINVAL);
2532         if (opts->eps[index])
2533                 return ERR_PTR(-EBUSY);
2534         ret = f_midi2_ep_opts_create(opts, index, &ep_opts);
2535         if (ret)
2536                 return ERR_PTR(ret);
2537
2538         config_group_init_type_name(&ep_opts->group, name, &f_midi2_ep_type);
2539         return &ep_opts->group;
2540 }
2541
2542 /* drop_item callback for an EP */
2543 static void
2544 f_midi2_opts_ep_drop(struct config_group *group, struct config_item *item)
2545 {
2546         struct f_midi2_ep_opts *ep_opts = to_f_midi2_ep_opts(item);
2547
2548         mutex_lock(&ep_opts->opts->lock);
2549         ep_opts->opts->eps[ep_opts->index] = NULL;
2550         mutex_unlock(&ep_opts->opts->lock);
2551         config_item_put(item);
2552 }
2553
2554 /*
2555  * Definitions for card config
2556  */
2557
2558 /* define a bool option for card */
2559 #define F_MIDI2_BOOL_OPT(name)                                          \
2560 static ssize_t f_midi2_opts_##name##_show(struct config_item *item,     \
2561                                           char *page)                   \
2562 {                                                                       \
2563         struct f_midi2_opts *opts = to_f_midi2_opts(item);              \
2564         return f_midi2_opts_uint_show(opts, opts->info.name,            \
2565                                       "%u\n", page);                    \
2566 }                                                                       \
2567                                                                         \
2568 static ssize_t f_midi2_opts_##name##_store(struct config_item *item,    \
2569                                          const char *page, size_t len)  \
2570 {                                                                       \
2571         struct f_midi2_opts *opts = to_f_midi2_opts(item);              \
2572         return f_midi2_opts_bool_store(opts, &opts->info.name,          \
2573                                        page, len);                      \
2574 }                                                                       \
2575                                                                         \
2576 CONFIGFS_ATTR(f_midi2_opts_, name)
2577
2578 F_MIDI2_BOOL_OPT(process_ump);
2579 F_MIDI2_BOOL_OPT(static_block);
2580
2581 static ssize_t f_midi2_opts_iface_name_show(struct config_item *item,
2582                                             char *page)
2583 {
2584         struct f_midi2_opts *opts = to_f_midi2_opts(item);
2585
2586         return f_midi2_opts_str_show(opts, opts->info.iface_name, page);
2587 }
2588
2589 static ssize_t f_midi2_opts_iface_name_store(struct config_item *item,
2590                                              const char *page, size_t len)
2591 {
2592         struct f_midi2_opts *opts = to_f_midi2_opts(item);
2593
2594         return f_midi2_opts_str_store(opts, &opts->info.iface_name, 128,
2595                                       page, len);
2596 }
2597
2598 CONFIGFS_ATTR(f_midi2_opts_, iface_name);
2599
2600 static struct configfs_attribute *f_midi2_attrs[] = {
2601         &f_midi2_opts_attr_process_ump,
2602         &f_midi2_opts_attr_static_block,
2603         &f_midi2_opts_attr_iface_name,
2604         NULL
2605 };
2606
2607 static void f_midi2_opts_release(struct config_item *item)
2608 {
2609         struct f_midi2_opts *opts = to_f_midi2_opts(item);
2610
2611         usb_put_function_instance(&opts->func_inst);
2612 }
2613
2614 static struct configfs_item_operations f_midi2_item_ops = {
2615         .release        = f_midi2_opts_release,
2616 };
2617
2618 static struct configfs_group_operations f_midi2_group_ops = {
2619         .make_group     = f_midi2_opts_ep_make,
2620         .drop_item      = f_midi2_opts_ep_drop,
2621 };
2622
2623 static const struct config_item_type f_midi2_func_type = {
2624         .ct_item_ops    = &f_midi2_item_ops,
2625         .ct_group_ops   = &f_midi2_group_ops,
2626         .ct_attrs       = f_midi2_attrs,
2627         .ct_owner       = THIS_MODULE,
2628 };
2629
2630 static void f_midi2_free_inst(struct usb_function_instance *f)
2631 {
2632         struct f_midi2_opts *opts;
2633
2634         opts = container_of(f, struct f_midi2_opts, func_inst);
2635
2636         kfree(opts->info.iface_name);
2637         kfree(opts);
2638 }
2639
2640 /* gadget alloc_inst */
2641 static struct usb_function_instance *f_midi2_alloc_inst(void)
2642 {
2643         struct f_midi2_opts *opts;
2644         struct f_midi2_ep_opts *ep_opts;
2645         struct f_midi2_block_opts *block_opts;
2646         int ret;
2647
2648         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
2649         if (!opts)
2650                 return ERR_PTR(-ENOMEM);
2651
2652         mutex_init(&opts->lock);
2653         opts->func_inst.free_func_inst = f_midi2_free_inst;
2654         opts->info.process_ump = true;
2655         opts->info.static_block = true;
2656         opts->info.num_reqs = 32;
2657         opts->info.req_buf_size = 512;
2658
2659         /* create the default ep */
2660         ret = f_midi2_ep_opts_create(opts, 0, &ep_opts);
2661         if (ret) {
2662                 kfree(opts);
2663                 return ERR_PTR(ret);
2664         }
2665
2666         /* create the default block */
2667         ret = f_midi2_block_opts_create(ep_opts, 0, &block_opts);
2668         if (ret) {
2669                 kfree(ep_opts);
2670                 kfree(opts);
2671                 return ERR_PTR(ret);
2672         }
2673
2674         /* set up the default MIDI1 (that is mandatory) */
2675         block_opts->info.midi1_num_groups = 1;
2676
2677         config_group_init_type_name(&opts->func_inst.group, "",
2678                                     &f_midi2_func_type);
2679
2680         config_group_init_type_name(&ep_opts->group, "ep.0",
2681                                     &f_midi2_ep_type);
2682         configfs_add_default_group(&ep_opts->group, &opts->func_inst.group);
2683
2684         config_group_init_type_name(&block_opts->group, "block.0",
2685                                     &f_midi2_block_type);
2686         configfs_add_default_group(&block_opts->group, &ep_opts->group);
2687
2688         return &opts->func_inst;
2689 }
2690
2691 static void do_f_midi2_free(struct f_midi2 *midi2, struct f_midi2_opts *opts)
2692 {
2693         mutex_lock(&opts->lock);
2694         --opts->refcnt;
2695         mutex_unlock(&opts->lock);
2696         kfree(midi2->string_defs);
2697         kfree(midi2);
2698 }
2699
2700 static void f_midi2_free(struct usb_function *f)
2701 {
2702         do_f_midi2_free(func_to_midi2(f),
2703                         container_of(f->fi, struct f_midi2_opts, func_inst));
2704 }
2705
2706 /* verify the parameters set up via configfs;
2707  * return the number of EPs or a negative error
2708  */
2709 static int verify_parameters(struct f_midi2_opts *opts)
2710 {
2711         int i, j, num_eps, num_blks;
2712         struct f_midi2_ep_info *ep;
2713         struct f_midi2_block_info *bp;
2714
2715         for (num_eps = 0; num_eps < MAX_UMP_EPS && opts->eps[num_eps];
2716              num_eps++)
2717                 ;
2718         if (!num_eps) {
2719                 pr_err("f_midi2: No EP is defined\n");
2720                 return -EINVAL;
2721         }
2722
2723         num_blks = 0;
2724         for (i = 0; i < num_eps; i++) {
2725                 ep = &opts->eps[i]->info;
2726                 if (!(ep->protocol_caps & ep->protocol)) {
2727                         pr_err("f_midi2: Invalid protocol 0x%x (caps 0x%x) for EP %d\n",
2728                                ep->protocol, ep->protocol_caps, i);
2729                         return -EINVAL;
2730                 }
2731
2732                 for (j = 0; j < SNDRV_UMP_MAX_BLOCKS && opts->eps[i]->blks[j];
2733                      j++, num_blks++) {
2734                         bp = &opts->eps[i]->blks[j]->info;
2735                         if (bp->first_group + bp->num_groups > SNDRV_UMP_MAX_GROUPS) {
2736                                 pr_err("f_midi2: Invalid group definitions for block %d:%d\n",
2737                                        i, j);
2738                                 return -EINVAL;
2739                         }
2740
2741                         if (bp->midi1_num_groups) {
2742                                 if (bp->midi1_first_group < bp->first_group ||
2743                                     bp->midi1_first_group + bp->midi1_num_groups >
2744                                     bp->first_group + bp->num_groups) {
2745                                         pr_err("f_midi2: Invalid MIDI1 group definitions for block %d:%d\n",
2746                                                i, j);
2747                                         return -EINVAL;
2748                                 }
2749                         }
2750                 }
2751         }
2752         if (!num_blks) {
2753                 pr_err("f_midi2: No block is defined\n");
2754                 return -EINVAL;
2755         }
2756
2757         return num_eps;
2758 }
2759
2760 /* fill mapping between MIDI 1.0 cable and UMP EP/group */
2761 static void fill_midi1_cable_mapping(struct f_midi2 *midi2,
2762                                      struct f_midi2_ep *ep,
2763                                      int blk)
2764 {
2765         const struct f_midi2_block_info *binfo = &ep->blks[blk].info;
2766         struct midi1_cable_mapping *map;
2767         int i, group;
2768
2769         if (!binfo->midi1_num_groups)
2770                 return;
2771         if (binfo->direction != SNDRV_UMP_DIR_OUTPUT) {
2772                 group = binfo->midi1_first_group;
2773                 map = midi2->in_cable_mapping + midi2->num_midi1_in;
2774                 for (i = 0; i < binfo->midi1_num_groups; i++, group++, map++) {
2775                         if (midi2->num_midi1_in >= MAX_CABLES)
2776                                 break;
2777                         map->ep = ep;
2778                         map->block = blk;
2779                         map->group = group;
2780                         midi2->num_midi1_in++;
2781                         /* store 1-based cable number */
2782                         ep->in_group_to_cable[group] = midi2->num_midi1_in;
2783                 }
2784         }
2785
2786         if (binfo->direction != SNDRV_UMP_DIR_INPUT) {
2787                 group = binfo->midi1_first_group;
2788                 map = midi2->out_cable_mapping + midi2->num_midi1_out;
2789                 for (i = 0; i < binfo->midi1_num_groups; i++, group++, map++) {
2790                         if (midi2->num_midi1_out >= MAX_CABLES)
2791                                 break;
2792                         map->ep = ep;
2793                         map->block = blk;
2794                         map->group = group;
2795                         midi2->num_midi1_out++;
2796                 }
2797         }
2798 }
2799
2800 /* gadget alloc callback */
2801 static struct usb_function *f_midi2_alloc(struct usb_function_instance *fi)
2802 {
2803         struct f_midi2 *midi2;
2804         struct f_midi2_opts *opts;
2805         struct f_midi2_ep *ep;
2806         struct f_midi2_block *bp;
2807         int i, num_eps, blk;
2808
2809         midi2 = kzalloc(sizeof(*midi2), GFP_KERNEL);
2810         if (!midi2)
2811                 return ERR_PTR(-ENOMEM);
2812
2813         opts = container_of(fi, struct f_midi2_opts, func_inst);
2814         mutex_lock(&opts->lock);
2815         num_eps = verify_parameters(opts);
2816         if (num_eps < 0) {
2817                 mutex_unlock(&opts->lock);
2818                 kfree(midi2);
2819                 return ERR_PTR(num_eps);
2820         }
2821         ++opts->refcnt;
2822         mutex_unlock(&opts->lock);
2823
2824         spin_lock_init(&midi2->queue_lock);
2825
2826         midi2->func.name = "midi2_func";
2827         midi2->func.bind = f_midi2_bind;
2828         midi2->func.unbind = f_midi2_unbind;
2829         midi2->func.get_alt = f_midi2_get_alt;
2830         midi2->func.set_alt = f_midi2_set_alt;
2831         midi2->func.setup = f_midi2_setup;
2832         midi2->func.disable = f_midi2_disable;
2833         midi2->func.free_func = f_midi2_free;
2834
2835         midi2->info = opts->info;
2836         midi2->num_eps = num_eps;
2837
2838         for (i = 0; i < num_eps; i++) {
2839                 ep = &midi2->midi2_eps[i];
2840                 ep->info = opts->eps[i]->info;
2841                 ep->card = midi2;
2842                 for (blk = 0; blk < SNDRV_UMP_MAX_BLOCKS &&
2843                              opts->eps[i]->blks[blk]; blk++) {
2844                         bp = &ep->blks[blk];
2845                         ep->num_blks++;
2846                         bp->info = opts->eps[i]->blks[blk]->info;
2847                         bp->gtb_id = ++midi2->total_blocks;
2848                 }
2849         }
2850
2851         midi2->string_defs = kcalloc(midi2->total_blocks + 1,
2852                                      sizeof(*midi2->string_defs), GFP_KERNEL);
2853         if (!midi2->string_defs) {
2854                 do_f_midi2_free(midi2, opts);
2855                 return ERR_PTR(-ENOMEM);
2856         }
2857
2858         if (opts->info.iface_name && *opts->info.iface_name)
2859                 midi2->string_defs[STR_IFACE].s = opts->info.iface_name;
2860         else
2861                 midi2->string_defs[STR_IFACE].s = ump_ep_name(&midi2->midi2_eps[0]);
2862
2863         for (i = 0; i < midi2->num_eps; i++) {
2864                 ep = &midi2->midi2_eps[i];
2865                 for (blk = 0; blk < ep->num_blks; blk++) {
2866                         bp = &ep->blks[blk];
2867                         midi2->string_defs[gtb_to_str_id(bp->gtb_id)].s =
2868                                 ump_fb_name(&bp->info);
2869
2870                         fill_midi1_cable_mapping(midi2, ep, blk);
2871                 }
2872         }
2873
2874         if (!midi2->num_midi1_in && !midi2->num_midi1_out) {
2875                 pr_err("f_midi2: MIDI1 definition is missing\n");
2876                 do_f_midi2_free(midi2, opts);
2877                 return ERR_PTR(-EINVAL);
2878         }
2879
2880         return &midi2->func;
2881 }
2882
2883 DECLARE_USB_FUNCTION_INIT(midi2, f_midi2_alloc_inst, f_midi2_alloc);
2884
2885 MODULE_DESCRIPTION("USB MIDI 2.0 class function driver");
2886 MODULE_LICENSE("GPL");