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(addr: &usb_ep->free_reqs, size: 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(nr: index, addr: &usb_ep->free_reqs);
399	req->length = 0;
400	unlock:
401	spin_unlock_irqrestore(lock: &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(nr: ctx->index, addr: &ctx->usb_ep->free_reqs);
413	spin_unlock_irqrestore(lock: &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(ep: 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(buf: (u32 *)req->buf, words: 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, buf: &rep, len: 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_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, buf: &rep, len: 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(status: type, form: 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, name: ump_ep_name(ep),
550	type: UMP_STREAM_MSG_STATUS_EP_NAME, extra: 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, name: ump_product_id(ep),
558	type: UMP_STREAM_MSG_STATUS_PRODUCT_ID, extra: 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, buf: &rep, len: 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, buf: &rep, len: 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, name: ump_fb_name(info: &ep->blks[blk].info),
603	type: UMP_STREAM_MSG_STATUS_FB_NAME, extra: 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: *data);
614	status = ump_stream_message_status(data: *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(ump: 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(ump: ep->ump, val: *data) <= 0)
673	continue;
674	if (ump_message_type(data: *in_buf) == UMP_MSG_TYPE_STREAM)
675	process_ump_stream_msg(ep, data: 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(buf: (u32 *)req->buf, words: req->actual >> 2);
700
701	if (midi2->info.process_ump)
702	process_ump(ep, req);
703
704	snd_ump_receive(ump: ep->ump, buffer: req->buf, count: 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(ump: ep->ump, buffer: (u32 *)req->buf,
733	count: 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, b: 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_p: &req))
1004	continue;
1005
1006	len = snd_ump_transmit(ump: ep->ump, buffer: &ump, count: 4);
1007	if (len <= 0)
1008	break;
1009	if (snd_ump_receive_ump_val(ump: ep->ump, val: ump) <= 0)
1010	continue;
1011	size = snd_ump_convert_from_ump(data: ep->ump->input_buf, dst: outbuf,
1012	group_ret: &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, buf: 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	c: buf[c + 1]);
1082	if (cvt->ump_bytes) {
1083	snd_ump_receive(ump: ep->ump, buffer: cvt->ump,
1084	count: 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(ep: usb_ep->usb_ep);
1115	err = config_ep_by_speed(g: usb_ep->card->gadget, f: fn, ep: usb_ep->usb_ep);
1116	if (err)
1117	return err;
1118	return usb_ep_enable(ep: 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(ep: usb_ep->usb_ep, req: usb_ep->reqs[i].req);
1132	set_bit(nr: i, addr: &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(ep: usb_ep->usb_ep,
1152	len: 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(ep: usb_ep->usb_ep, req: 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(nr: i, addr: &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(objp: 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(ep: usb_ep->usb_ep, req: usb_ep->reqs[i].req,
1230	GFP_ATOMIC);
1231	if (!err)
1232	clear_bit(nr: i, addr: &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(usb_ep: ep_in);
1245	f_midi2_drop_reqs(usb_ep: ep_out);
1246	f_midi2_free_ep_reqs(usb_ep: ep_in);
1247	f_midi2_free_ep_reqs(usb_ep: 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(usb_ep: ep_in, fn);
1258	if (err)
1259	return err;
1260	err = f_midi2_start_ep(usb_ep: ep_out, fn);
1261	if (err)
1262	return err;
1263
1264	err = f_midi2_alloc_ep_reqs(usb_ep: ep_in);
1265	if (err)
1266	return err;
1267	err = f_midi2_alloc_ep_reqs(usb_ep: ep_out);
1268	if (err)
1269	return err;
1270
1271	f_midi2_queue_out_reqs(usb_ep: 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(ep_in: &midi2->midi1_ep_in, ep_out: &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_in: &ep->ep_in, ep_out: &ep->ep_out);
1303	}
1304	}
1305
1306	if (op_mode == MIDI_OP_MODE_MIDI1)
1307	return f_midi2_start_eps(ep_in: &midi2->midi1_ep_in,
1308	ep_out: &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_in: &ep->ep_in, ep_out: &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(ump_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, max_len: length);
1430	return usb_ep_queue(ep: 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(card: 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(parent: &midi2->gadget->dev, idx: -1, NULL, THIS_MODULE, extra_size: 0,
1540	card_ret: &card);
1541	if (err < 0)
1542	return err;
1543	midi2->card = card;
1544
1545	strcpy(p: card->driver, q: "f_midi2");
1546	strcpy(p: card->shortname, q: "MIDI 2.0 Gadget");
1547	strcpy(p: card->longname, q: "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, id: "MIDI 2.0 Gadget", device: id,
1553	output: 1, input: 1, ump_ret: &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	direction: reverse_dir(dir: b->direction),
1585	first_group: b->first_group, num_groups: b->num_groups,
1586	blk_ret: &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(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(ump: midi2->midi2_eps[i].ump,
1607	id: "Legacy MIDI", device: id);
1608	if (err < 0)
1609	goto error;
1610	id++;
1611	}
1612
1613	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &operation_mode_ctl, private_data: 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	*/
1631	struct 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
1642	static 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
1662	static 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: *d);
1668	if (err)
1669	return err;
1670	}
1671	return 0;
1672	}
1673
1674	static 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, d: jack);
1694	if (err < 0)
1695	return err;
1696	return id;
1697	}
1698
1699	static 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, d: jack);
1722	if (err < 0)
1723	return err;
1724	return id;
1725	}
1726
1727	static 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, d: 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, d: 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	map: &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	map: &midi2->in_cable_mapping[i],
1796	USB_MS_EXTERNAL, source: 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	map: &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	map: &midi2->out_cable_mapping[i],
1818	USB_MS_EMBEDDED, source: 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, d: midi1_out_eps);
1829	if (err < 0)
1830	return err;
1831	}
1832	if (midi2->num_midi1_in) {
1833	err = append_configs(config, d: midi1_in_eps);
1834	if (err < 0)
1835	return err;
1836	}
1837
1838	err = append_configs(config, d: 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, d: &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, d: &midi2_midi2_ep_out_ss_comp_desc);
1848	if (err < 0)
1849	return err;
1850	}
1851	err = append_config(config, d: &midi2_midi2_ep_out_class_desc[i]);
1852	if (err < 0)
1853	return err;
1854	err = append_config(config, d: &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, d: &midi2_midi2_ep_in_ss_comp_desc);
1859	if (err < 0)
1860	return err;
1861	}
1862	err = append_config(config, d: &midi2_midi2_ep_in_class_desc[i]);
1863	if (err < 0)
1864	return err;
1865	}
1866
1867	return 0;
1868	}
1869
1870	static void f_midi2_free_usb_configs(struct f_midi2_usb_config *config)
1871	{
1872	kfree(objp: config->list);
1873	memset(config, 0, sizeof(*config));
1874	}
1875
1876	/* as we use the static descriptors for simplicity, serialize bind call */
1877	static DEFINE_MUTEX(f_midi2_desc_mutex);
1878
1879	/* fill MIDI2 EP class-specific descriptor */
1880	static 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 */
1894	static 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, cdesc: &midi2_midi2_ep_in_class_desc[index]);
1907
1908	return f_midi2_init_ep(midi2, ep, usb_ep: &ep->ep_in, desc,
1909	complete: f_midi2_ep_in_complete);
1910	}
1911
1912	/* initialize MIDI2 EP-out */
1913	static 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, cdesc: &midi2_midi2_ep_out_class_desc[index]);
1924
1925	return f_midi2_init_ep(midi2, ep, usb_ep: &ep->ep_out, desc,
1926	complete: f_midi2_ep_out_complete);
1927	}
1928
1929	/* gadget function bind callback */
1930	static 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(cdev: c->cdev, sp: strings,
1955	n_strings: midi2->total_blocks + 1);
1956	if (IS_ERR(ptr: midi2->strings)) {
1957	status = PTR_ERR(ptr: 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, usb_ep: &midi2->midi1_ep_in,
1991	desc: &midi2_midi1_ep_in_desc,
1992	complete: 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, usb_ep: &midi2->midi1_ep_out,
1999	desc: &midi2_midi1_ep_out_desc,
2000	complete: 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, index: i);
2007	if (status)
2008	goto fail;
2009	status = f_midi2_init_midi2_ep_out(midi2, index: i);
2010	if (status)
2011	goto fail;
2012	}
2013
2014	status = f_midi2_create_usb_configs(midi2, config: &config, speed: 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: &config);
2023
2024	status = f_midi2_create_usb_configs(midi2, config: &config, speed: 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: &config);
2033
2034	status = f_midi2_create_usb_configs(midi2, config: &config, speed: 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: &config);
2043
2044	mutex_unlock(lock: &f_midi2_desc_mutex);
2045	return 0;
2046
2047	fail:
2048	f_midi2_free_usb_configs(config: &config);
2049	mutex_unlock(lock: &f_midi2_desc_mutex);
2050	usb_free_all_descriptors(f);
2051	fail_string:
2052	f_midi2_free_card(midi2);
2053	fail_register:
2054	ERROR(midi2, "%s: can't bind, err %d\n", f->name, status);
2055	return status;
2056	}
2057
2058	/* gadget function unbind callback */
2059	static 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(usb_ep: &midi2->midi1_ep_in);
2067	f_midi2_free_ep(usb_ep: &midi2->midi1_ep_out);
2068	for (i = 0; i < midi2->num_eps; i++) {
2069	f_midi2_free_ep(usb_ep: &midi2->midi2_eps[i].ep_in);
2070	f_midi2_free_ep(usb_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 */
2081	static 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
2087	static inline struct f_midi2_ep_opts *
2088	to_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
2094	static inline struct f_midi2_block_opts *
2095	to_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 */
2102	static 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 */
2116	static 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(buf: page, fmt: format, val);
2123	mutex_unlock(lock: &opts->lock);
2124	return result;
2125	}
2126
2127	static 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(s: page, base: 0, res: &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
2151	end:
2152	mutex_unlock(lock: &opts->lock);
2153	return ret;
2154	}
2155
2156	/* generic store for bool */
2157	static 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(s: page, res: &val);
2170	if (ret)
2171	goto end;
2172	*valp = val;
2173	ret = len;
2174
2175	end:
2176	mutex_unlock(lock: &opts->lock);
2177	return ret;
2178	}
2179
2180	/* generic show/store for string */
2181	static 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(buf: page, PAGE_SIZE, fmt: "%s\n", str);
2189	mutex_unlock(lock: &opts->lock);
2190	return result;
2191	}
2192
2193	static 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(s: page, min(len, maxlen), GFP_KERNEL);
2207	if (!c) {
2208	ret = -ENOMEM;
2209	goto end;
2210	}
2211
2212	kfree(objp: *strp);
2213	make_name_string(s: c);
2214	*strp = c;
2215	ret = len;
2216
2217	end:
2218	mutex_unlock(lock: &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) \
2228	static 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	\
2236	static 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	\
2244	CONFIGFS_ATTR(f_midi2_block_opts_, name)
2245
2246	/* define a boolean option for block */
2247	#define F_MIDI2_BLOCK_BOOL_OPT(name) \
2248	static 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	\
2256	static 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	\
2264	CONFIGFS_ATTR(f_midi2_block_opts_, name)
2265
2266	F_MIDI2_BLOCK_OPT(direction, "0x%x", 1, 3);
2267	F_MIDI2_BLOCK_OPT(first_group, "0x%x", 0, 15);
2268	F_MIDI2_BLOCK_OPT(num_groups, "0x%x", 1, 16);
2269	F_MIDI2_BLOCK_OPT(midi1_first_group, "0x%x", 0, 15);
2270	F_MIDI2_BLOCK_OPT(midi1_num_groups, "0x%x", 0, 16);
2271	F_MIDI2_BLOCK_OPT(ui_hint, "0x%x", 0, 3);
2272	F_MIDI2_BLOCK_OPT(midi_ci_version, "%u", 0, 1);
2273	F_MIDI2_BLOCK_OPT(sysex8_streams, "%u", 0, 255);
2274	F_MIDI2_BLOCK_OPT(is_midi1, "%u", 0, 2);
2275	F_MIDI2_BLOCK_BOOL_OPT(active);
2276
2277	static 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: opts->ep->opts, str: opts->info.name, page);
2283	}
2284
2285	static 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: opts->ep->opts, strp: &opts->info.name, maxlen: 128,
2291	page, len);
2292	}
2293
2294	CONFIGFS_ATTR(f_midi2_block_opts_, name);
2295
2296	static 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
2311	static 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(objp: opts->info.name);
2316	kfree(objp: opts);
2317	}
2318
2319	static struct configfs_item_operations f_midi2_block_item_ops = {
2320	.release = f_midi2_block_opts_release,
2321	};
2322
2323	static 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 */
2330	static 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(lock: &ep_opts->opts->lock);
2364	return ret;
2365	}
2366
2367	/* make_group callback for a block */
2368	static struct config_group *
2369	f_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(error: -EINVAL);
2378	ret = kstrtouint(s: name + 6, base: 10, res: &blk);
2379	if (ret)
2380	return ERR_PTR(error: ret);
2381
2382	ep_opts = to_f_midi2_ep_opts(item: &group->cg_item);
2383
2384	if (blk >= SNDRV_UMP_MAX_BLOCKS)
2385	return ERR_PTR(error: -EINVAL);
2386	if (ep_opts->blks[blk])
2387	return ERR_PTR(error: -EBUSY);
2388	ret = f_midi2_block_opts_create(ep_opts, blk, block_p: &block_opts);
2389	if (ret)
2390	return ERR_PTR(error: ret);
2391
2392	config_group_init_type_name(group: &block_opts->group, name,
2393	type: &f_midi2_block_type);
2394	return &block_opts->group;
2395	}
2396
2397	/* drop_item callback for a block */
2398	static void
2399	f_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(lock: &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) \
2415	static 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	\
2423	static 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	\
2431	CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2432
2433	/* define a string option for EP */
2434	#define F_MIDI2_EP_STR_OPT(name, maxlen) \
2435	static 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	\
2442	static 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	\
2450	CONFIGFS_ATTR(f_midi2_ep_opts_, name)
2451
2452	F_MIDI2_EP_OPT(protocol, "0x%x", 1, 2);
2453	F_MIDI2_EP_OPT(protocol_caps, "0x%x", 1, 3);
2454	F_MIDI2_EP_OPT(manufacturer, "0x%x", 0, 0xffffff);
2455	F_MIDI2_EP_OPT(family, "0x%x", 0, 0xffff);
2456	F_MIDI2_EP_OPT(model, "0x%x", 0, 0xffff);
2457	F_MIDI2_EP_OPT(sw_revision, "0x%x", 0, 0xffffffff);
2458	F_MIDI2_EP_STR_OPT(ep_name, 128);
2459	F_MIDI2_EP_STR_OPT(product_id, 128);
2460
2461	static 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
2473	static 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(objp: opts->info.ep_name);
2478	kfree(objp: opts->info.product_id);
2479	kfree(objp: opts);
2480	}
2481
2482	static struct configfs_item_operations f_midi2_ep_item_ops = {
2483	.release = f_midi2_ep_opts_release,
2484	};
2485
2486	static 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
2491	static 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 */
2499	static 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 */
2522	static struct config_group *
2523	f_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(error: -EINVAL);
2532	ret = kstrtouint(s: name + 3, base: 10, res: &index);
2533	if (ret)
2534	return ERR_PTR(error: ret);
2535
2536	opts = to_f_midi2_opts(item: &group->cg_item);
2537	if (index >= MAX_UMP_EPS)
2538	return ERR_PTR(error: -EINVAL);
2539	if (opts->eps[index])
2540	return ERR_PTR(error: -EBUSY);
2541	ret = f_midi2_ep_opts_create(opts, index, ep_p: &ep_opts);
2542	if (ret)
2543	return ERR_PTR(error: ret);
2544
2545	config_group_init_type_name(group: &ep_opts->group, name, type: &f_midi2_ep_type);
2546	return &ep_opts->group;
2547	}
2548
2549	/* drop_item callback for an EP */
2550	static void
2551	f_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(lock: &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) \
2567	static 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	\
2575	static 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	\
2583	CONFIGFS_ATTR(f_midi2_opts_, name)
2584
2585	F_MIDI2_BOOL_OPT(process_ump);
2586	F_MIDI2_BOOL_OPT(static_block);
2587
2588	static 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, str: opts->info.iface_name, page);
2594	}
2595
2596	static 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, strp: &opts->info.iface_name, maxlen: 128,
2602	page, len);
2603	}
2604
2605	CONFIGFS_ATTR(f_midi2_opts_, iface_name);
2606
2607	static 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
2614	static 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(fi: &opts->func_inst);
2619	}
2620
2621	static struct configfs_item_operations f_midi2_item_ops = {
2622	.release = f_midi2_opts_release,
2623	};
2624
2625	static 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
2630	static 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
2637	static 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(objp: opts->info.iface_name);
2644	kfree(objp: opts);
2645	}
2646
2647	/* gadget alloc_inst */
2648	static 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(error: -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, index: 0, ep_p: &ep_opts);
2668	if (ret) {
2669	kfree(objp: opts);
2670	return ERR_PTR(error: ret);
2671	}
2672
2673	/* create the default block */
2674	ret = f_midi2_block_opts_create(ep_opts, blk: 0, block_p: &block_opts);
2675	if (ret) {
2676	kfree(objp: ep_opts);
2677	kfree(objp: opts);
2678	return ERR_PTR(error: 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(group: &opts->func_inst.group, name: "",
2685	type: &f_midi2_func_type);
2686
2687	config_group_init_type_name(group: &ep_opts->group, name: "ep.0",
2688	type: &f_midi2_ep_type);
2689	configfs_add_default_group(new_group: &ep_opts->group, group: &opts->func_inst.group);
2690
2691	config_group_init_type_name(group: &block_opts->group, name: "block.0",
2692	type: &f_midi2_block_type);
2693	configfs_add_default_group(new_group: &block_opts->group, group: &ep_opts->group);
2694
2695	return &opts->func_inst;
2696	}
2697
2698	static 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(lock: &opts->lock);
2703	kfree(objp: midi2->string_defs);
2704	kfree(objp: midi2);
2705	}
2706
2707	static 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	*/
2716	static 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 */
2768	static 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 */
2808	static 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(error: -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(lock: &opts->lock);
2825	kfree(objp: midi2);
2826	return ERR_PTR(error: num_eps);
2827	}
2828	++opts->refcnt;
2829	mutex_unlock(lock: &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(error: -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(ep: &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(info: &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(error: -EINVAL);
2885	}
2886
2887	return &midi2->func;
2888	}
2889
2890	DECLARE_USB_FUNCTION_INIT(midi2, f_midi2_alloc_inst, f_midi2_alloc);
2891
2892	MODULE_DESCRIPTION("USB MIDI 2.0 class function driver");
2893	MODULE_LICENSE("GPL");
2894