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
  25struct f_midi2;
  26struct f_midi2_ep;
  27struct f_midi2_usb_ep;
  28
  29/* Context for each USB request */
  30struct 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 */
  37struct 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) */
  48struct 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 */
  56struct 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 */
  64enum {
  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 */
  77struct 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 */
  92enum {
  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 */
 101struct midi1_cable_mapping {
 102	struct f_midi2_ep *ep;
 103	unsigned char block;
 104	unsigned char group;
 105};
 106
 107/* operation mode */
 108enum {
 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 */
 115struct 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 */
 157static 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 */
 163static 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 */
 169static 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 */
 178static 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 */
 186static 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
 200DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
 201DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
 202DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
 203DECLARE_USB_MS20_ENDPOINT_DESCRIPTOR(32);
 204
 205#define EP_MAX_PACKET_INT	8
 206
 207/* Audio Control Interface */
 208static 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
 219static 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) */
 230static 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
 242static 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 */
 251static 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
 258static 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
 263static 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 */
 272static 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
 279static 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
 284static 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) */
 293static 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
 305static 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 */
 314static struct usb_endpoint_descriptor midi2_midi2_ep_out_desc[MAX_UMP_EPS];
 315
 316static 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
 321static struct usb_ms20_endpoint_descriptor_32 midi2_midi2_ep_out_class_desc[MAX_UMP_EPS];
 322
 323/* MIDI 2.0 EP IN */
 324static struct usb_endpoint_descriptor midi2_midi2_ep_in_desc[MAX_UMP_EPS];
 325
 326static 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
 331static struct usb_ms20_endpoint_descriptor_32 midi2_midi2_ep_in_class_desc[MAX_UMP_EPS];
 332
 333/* Arrays of descriptors to be created */
 334static void *midi2_audio_descs[] = {
 335	&midi2_audio_if_desc,
 336	&midi2_audio_class_desc,
 337	NULL
 338};
 339
 340static void *midi2_midi1_descs[] = {
 341	&midi2_midi1_if_desc,
 342	&midi2_midi1_class_desc,
 343	NULL
 344};
 345
 346static void *midi2_midi1_ep_out_descs[] = {
 347	&midi2_midi1_ep_out_desc,
 348	&midi2_midi1_ep_out_class_desc,
 349	NULL
 350};
 351
 352static void *midi2_midi1_ep_in_descs[] = {
 353	&midi2_midi1_ep_in_desc,
 354	&midi2_midi1_ep_in_class_desc,
 355	NULL
 356};
 357
 358static 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
 365static 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
 372static 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 */
 383static 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 */
 406static 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 */
 421static 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 */
 436static 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 */
 444static 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 */
 459static 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 */
 476static void reply_ump_stream_ep_device(struct f_midi2_ep *ep)
 477{
 478	struct snd_ump_stream_msg_device_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 */
 497static 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 */
 547static 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 */
 555static 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 */
 563static 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 */
 579static 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 */
 600static 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 */
 608static 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 */
 665static 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 */
 684static 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 */
 718static 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 */
 746static 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 */
 774static 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 */
 942static 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 */
 970static 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 */
 982static 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 */
1031static 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 */
1050static 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 */
1106static 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 */
1122static 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 */
1138static 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 */
1161static 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 */
1175static 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 */
1205static 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 */
1218static 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 */
1241static 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 */
1251static 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 */
1276static 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 */
1324static 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 */
1335static 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) */
1348static 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 */
1407static 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 */
1434static 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 */
1444static int f_midi2_ump_open(struct snd_ump_endpoint *ump, int dir)
1445{
1446	return 0;
1447}
1448
1449static void f_midi2_ump_close(struct snd_ump_endpoint *ump, int dir)
1450{
1451}
1452
1453static 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
1470static void f_midi2_ump_drain(struct snd_ump_endpoint *ump, int dir)
1471{
1472}
1473
1474static 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 */
1484static 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
1494static 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
1503static 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 */
1514static 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 */
1523static 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
1531static 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		snd_ump_update_group_attrs(ump);
1603	}
1604
1605	for (i = 0; i < midi2->num_eps; i++) {
1606		err = snd_ump_attach_legacy_rawmidi(midi2->midi2_eps[i].ump,
1607						    "Legacy MIDI", id);
1608		if (err < 0)
1609			goto error;
1610		id++;
1611	}
1612
1613	err = snd_ctl_add(card, snd_ctl_new1(&operation_mode_ctl, midi2));
1614	if (err < 0)
1615		goto error;
1616
1617	err = snd_card_register(card);
1618	if (err < 0)
1619		goto error;
1620
1621	return 0;
1622
1623 error:
1624	f_midi2_free_card(midi2);
1625	return err;
1626}
1627
1628/*
1629 * Creation of USB descriptors
1630 */
1631struct f_midi2_usb_config {
1632	struct usb_descriptor_header **list;
1633	unsigned int size;
1634	unsigned int alloc;
1635
1636	/* MIDI 1.0 jacks */
1637	unsigned char jack_in, jack_out, jack_id;
1638	struct usb_midi_in_jack_descriptor jack_ins[MAX_CABLES];
1639	struct usb_midi_out_jack_descriptor_1 jack_outs[MAX_CABLES];
1640};
1641
1642static int append_config(struct f_midi2_usb_config *config, void *d)
1643{
1644	unsigned int size;
1645	void *buf;
1646
1647	if (config->size + 2 >= config->alloc) {
1648		size = config->size + 16;
1649		buf = krealloc(config->list, size * sizeof(void *), GFP_KERNEL);
1650		if (!buf)
1651			return -ENOMEM;
1652		config->list = buf;
1653		config->alloc = size;
1654	}
1655
1656	config->list[config->size] = d;
1657	config->size++;
1658	config->list[config->size] = NULL;
1659	return 0;
1660}
1661
1662static int append_configs(struct f_midi2_usb_config *config, void **d)
1663{
1664	int err;
1665
1666	for (; *d; d++) {
1667		err = append_config(config, *d);
1668		if (err)
1669			return err;
1670	}
1671	return 0;
1672}
1673
1674static int append_midi1_in_jack(struct f_midi2 *midi2,
1675				struct f_midi2_usb_config *config,
1676				struct midi1_cable_mapping *map,
1677				unsigned int type)
1678{
1679	struct usb_midi_in_jack_descriptor *jack =
1680		&config->jack_ins[config->jack_in++];
1681	int id = ++config->jack_id;
1682	int err;
1683
1684	jack->bLength = 0x06;
1685	jack->bDescriptorType = USB_DT_CS_INTERFACE;
1686	jack->bDescriptorSubtype = USB_MS_MIDI_IN_JACK;
1687	jack->bJackType = type;
1688	jack->bJackID = id;
1689	/* use the corresponding block name as jack name */
1690	if (map->ep)
1691		jack->iJack = map->ep->blks[map->block].string_id;
1692
1693	err = append_config(config, jack);
1694	if (err < 0)
1695		return err;
1696	return id;
1697}
1698
1699static int append_midi1_out_jack(struct f_midi2 *midi2,
1700				 struct f_midi2_usb_config *config,
1701				 struct midi1_cable_mapping *map,
1702				 unsigned int type, unsigned int source)
1703{
1704	struct usb_midi_out_jack_descriptor_1 *jack =
1705		&config->jack_outs[config->jack_out++];
1706	int id = ++config->jack_id;
1707	int err;
1708
1709	jack->bLength = 0x09;
1710	jack->bDescriptorType = USB_DT_CS_INTERFACE;
1711	jack->bDescriptorSubtype = USB_MS_MIDI_OUT_JACK;
1712	jack->bJackType = type;
1713	jack->bJackID = id;
1714	jack->bNrInputPins = 1;
1715	jack->pins[0].baSourceID = source;
1716	jack->pins[0].baSourcePin = 0x01;
1717	/* use the corresponding block name as jack name */
1718	if (map->ep)
1719		jack->iJack = map->ep->blks[map->block].string_id;
1720
1721	err = append_config(config, jack);
1722	if (err < 0)
1723		return err;
1724	return id;
1725}
1726
1727static int f_midi2_create_usb_configs(struct f_midi2 *midi2,
1728				      struct f_midi2_usb_config *config,
1729				      int speed)
1730{
1731	void **midi1_in_eps, **midi1_out_eps;
1732	int i, jack, total;
1733	int err;
1734
1735	switch (speed) {
1736	default:
1737	case USB_SPEED_HIGH:
1738		midi2_midi1_ep_out_desc.wMaxPacketSize = cpu_to_le16(512);
1739		midi2_midi1_ep_in_desc.wMaxPacketSize = cpu_to_le16(512);
1740		for (i = 0; i < midi2->num_eps; i++) {
1741			midi2_midi2_ep_out_desc[i].wMaxPacketSize =
1742				cpu_to_le16(512);
1743			midi2_midi2_ep_in_desc[i].wMaxPacketSize =
1744				cpu_to_le16(512);
1745		}
1746		fallthrough;
1747	case USB_SPEED_FULL:
1748		midi1_in_eps = midi2_midi1_ep_in_descs;
1749		midi1_out_eps = midi2_midi1_ep_out_descs;
1750		break;
1751	case USB_SPEED_SUPER:
1752		midi2_midi1_ep_out_desc.wMaxPacketSize = cpu_to_le16(1024);
1753		midi2_midi1_ep_in_desc.wMaxPacketSize = cpu_to_le16(1024);
1754		for (i = 0; i < midi2->num_eps; i++) {
1755			midi2_midi2_ep_out_desc[i].wMaxPacketSize =
1756				cpu_to_le16(1024);
1757			midi2_midi2_ep_in_desc[i].wMaxPacketSize =
1758				cpu_to_le16(1024);
1759		}
1760		midi1_in_eps = midi2_midi1_ep_in_ss_descs;
1761		midi1_out_eps = midi2_midi1_ep_out_ss_descs;
1762		break;
1763	}
1764
1765	err = append_configs(config, midi2_audio_descs);
1766	if (err < 0)
1767		return err;
1768
1769	if (midi2->num_midi1_in && midi2->num_midi1_out)
1770		midi2_midi1_if_desc.bNumEndpoints = 2;
1771	else
1772		midi2_midi1_if_desc.bNumEndpoints = 1;
1773
1774	err = append_configs(config, midi2_midi1_descs);
1775	if (err < 0)
1776		return err;
1777
1778	total = USB_DT_MS_HEADER_SIZE;
1779	if (midi2->num_midi1_out) {
1780		midi2_midi1_ep_out_class_desc.bLength =
1781			USB_DT_MS_ENDPOINT_SIZE(midi2->num_midi1_out);
1782		total += midi2_midi1_ep_out_class_desc.bLength;
1783		midi2_midi1_ep_out_class_desc.bNumEmbMIDIJack =
1784			midi2->num_midi1_out;
1785		total += midi2->num_midi1_out *
1786			(USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
1787		for (i = 0; i < midi2->num_midi1_out; i++) {
1788			jack = append_midi1_in_jack(midi2, config,
1789						    &midi2->in_cable_mapping[i],
1790						    USB_MS_EMBEDDED);
1791			if (jack < 0)
1792				return jack;
1793			midi2_midi1_ep_out_class_desc.baAssocJackID[i] = jack;
1794			jack = append_midi1_out_jack(midi2, config,
1795						     &midi2->in_cable_mapping[i],
1796						     USB_MS_EXTERNAL, jack);
1797			if (jack < 0)
1798				return jack;
1799		}
1800	}
1801
1802	if (midi2->num_midi1_in) {
1803		midi2_midi1_ep_in_class_desc.bLength =
1804			USB_DT_MS_ENDPOINT_SIZE(midi2->num_midi1_in);
1805		total += midi2_midi1_ep_in_class_desc.bLength;
1806		midi2_midi1_ep_in_class_desc.bNumEmbMIDIJack =
1807			midi2->num_midi1_in;
1808		total += midi2->num_midi1_in *
1809			(USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
1810		for (i = 0; i < midi2->num_midi1_in; i++) {
1811			jack = append_midi1_in_jack(midi2, config,
1812						    &midi2->out_cable_mapping[i],
1813						    USB_MS_EXTERNAL);
1814			if (jack < 0)
1815				return jack;
1816			jack = append_midi1_out_jack(midi2, config,
1817						     &midi2->out_cable_mapping[i],
1818						     USB_MS_EMBEDDED, jack);
1819			if (jack < 0)
1820				return jack;
1821			midi2_midi1_ep_in_class_desc.baAssocJackID[i] = jack;
1822		}
1823	}
1824
1825	midi2_midi1_class_desc.wTotalLength = cpu_to_le16(total);
1826
1827	if (midi2->num_midi1_out) {
1828		err = append_configs(config, midi1_out_eps);
1829		if (err < 0)
1830			return err;
1831	}
1832	if (midi2->num_midi1_in) {
1833		err = append_configs(config, midi1_in_eps);
1834		if (err < 0)
1835			return err;
1836	}
1837
1838	err = append_configs(config, midi2_midi2_descs);
1839	if (err < 0)
1840		return err;
1841
1842	for (i = 0; i < midi2->num_eps; i++) {
1843		err = append_config(config, &midi2_midi2_ep_out_desc[i]);
1844		if (err < 0)
1845			return err;
1846		if (speed == USB_SPEED_SUPER || speed == USB_SPEED_SUPER_PLUS) {
1847			err = append_config(config, &midi2_midi2_ep_out_ss_comp_desc);
1848			if (err < 0)
1849				return err;
1850		}
1851		err = append_config(config, &midi2_midi2_ep_out_class_desc[i]);
1852		if (err < 0)
1853			return err;
1854		err = append_config(config, &midi2_midi2_ep_in_desc[i]);
1855		if (err < 0)
1856			return err;
1857		if (speed == USB_SPEED_SUPER || speed == USB_SPEED_SUPER_PLUS) {
1858			err = append_config(config, &midi2_midi2_ep_in_ss_comp_desc);
1859			if (err < 0)
1860				return err;
1861		}
1862		err = append_config(config, &midi2_midi2_ep_in_class_desc[i]);
1863		if (err < 0)
1864			return err;
1865	}
1866
1867	return 0;
1868}
1869
1870static void f_midi2_free_usb_configs(struct f_midi2_usb_config *config)
1871{
1872	kfree(config->list);
1873	memset(config, 0, sizeof(*config));
1874}
1875
1876/* as we use the static descriptors for simplicity, serialize bind call */
1877static DEFINE_MUTEX(f_midi2_desc_mutex);
1878
1879/* fill MIDI2 EP class-specific descriptor */
1880static void fill_midi2_class_desc(struct f_midi2_ep *ep,
1881				  struct usb_ms20_endpoint_descriptor_32 *cdesc)
1882{
1883	int blk;
1884
1885	cdesc->bLength = USB_DT_MS20_ENDPOINT_SIZE(ep->num_blks);
1886	cdesc->bDescriptorType = USB_DT_CS_ENDPOINT;
1887	cdesc->bDescriptorSubtype = USB_MS_GENERAL_2_0;
1888	cdesc->bNumGrpTrmBlock = ep->num_blks;
1889	for (blk = 0; blk < ep->num_blks; blk++)
1890		cdesc->baAssoGrpTrmBlkID[blk] = ep->blks[blk].gtb_id;
1891}
1892
1893/* initialize MIDI2 EP-in */
1894static int f_midi2_init_midi2_ep_in(struct f_midi2 *midi2, int index)
1895{
1896	struct f_midi2_ep *ep = &midi2->midi2_eps[index];
1897	struct usb_endpoint_descriptor *desc = &midi2_midi2_ep_in_desc[index];
1898
1899	desc->bLength = USB_DT_ENDPOINT_SIZE;
1900	desc->bDescriptorType = USB_DT_ENDPOINT;
1901	desc->bEndpointAddress = USB_DIR_IN;
1902	desc->bmAttributes = USB_ENDPOINT_XFER_INT;
1903	desc->wMaxPacketSize = cpu_to_le16(EP_MAX_PACKET_INT);
1904	desc->bInterval = 1;
1905
1906	fill_midi2_class_desc(ep, &midi2_midi2_ep_in_class_desc[index]);
1907
1908	return f_midi2_init_ep(midi2, ep, &ep->ep_in, desc,
1909			       f_midi2_ep_in_complete);
1910}
1911
1912/* initialize MIDI2 EP-out */
1913static int f_midi2_init_midi2_ep_out(struct f_midi2 *midi2, int index)
1914{
1915	struct f_midi2_ep *ep = &midi2->midi2_eps[index];
1916	struct usb_endpoint_descriptor *desc = &midi2_midi2_ep_out_desc[index];
1917
1918	desc->bLength = USB_DT_ENDPOINT_SIZE;
1919	desc->bDescriptorType = USB_DT_ENDPOINT;
1920	desc->bEndpointAddress = USB_DIR_OUT;
1921	desc->bmAttributes = USB_ENDPOINT_XFER_BULK;
1922
1923	fill_midi2_class_desc(ep, &midi2_midi2_ep_out_class_desc[index]);
1924
1925	return f_midi2_init_ep(midi2, ep, &ep->ep_out, desc,
1926			       f_midi2_ep_out_complete);
1927}
1928
1929/* gadget function bind callback */
1930static int f_midi2_bind(struct usb_configuration *c, struct usb_function *f)
1931{
1932	struct usb_composite_dev *cdev = c->cdev;
1933	struct f_midi2 *midi2 = func_to_midi2(f);
1934	struct f_midi2_ep *ep;
1935	struct f_midi2_usb_config config = {};
1936	struct usb_gadget_strings string_fn = {
1937		.language = 0x0409,	/* en-us */
1938		.strings = midi2->string_defs,
1939	};
1940	struct usb_gadget_strings *strings[] = {
1941		&string_fn,
1942		NULL,
1943	};
1944	int i, blk, status;
1945
1946	midi2->gadget = cdev->gadget;
1947	midi2->operation_mode = MIDI_OP_MODE_UNSET;
1948
1949	status = f_midi2_create_card(midi2);
1950	if (status < 0)
1951		goto fail_register;
1952
1953	/* maybe allocate device-global string ID */
1954	midi2->strings = usb_gstrings_attach(c->cdev, strings,
1955					     midi2->total_blocks + 1);
1956	if (IS_ERR(midi2->strings)) {
1957		status = PTR_ERR(midi2->strings);
1958		goto fail_string;
1959	}
1960
1961	mutex_lock(&f_midi2_desc_mutex);
1962	midi2_midi1_if_desc.iInterface = midi2->strings[STR_IFACE].id;
1963	midi2_midi2_if_desc.iInterface = midi2->strings[STR_IFACE].id;
1964	for (i = 0; i < midi2->num_eps; i++) {
1965		ep = &midi2->midi2_eps[i];
1966		for (blk = 0; blk < ep->num_blks; blk++)
1967			ep->blks[blk].string_id =
1968				midi2->strings[gtb_to_str_id(ep->blks[blk].gtb_id)].id;
1969	}
1970
1971	midi2_midi2_if_desc.bNumEndpoints = midi2->num_eps * 2;
1972
1973	/* audio interface */
1974	status = usb_interface_id(c, f);
1975	if (status < 0)
1976		goto fail;
1977	midi2_audio_if_desc.bInterfaceNumber = status;
1978
1979	/* MIDI streaming */
1980	status = usb_interface_id(c, f);
1981	if (status < 0)
1982		goto fail;
1983	midi2->midi_if = status;
1984	midi2_midi1_if_desc.bInterfaceNumber = status;
1985	midi2_midi2_if_desc.bInterfaceNumber = status;
1986	midi2_audio_class_desc.baInterfaceNr[0] = status;
1987
1988	/* allocate instance-specific endpoints */
1989	if (midi2->midi2_eps[0].blks[0].info.direction != SNDRV_UMP_DIR_OUTPUT) {
1990		status = f_midi2_init_ep(midi2, NULL, &midi2->midi1_ep_in,
1991					 &midi2_midi1_ep_in_desc,
1992					 f_midi2_midi1_ep_in_complete);
1993		if (status)
1994			goto fail;
1995	}
1996
1997	if (midi2->midi2_eps[0].blks[0].info.direction != SNDRV_UMP_DIR_INPUT) {
1998		status = f_midi2_init_ep(midi2, NULL, &midi2->midi1_ep_out,
1999					 &midi2_midi1_ep_out_desc,
2000					 f_midi2_midi1_ep_out_complete);
2001		if (status)
2002			goto fail;
2003	}
2004
2005	for (i = 0; i < midi2->num_eps; i++) {
2006		status = f_midi2_init_midi2_ep_in(midi2, i);
2007		if (status)
2008			goto fail;
2009		status = f_midi2_init_midi2_ep_out(midi2, i);
2010		if (status)
2011			goto fail;
2012	}
2013
2014	status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_FULL);
2015	if (status < 0)
2016		goto fail;
2017	f->fs_descriptors = usb_copy_descriptors(config.list);
2018	if (!f->fs_descriptors) {
2019		status = -ENOMEM;
2020		goto fail;
2021	}
2022	f_midi2_free_usb_configs(&config);
2023
2024	status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_HIGH);
2025	if (status < 0)
2026		goto fail;
2027	f->hs_descriptors = usb_copy_descriptors(config.list);
2028	if (!f->hs_descriptors) {
2029		status = -ENOMEM;
2030		goto fail;
2031	}
2032	f_midi2_free_usb_configs(&config);
2033
2034	status = f_midi2_create_usb_configs(midi2, &config, USB_SPEED_SUPER);
2035	if (status < 0)
2036		goto fail;
2037	f->ss_descriptors = usb_copy_descriptors(config.list);
2038	if (!f->ss_descriptors) {
2039		status = -ENOMEM;
2040		goto fail;
2041	}
2042	f_midi2_free_usb_configs(&config);
2043
2044	mutex_unlock(&f_midi2_desc_mutex);
2045	return 0;
2046
2047fail:
2048	f_midi2_free_usb_configs(&config);
2049	mutex_unlock(&f_midi2_desc_mutex);
2050	usb_free_all_descriptors(f);
2051fail_string:
2052	f_midi2_free_card(midi2);
2053fail_register:
2054	ERROR(midi2, "%s: can't bind, err %d\n", f->name, status);
2055	return status;
2056}
2057
2058/* gadget function unbind callback */
2059static void f_midi2_unbind(struct usb_configuration *c, struct usb_function *f)
2060{
2061	struct f_midi2 *midi2 = func_to_midi2(f);
2062	int i;
2063
2064	f_midi2_free_card(midi2);
2065
2066	f_midi2_free_ep(&midi2->midi1_ep_in);
2067	f_midi2_free_ep(&midi2->midi1_ep_out);
2068	for (i = 0; i < midi2->num_eps; i++) {
2069		f_midi2_free_ep(&midi2->midi2_eps[i].ep_in);
2070		f_midi2_free_ep(&midi2->midi2_eps[i].ep_out);
2071	}
2072
2073	usb_free_all_descriptors(f);
2074}
2075
2076/*
2077 * ConfigFS interface
2078 */
2079
2080/* type conversion helpers */
2081static inline struct f_midi2_opts *to_f_midi2_opts(struct config_item *item)
2082{
2083	return container_of(to_config_group(item), struct f_midi2_opts,
2084			    func_inst.group);
2085}
2086
2087static inline struct f_midi2_ep_opts *
2088to_f_midi2_ep_opts(struct config_item *item)
2089{
2090	return container_of(to_config_group(item), struct f_midi2_ep_opts,
2091			    group);
2092}
2093
2094static inline struct f_midi2_block_opts *
2095to_f_midi2_block_opts(struct config_item *item)
2096{
2097	return container_of(to_config_group(item), struct f_midi2_block_opts,
2098			    group);
2099}
2100
2101/* trim the string to be usable for EP and FB name strings */
2102static void make_name_string(char *s)
2103{
2104	char *p;
2105
2106	p = strchr(s, '\n');
2107	if (p)
2108		*p = 0;
2109
2110	p = s + strlen(s);
2111	for (; p > s && isspace(*p); p--)
2112		*p = 0;
2113}
2114
2115/* configfs helpers: generic show/store for unisnged int */
2116static ssize_t f_midi2_opts_uint_show(struct f_midi2_opts *opts,
2117				      u32 val, const char *format, char *page)
2118{
2119	int result;
2120
2121	mutex_lock(&opts->lock);
2122	result = sprintf(page, format, val);
2123	mutex_unlock(&opts->lock);
2124	return result;
2125}
2126
2127static ssize_t f_midi2_opts_uint_store(struct f_midi2_opts *opts,
2128				       u32 *valp, u32 minval, u32 maxval,
2129				       const char *page, size_t len)
2130{
2131	int ret;
2132	u32 val;
2133
2134	mutex_lock(&opts->lock);
2135	if (opts->refcnt) {
2136		ret = -EBUSY;
2137		goto end;
2138	}
2139
2140	ret = kstrtou32(page, 0, &val);
2141	if (ret)
2142		goto end;
2143	if (val < minval || val > maxval) {
2144		ret = -EINVAL;
2145		goto end;
2146	}
2147
2148	*valp = val;
2149	ret = len;
2150
2151end:
2152	mutex_unlock(&opts->lock);
2153	return ret;
2154}
2155
2156/* generic store for bool */
2157static ssize_t f_midi2_opts_bool_store(struct f_midi2_opts *opts,
2158				       bool *valp, const char *page, size_t len)
2159{
2160	int ret;
2161	bool val;
2162
2163	mutex_lock(&opts->lock);
2164	if (opts->refcnt) {
2165		ret = -EBUSY;
2166		goto end;
2167	}
2168
2169	ret = kstrtobool(page, &val);
2170	if (ret)
2171		goto end;
2172	*valp = val;
2173	ret = len;
2174
2175end:
2176	mutex_unlock(&opts->lock);
2177	return ret;
2178}
2179
2180/* generic show/store for string */
2181static ssize_t f_midi2_opts_str_show(struct f_midi2_opts *opts,
2182				     const char *str, char *page)
2183{
2184	int result = 0;
2185
2186	mutex_lock(&opts->lock);
2187	if (str)
2188		result = scnprintf(page, PAGE_SIZE, "%s\n", str);
2189	mutex_unlock(&opts->lock);
2190	return result;
2191}
2192
2193static ssize_t f_midi2_opts_str_store(struct f_midi2_opts *opts,
2194				      const char **strp, size_t maxlen,
2195				      const char *page, size_t len)
2196{
2197	char *c;
2198	int ret;
2199
2200	mutex_lock(&opts->lock);
2201	if (opts->refcnt) {
2202		ret = -EBUSY;
2203		goto end;
2204	}
2205
2206	c = kstrndup(page, min(len, maxlen), GFP_KERNEL);
2207	if (!c) {
2208		ret = -ENOMEM;
2209		goto end;
2210	}
2211
2212	kfree(*strp);
2213	make_name_string(c);
2214	*strp = c;
2215	ret = len;
2216
2217end:
2218	mutex_unlock(&opts->lock);
2219	return ret;
2220}
2221
2222/*
2223 * Definitions for UMP Block config
2224 */
2225
2226/* define an uint option for block */
2227#define F_MIDI2_BLOCK_OPT(name, format, minval, maxval)			\
2228static ssize_t f_midi2_block_opts_##name##_show(struct config_item *item,\
2229					  char *page)			\
2230{									\
2231	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);	\
2232	return f_midi2_opts_uint_show(opts->ep->opts, opts->info.name,	\
2233				      format "\n", page);		\
2234}									\
2235									\
2236static ssize_t f_midi2_block_opts_##name##_store(struct config_item *item,\
2237					 const char *page, size_t len)	\
2238{									\
2239	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);	\
2240	return f_midi2_opts_uint_store(opts->ep->opts, &opts->info.name,\
2241				       minval, maxval, page, len);	\
2242}									\
2243									\
2244CONFIGFS_ATTR(f_midi2_block_opts_, name)
2245
2246/* define a boolean option for block */
2247#define F_MIDI2_BLOCK_BOOL_OPT(name)					\
2248static ssize_t f_midi2_block_opts_##name##_show(struct config_item *item,\
2249					  char *page)			\
2250{									\
2251	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);	\
2252	return f_midi2_opts_uint_show(opts->ep->opts, opts->info.name,	\
2253				      "%u\n", page);			\
2254}									\
2255									\
2256static ssize_t f_midi2_block_opts_##name##_store(struct config_item *item,\
2257					 const char *page, size_t len)	\
2258{									\
2259	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);	\
2260	return f_midi2_opts_bool_store(opts->ep->opts, &opts->info.name,\
2261				       page, len);			\
2262}									\
2263									\
2264CONFIGFS_ATTR(f_midi2_block_opts_, name)
2265
2266F_MIDI2_BLOCK_OPT(direction, "0x%x", 1, 3);
2267F_MIDI2_BLOCK_OPT(first_group, "0x%x", 0, 15);
2268F_MIDI2_BLOCK_OPT(num_groups, "0x%x", 1, 16);
2269F_MIDI2_BLOCK_OPT(midi1_first_group, "0x%x", 0, 15);
2270F_MIDI2_BLOCK_OPT(midi1_num_groups, "0x%x", 0, 16);
2271F_MIDI2_BLOCK_OPT(ui_hint, "0x%x", 0, 3);
2272F_MIDI2_BLOCK_OPT(midi_ci_version, "%u", 0, 1);
2273F_MIDI2_BLOCK_OPT(sysex8_streams, "%u", 0, 255);
2274F_MIDI2_BLOCK_OPT(is_midi1, "%u", 0, 2);
2275F_MIDI2_BLOCK_BOOL_OPT(active);
2276
2277static ssize_t f_midi2_block_opts_name_show(struct config_item *item,
2278					    char *page)
2279{
2280	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2281
2282	return f_midi2_opts_str_show(opts->ep->opts, opts->info.name, page);
2283}
2284
2285static ssize_t f_midi2_block_opts_name_store(struct config_item *item,
2286					     const char *page, size_t len)
2287{
2288	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2289
2290	return f_midi2_opts_str_store(opts->ep->opts, &opts->info.name, 128,
2291				      page, len);
2292}
2293
2294CONFIGFS_ATTR(f_midi2_block_opts_, name);
2295
2296static struct configfs_attribute *f_midi2_block_attrs[] = {
2297	&f_midi2_block_opts_attr_direction,
2298	&f_midi2_block_opts_attr_first_group,
2299	&f_midi2_block_opts_attr_num_groups,
2300	&f_midi2_block_opts_attr_midi1_first_group,
2301	&f_midi2_block_opts_attr_midi1_num_groups,
2302	&f_midi2_block_opts_attr_ui_hint,
2303	&f_midi2_block_opts_attr_midi_ci_version,
2304	&f_midi2_block_opts_attr_sysex8_streams,
2305	&f_midi2_block_opts_attr_is_midi1,
2306	&f_midi2_block_opts_attr_active,
2307	&f_midi2_block_opts_attr_name,
2308	NULL,
2309};
2310
2311static void f_midi2_block_opts_release(struct config_item *item)
2312{
2313	struct f_midi2_block_opts *opts = to_f_midi2_block_opts(item);
2314
2315	kfree(opts->info.name);
2316	kfree(opts);
2317}
2318
2319static struct configfs_item_operations f_midi2_block_item_ops = {
2320	.release	= f_midi2_block_opts_release,
2321};
2322
2323static const struct config_item_type f_midi2_block_type = {
2324	.ct_item_ops	= &f_midi2_block_item_ops,
2325	.ct_attrs	= f_midi2_block_attrs,
2326	.ct_owner	= THIS_MODULE,
2327};
2328
2329/* create a f_midi2_block_opts instance for the given block number */
2330static int f_midi2_block_opts_create(struct f_midi2_ep_opts *ep_opts,
2331				     unsigned int blk,
2332				     struct f_midi2_block_opts **block_p)
2333{
2334	struct f_midi2_block_opts *block_opts;
2335	int ret = 0;
2336
2337	mutex_lock(&ep_opts->opts->lock);
2338	if (ep_opts->opts->refcnt || ep_opts->blks[blk]) {
2339		ret = -EBUSY;
2340		goto out;
2341	}
2342
2343	block_opts = kzalloc(sizeof(*block_opts), GFP_KERNEL);
2344	if (!block_opts) {
2345		ret = -ENOMEM;
2346		goto out;
2347	}
2348
2349	block_opts->ep = ep_opts;
2350	block_opts->id = blk;
2351
2352	/* set up the default values */
2353	block_opts->info.direction = SNDRV_UMP_DIR_BIDIRECTION;
2354	block_opts->info.first_group = 0;
2355	block_opts->info.num_groups = 1;
2356	block_opts->info.ui_hint = SNDRV_UMP_BLOCK_UI_HINT_BOTH;
2357	block_opts->info.active = 1;
2358
2359	ep_opts->blks[blk] = block_opts;
2360	*block_p = block_opts;
2361
2362 out:
2363	mutex_unlock(&ep_opts->opts->lock);
2364	return ret;
2365}
2366
2367/* make_group callback for a block */
2368static struct config_group *
2369f_midi2_opts_block_make(struct config_group *group, const char *name)
2370{
2371	struct f_midi2_ep_opts *ep_opts;
2372	struct f_midi2_block_opts *block_opts;
2373	unsigned int blk;
2374	int ret;
2375
2376	if (strncmp(name, "block.", 6))
2377		return ERR_PTR(-EINVAL);
2378	ret = kstrtouint(name + 6, 10, &blk);
2379	if (ret)
2380		return ERR_PTR(ret);
2381
2382	ep_opts = to_f_midi2_ep_opts(&group->cg_item);
2383
2384	if (blk >= SNDRV_UMP_MAX_BLOCKS)
2385		return ERR_PTR(-EINVAL);
2386	if (ep_opts->blks[blk])
2387		return ERR_PTR(-EBUSY);
2388	ret = f_midi2_block_opts_create(ep_opts, blk, &block_opts);
2389	if (ret)
2390		return ERR_PTR(ret);
2391
2392	config_group_init_type_name(&block_opts->group, name,
2393				    &f_midi2_block_type);
2394	return &block_opts->group;
2395}
2396
2397/* drop_item callback for a block */
2398static void
2399f_midi2_opts_block_drop(struct config_group *group, struct config_item *item)
2400{
2401	struct f_midi2_block_opts *block_opts = to_f_midi2_block_opts(item);
2402
2403	mutex_lock(&block_opts->ep->opts->lock);
2404	block_opts->ep->blks[block_opts->id] = NULL;
2405	mutex_unlock(&block_opts->ep->opts->lock);
2406	config_item_put(item);
2407}
2408
2409/*
2410 * Definitions for UMP Endpoint config
2411 */
2412
2413/* define an uint option for EP */
2414#define F_MIDI2_EP_OPT(name, format, minval, maxval)			\
2415static ssize_t f_midi2_ep_opts_##name##_show(struct config_item *item,	\
2416					     char *page)		\
2417{									\
2418	struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);	\
2419	return f_midi2_opts_uint_show(opts->opts, opts->info.name,	\
2420				      format "\n", page);		\
2421}									\
2422									\
2423static ssize_t f_midi2_ep_opts_##name##_store(struct config_item *item,	\
2424					   const char *page, size_t len)\
2425{									\
2426	struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);	\
2427	return f_midi2_opts_uint_store(opts->opts, &opts->info.name,	\
2428				       minval, maxval, page, len);	\
2429}									\
2430									\
2431CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2432
2433/* define a string option for EP */
2434#define F_MIDI2_EP_STR_OPT(name, maxlen)				\
2435static ssize_t f_midi2_ep_opts_##name##_show(struct config_item *item,	\
2436					     char *page)		\
2437{									\
2438	struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);	\
2439	return f_midi2_opts_str_show(opts->opts, opts->info.name, page);\
2440}									\
2441									\
2442static ssize_t f_midi2_ep_opts_##name##_store(struct config_item *item,	\
2443					 const char *page, size_t len)	\
2444{									\
2445	struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);	\
2446	return f_midi2_opts_str_store(opts->opts, &opts->info.name, maxlen,\
2447				      page, len);			\
2448}									\
2449									\
2450CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2451
2452F_MIDI2_EP_OPT(protocol, "0x%x", 1, 2);
2453F_MIDI2_EP_OPT(protocol_caps, "0x%x", 1, 3);
2454F_MIDI2_EP_OPT(manufacturer, "0x%x", 0, 0xffffff);
2455F_MIDI2_EP_OPT(family, "0x%x", 0, 0xffff);
2456F_MIDI2_EP_OPT(model, "0x%x", 0, 0xffff);
2457F_MIDI2_EP_OPT(sw_revision, "0x%x", 0, 0xffffffff);
2458F_MIDI2_EP_STR_OPT(ep_name, 128);
2459F_MIDI2_EP_STR_OPT(product_id, 128);
2460
2461static struct configfs_attribute *f_midi2_ep_attrs[] = {
2462	&f_midi2_ep_opts_attr_protocol,
2463	&f_midi2_ep_opts_attr_protocol_caps,
2464	&f_midi2_ep_opts_attr_ep_name,
2465	&f_midi2_ep_opts_attr_product_id,
2466	&f_midi2_ep_opts_attr_manufacturer,
2467	&f_midi2_ep_opts_attr_family,
2468	&f_midi2_ep_opts_attr_model,
2469	&f_midi2_ep_opts_attr_sw_revision,
2470	NULL,
2471};
2472
2473static void f_midi2_ep_opts_release(struct config_item *item)
2474{
2475	struct f_midi2_ep_opts *opts = to_f_midi2_ep_opts(item);
2476
2477	kfree(opts->info.ep_name);
2478	kfree(opts->info.product_id);
2479	kfree(opts);
2480}
2481
2482static struct configfs_item_operations f_midi2_ep_item_ops = {
2483	.release	= f_midi2_ep_opts_release,
2484};
2485
2486static struct configfs_group_operations f_midi2_ep_group_ops = {
2487	.make_group	= f_midi2_opts_block_make,
2488	.drop_item	= f_midi2_opts_block_drop,
2489};
2490
2491static const struct config_item_type f_midi2_ep_type = {
2492	.ct_item_ops	= &f_midi2_ep_item_ops,
2493	.ct_group_ops	= &f_midi2_ep_group_ops,
2494	.ct_attrs	= f_midi2_ep_attrs,
2495	.ct_owner	= THIS_MODULE,
2496};
2497
2498/* create a f_midi2_ep_opts instance */
2499static int f_midi2_ep_opts_create(struct f_midi2_opts *opts,
2500				  unsigned int index,
2501				  struct f_midi2_ep_opts **ep_p)
2502{
2503	struct f_midi2_ep_opts *ep_opts;
2504
2505	ep_opts = kzalloc(sizeof(*ep_opts), GFP_KERNEL);
2506	if (!ep_opts)
2507		return -ENOMEM;
2508
2509	ep_opts->opts = opts;
2510	ep_opts->index = index;
2511
2512	/* set up the default values */
2513	ep_opts->info.protocol = 2;
2514	ep_opts->info.protocol_caps = 3;
2515
2516	opts->eps[index] = ep_opts;
2517	*ep_p = ep_opts;
2518	return 0;
2519}
2520
2521/* make_group callback for an EP */
2522static struct config_group *
2523f_midi2_opts_ep_make(struct config_group *group, const char *name)
2524{
2525	struct f_midi2_opts *opts;
2526	struct f_midi2_ep_opts *ep_opts;
2527	unsigned int index;
2528	int ret;
2529
2530	if (strncmp(name, "ep.", 3))
2531		return ERR_PTR(-EINVAL);
2532	ret = kstrtouint(name + 3, 10, &index);
2533	if (ret)
2534		return ERR_PTR(ret);
2535
2536	opts = to_f_midi2_opts(&group->cg_item);
2537	if (index >= MAX_UMP_EPS)
2538		return ERR_PTR(-EINVAL);
2539	if (opts->eps[index])
2540		return ERR_PTR(-EBUSY);
2541	ret = f_midi2_ep_opts_create(opts, index, &ep_opts);
2542	if (ret)
2543		return ERR_PTR(ret);
2544
2545	config_group_init_type_name(&ep_opts->group, name, &f_midi2_ep_type);
2546	return &ep_opts->group;
2547}
2548
2549/* drop_item callback for an EP */
2550static void
2551f_midi2_opts_ep_drop(struct config_group *group, struct config_item *item)
2552{
2553	struct f_midi2_ep_opts *ep_opts = to_f_midi2_ep_opts(item);
2554
2555	mutex_lock(&ep_opts->opts->lock);
2556	ep_opts->opts->eps[ep_opts->index] = NULL;
2557	mutex_unlock(&ep_opts->opts->lock);
2558	config_item_put(item);
2559}
2560
2561/*
2562 * Definitions for card config
2563 */
2564
2565/* define a bool option for card */
2566#define F_MIDI2_BOOL_OPT(name)						\
2567static ssize_t f_midi2_opts_##name##_show(struct config_item *item,	\
2568					  char *page)			\
2569{									\
2570	struct f_midi2_opts *opts = to_f_midi2_opts(item);		\
2571	return f_midi2_opts_uint_show(opts, opts->info.name,		\
2572				      "%u\n", page);			\
2573}									\
2574									\
2575static ssize_t f_midi2_opts_##name##_store(struct config_item *item,	\
2576					 const char *page, size_t len)	\
2577{									\
2578	struct f_midi2_opts *opts = to_f_midi2_opts(item);		\
2579	return f_midi2_opts_bool_store(opts, &opts->info.name,		\
2580				       page, len);			\
2581}									\
2582									\
2583CONFIGFS_ATTR(f_midi2_opts_, name)
2584
2585F_MIDI2_BOOL_OPT(process_ump);
2586F_MIDI2_BOOL_OPT(static_block);
2587
2588static ssize_t f_midi2_opts_iface_name_show(struct config_item *item,
2589					    char *page)
2590{
2591	struct f_midi2_opts *opts = to_f_midi2_opts(item);
2592
2593	return f_midi2_opts_str_show(opts, opts->info.iface_name, page);
2594}
2595
2596static ssize_t f_midi2_opts_iface_name_store(struct config_item *item,
2597					     const char *page, size_t len)
2598{
2599	struct f_midi2_opts *opts = to_f_midi2_opts(item);
2600
2601	return f_midi2_opts_str_store(opts, &opts->info.iface_name, 128,
2602				      page, len);
2603}
2604
2605CONFIGFS_ATTR(f_midi2_opts_, iface_name);
2606
2607static struct configfs_attribute *f_midi2_attrs[] = {
2608	&f_midi2_opts_attr_process_ump,
2609	&f_midi2_opts_attr_static_block,
2610	&f_midi2_opts_attr_iface_name,
2611	NULL
2612};
2613
2614static void f_midi2_opts_release(struct config_item *item)
2615{
2616	struct f_midi2_opts *opts = to_f_midi2_opts(item);
2617
2618	usb_put_function_instance(&opts->func_inst);
2619}
2620
2621static struct configfs_item_operations f_midi2_item_ops = {
2622	.release	= f_midi2_opts_release,
2623};
2624
2625static struct configfs_group_operations f_midi2_group_ops = {
2626	.make_group	= f_midi2_opts_ep_make,
2627	.drop_item	= f_midi2_opts_ep_drop,
2628};
2629
2630static const struct config_item_type f_midi2_func_type = {
2631	.ct_item_ops	= &f_midi2_item_ops,
2632	.ct_group_ops	= &f_midi2_group_ops,
2633	.ct_attrs	= f_midi2_attrs,
2634	.ct_owner	= THIS_MODULE,
2635};
2636
2637static void f_midi2_free_inst(struct usb_function_instance *f)
2638{
2639	struct f_midi2_opts *opts;
2640
2641	opts = container_of(f, struct f_midi2_opts, func_inst);
2642
2643	kfree(opts->info.iface_name);
2644	kfree(opts);
2645}
2646
2647/* gadget alloc_inst */
2648static struct usb_function_instance *f_midi2_alloc_inst(void)
2649{
2650	struct f_midi2_opts *opts;
2651	struct f_midi2_ep_opts *ep_opts;
2652	struct f_midi2_block_opts *block_opts;
2653	int ret;
2654
2655	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
2656	if (!opts)
2657		return ERR_PTR(-ENOMEM);
2658
2659	mutex_init(&opts->lock);
2660	opts->func_inst.free_func_inst = f_midi2_free_inst;
2661	opts->info.process_ump = true;
2662	opts->info.static_block = true;
2663	opts->info.num_reqs = 32;
2664	opts->info.req_buf_size = 512;
2665
2666	/* create the default ep */
2667	ret = f_midi2_ep_opts_create(opts, 0, &ep_opts);
2668	if (ret) {
2669		kfree(opts);
2670		return ERR_PTR(ret);
2671	}
2672
2673	/* create the default block */
2674	ret = f_midi2_block_opts_create(ep_opts, 0, &block_opts);
2675	if (ret) {
2676		kfree(ep_opts);
2677		kfree(opts);
2678		return ERR_PTR(ret);
2679	}
2680
2681	/* set up the default MIDI1 (that is mandatory) */
2682	block_opts->info.midi1_num_groups = 1;
2683
2684	config_group_init_type_name(&opts->func_inst.group, "",
2685				    &f_midi2_func_type);
2686
2687	config_group_init_type_name(&ep_opts->group, "ep.0",
2688				    &f_midi2_ep_type);
2689	configfs_add_default_group(&ep_opts->group, &opts->func_inst.group);
2690
2691	config_group_init_type_name(&block_opts->group, "block.0",
2692				    &f_midi2_block_type);
2693	configfs_add_default_group(&block_opts->group, &ep_opts->group);
2694
2695	return &opts->func_inst;
2696}
2697
2698static void do_f_midi2_free(struct f_midi2 *midi2, struct f_midi2_opts *opts)
2699{
2700	mutex_lock(&opts->lock);
2701	--opts->refcnt;
2702	mutex_unlock(&opts->lock);
2703	kfree(midi2->string_defs);
2704	kfree(midi2);
2705}
2706
2707static void f_midi2_free(struct usb_function *f)
2708{
2709	do_f_midi2_free(func_to_midi2(f),
2710			container_of(f->fi, struct f_midi2_opts, func_inst));
2711}
2712
2713/* verify the parameters set up via configfs;
2714 * return the number of EPs or a negative error
2715 */
2716static int verify_parameters(struct f_midi2_opts *opts)
2717{
2718	int i, j, num_eps, num_blks;
2719	struct f_midi2_ep_info *ep;
2720	struct f_midi2_block_info *bp;
2721
2722	for (num_eps = 0; num_eps < MAX_UMP_EPS && opts->eps[num_eps];
2723	     num_eps++)
2724		;
2725	if (!num_eps) {
2726		pr_err("f_midi2: No EP is defined\n");
2727		return -EINVAL;
2728	}
2729
2730	num_blks = 0;
2731	for (i = 0; i < num_eps; i++) {
2732		ep = &opts->eps[i]->info;
2733		if (!(ep->protocol_caps & ep->protocol)) {
2734			pr_err("f_midi2: Invalid protocol 0x%x (caps 0x%x) for EP %d\n",
2735			       ep->protocol, ep->protocol_caps, i);
2736			return -EINVAL;
2737		}
2738
2739		for (j = 0; j < SNDRV_UMP_MAX_BLOCKS && opts->eps[i]->blks[j];
2740		     j++, num_blks++) {
2741			bp = &opts->eps[i]->blks[j]->info;
2742			if (bp->first_group + bp->num_groups > SNDRV_UMP_MAX_GROUPS) {
2743				pr_err("f_midi2: Invalid group definitions for block %d:%d\n",
2744				       i, j);
2745				return -EINVAL;
2746			}
2747
2748			if (bp->midi1_num_groups) {
2749				if (bp->midi1_first_group < bp->first_group ||
2750				    bp->midi1_first_group + bp->midi1_num_groups >
2751				    bp->first_group + bp->num_groups) {
2752					pr_err("f_midi2: Invalid MIDI1 group definitions for block %d:%d\n",
2753					       i, j);
2754					return -EINVAL;
2755				}
2756			}
2757		}
2758	}
2759	if (!num_blks) {
2760		pr_err("f_midi2: No block is defined\n");
2761		return -EINVAL;
2762	}
2763
2764	return num_eps;
2765}
2766
2767/* fill mapping between MIDI 1.0 cable and UMP EP/group */
2768static void fill_midi1_cable_mapping(struct f_midi2 *midi2,
2769				     struct f_midi2_ep *ep,
2770				     int blk)
2771{
2772	const struct f_midi2_block_info *binfo = &ep->blks[blk].info;
2773	struct midi1_cable_mapping *map;
2774	int i, group;
2775
2776	if (!binfo->midi1_num_groups)
2777		return;
2778	if (binfo->direction != SNDRV_UMP_DIR_OUTPUT) {
2779		group = binfo->midi1_first_group;
2780		map = midi2->in_cable_mapping + midi2->num_midi1_in;
2781		for (i = 0; i < binfo->midi1_num_groups; i++, group++, map++) {
2782			if (midi2->num_midi1_in >= MAX_CABLES)
2783				break;
2784			map->ep = ep;
2785			map->block = blk;
2786			map->group = group;
2787			midi2->num_midi1_in++;
2788			/* store 1-based cable number */
2789			ep->in_group_to_cable[group] = midi2->num_midi1_in;
2790		}
2791	}
2792
2793	if (binfo->direction != SNDRV_UMP_DIR_INPUT) {
2794		group = binfo->midi1_first_group;
2795		map = midi2->out_cable_mapping + midi2->num_midi1_out;
2796		for (i = 0; i < binfo->midi1_num_groups; i++, group++, map++) {
2797			if (midi2->num_midi1_out >= MAX_CABLES)
2798				break;
2799			map->ep = ep;
2800			map->block = blk;
2801			map->group = group;
2802			midi2->num_midi1_out++;
2803		}
2804	}
2805}
2806
2807/* gadget alloc callback */
2808static struct usb_function *f_midi2_alloc(struct usb_function_instance *fi)
2809{
2810	struct f_midi2 *midi2;
2811	struct f_midi2_opts *opts;
2812	struct f_midi2_ep *ep;
2813	struct f_midi2_block *bp;
2814	int i, num_eps, blk;
2815
2816	midi2 = kzalloc(sizeof(*midi2), GFP_KERNEL);
2817	if (!midi2)
2818		return ERR_PTR(-ENOMEM);
2819
2820	opts = container_of(fi, struct f_midi2_opts, func_inst);
2821	mutex_lock(&opts->lock);
2822	num_eps = verify_parameters(opts);
2823	if (num_eps < 0) {
2824		mutex_unlock(&opts->lock);
2825		kfree(midi2);
2826		return ERR_PTR(num_eps);
2827	}
2828	++opts->refcnt;
2829	mutex_unlock(&opts->lock);
2830
2831	spin_lock_init(&midi2->queue_lock);
2832
2833	midi2->func.name = "midi2_func";
2834	midi2->func.bind = f_midi2_bind;
2835	midi2->func.unbind = f_midi2_unbind;
2836	midi2->func.get_alt = f_midi2_get_alt;
2837	midi2->func.set_alt = f_midi2_set_alt;
2838	midi2->func.setup = f_midi2_setup;
2839	midi2->func.disable = f_midi2_disable;
2840	midi2->func.free_func = f_midi2_free;
2841
2842	midi2->info = opts->info;
2843	midi2->num_eps = num_eps;
2844
2845	for (i = 0; i < num_eps; i++) {
2846		ep = &midi2->midi2_eps[i];
2847		ep->info = opts->eps[i]->info;
2848		ep->card = midi2;
2849		for (blk = 0; blk < SNDRV_UMP_MAX_BLOCKS &&
2850			     opts->eps[i]->blks[blk]; blk++) {
2851			bp = &ep->blks[blk];
2852			ep->num_blks++;
2853			bp->info = opts->eps[i]->blks[blk]->info;
2854			bp->gtb_id = ++midi2->total_blocks;
2855		}
2856	}
2857
2858	midi2->string_defs = kcalloc(midi2->total_blocks + 1,
2859				     sizeof(*midi2->string_defs), GFP_KERNEL);
2860	if (!midi2->string_defs) {
2861		do_f_midi2_free(midi2, opts);
2862		return ERR_PTR(-ENOMEM);
2863	}
2864
2865	if (opts->info.iface_name && *opts->info.iface_name)
2866		midi2->string_defs[STR_IFACE].s = opts->info.iface_name;
2867	else
2868		midi2->string_defs[STR_IFACE].s = ump_ep_name(&midi2->midi2_eps[0]);
2869
2870	for (i = 0; i < midi2->num_eps; i++) {
2871		ep = &midi2->midi2_eps[i];
2872		for (blk = 0; blk < ep->num_blks; blk++) {
2873			bp = &ep->blks[blk];
2874			midi2->string_defs[gtb_to_str_id(bp->gtb_id)].s =
2875				ump_fb_name(&bp->info);
2876
2877			fill_midi1_cable_mapping(midi2, ep, blk);
2878		}
2879	}
2880
2881	if (!midi2->num_midi1_in && !midi2->num_midi1_out) {
2882		pr_err("f_midi2: MIDI1 definition is missing\n");
2883		do_f_midi2_free(midi2, opts);
2884		return ERR_PTR(-EINVAL);
2885	}
2886
2887	return &midi2->func;
2888}
2889
2890DECLARE_USB_FUNCTION_INIT(midi2, f_midi2_alloc_inst, f_midi2_alloc);
2891
2892MODULE_DESCRIPTION("USB MIDI 2.0 class function driver");
2893MODULE_LICENSE("GPL");