f_midi.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * f_midi.c -- USB MIDI class function driver
   4 *
   5 * Copyright (C) 2006 Thumtronics Pty Ltd.
   6 * Developed for Thumtronics by Grey Innovation
   7 * Ben Williamson <ben.williamson@greyinnovation.com>
   8 *
   9 * Rewritten for the composite framework
  10 *   Copyright (C) 2011 Daniel Mack <zonque@gmail.com>
  11 *
  12 * Based on drivers/usb/gadget/f_audio.c,
  13 *   Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
  14 *   Copyright (C) 2008 Analog Devices, Inc
  15 *
  16 * and drivers/usb/gadget/midi.c,
  17 *   Copyright (C) 2006 Thumtronics Pty Ltd.
  18 *   Ben Williamson <ben.williamson@greyinnovation.com>
  19 */
  20
  21#include <linux/kernel.h>
  22#include <linux/module.h>
  23#include <linux/slab.h>
  24#include <linux/device.h>
  25#include <linux/kfifo.h>
  26#include <linux/spinlock.h>
  27
  28#include <sound/core.h>
  29#include <sound/initval.h>
  30#include <sound/rawmidi.h>
  31
  32#include <linux/usb/ch9.h>
  33#include <linux/usb/func_utils.h>
  34#include <linux/usb/gadget.h>
  35#include <linux/usb/audio.h>
  36#include <linux/usb/midi.h>
  37
  38#include "u_midi.h"
  39
  40MODULE_AUTHOR("Ben Williamson");
  41MODULE_DESCRIPTION("USB MIDI class function driver");
  42MODULE_LICENSE("GPL v2");
  43
  44static const char f_midi_shortname[] = "f_midi";
  45static const char f_midi_longname[] = "MIDI Gadget";
  46
  47/*
  48 * We can only handle 16 cables on one single endpoint, as cable numbers are
  49 * stored in 4-bit fields. And as the interface currently only holds one
  50 * single endpoint, this is the maximum number of ports we can allow.
  51 */
  52#define MAX_PORTS 16
  53
  54/* MIDI message states */
  55enum {
  56	STATE_INITIAL = 0,	/* pseudo state */
  57	STATE_1PARAM,
  58	STATE_2PARAM_1,
  59	STATE_2PARAM_2,
  60	STATE_SYSEX_0,
  61	STATE_SYSEX_1,
  62	STATE_SYSEX_2,
  63	STATE_REAL_TIME,
  64	STATE_FINISHED,		/* pseudo state */
  65};
  66
  67/*
  68 * This is a gadget, and the IN/OUT naming is from the host's perspective.
  69 * USB -> OUT endpoint -> rawmidi
  70 * USB <- IN endpoint  <- rawmidi
  71 */
  72struct gmidi_in_port {
  73	struct snd_rawmidi_substream *substream;
  74	int active;
  75	uint8_t cable;
  76	uint8_t state;
  77	uint8_t data[2];
  78};
  79
  80struct f_midi {
  81	struct usb_function	func;
  82	struct usb_gadget	*gadget;
  83	struct usb_ep		*in_ep, *out_ep;
  84	struct snd_card		*card;
  85	struct snd_rawmidi	*rmidi;
  86	u8			ms_id;
  87
  88	struct snd_rawmidi_substream *out_substream[MAX_PORTS];
  89
  90	unsigned long		out_triggered;
  91	struct work_struct	work;
  92	unsigned int in_ports;
  93	unsigned int out_ports;
  94	int index;
  95	char *id;
  96	unsigned int buflen, qlen;
  97	/* This fifo is used as a buffer ring for pre-allocated IN usb_requests */
  98	DECLARE_KFIFO_PTR(in_req_fifo, struct usb_request *);
  99	spinlock_t transmit_lock;
 100	unsigned int in_last_port;
 101	unsigned char free_ref;
 102
 103	struct gmidi_in_port	in_ports_array[] __counted_by(in_ports);
 104};
 105
 106static inline struct f_midi *func_to_midi(struct usb_function *f)
 107{
 108	return container_of(f, struct f_midi, func);
 109}
 110
 111static void f_midi_transmit(struct f_midi *midi);
 112static void f_midi_rmidi_free(struct snd_rawmidi *rmidi);
 113static void f_midi_free_inst(struct usb_function_instance *f);
 114
 115DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
 116DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
 117DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(16);
 118
 119/* B.3.1  Standard AC Interface Descriptor */
 120static struct usb_interface_descriptor ac_interface_desc = {
 121	.bLength =		USB_DT_INTERFACE_SIZE,
 122	.bDescriptorType =	USB_DT_INTERFACE,
 123	/* .bInterfaceNumber =	DYNAMIC */
 124	/* .bNumEndpoints =	DYNAMIC */
 125	.bInterfaceClass =	USB_CLASS_AUDIO,
 126	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOCONTROL,
 127	/* .iInterface =	DYNAMIC */
 128};
 129
 130/* B.3.2  Class-Specific AC Interface Descriptor */
 131static struct uac1_ac_header_descriptor_1 ac_header_desc = {
 132	.bLength =		UAC_DT_AC_HEADER_SIZE(1),
 133	.bDescriptorType =	USB_DT_CS_INTERFACE,
 134	.bDescriptorSubtype =	USB_MS_HEADER,
 135	.bcdADC =		cpu_to_le16(0x0100),
 136	.wTotalLength =		cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
 137	.bInCollection =	1,
 138	/* .baInterfaceNr =	DYNAMIC */
 139};
 140
 141/* B.4.1  Standard MS Interface Descriptor */
 142static struct usb_interface_descriptor ms_interface_desc = {
 143	.bLength =		USB_DT_INTERFACE_SIZE,
 144	.bDescriptorType =	USB_DT_INTERFACE,
 145	/* .bInterfaceNumber =	DYNAMIC */
 146	.bNumEndpoints =	2,
 147	.bInterfaceClass =	USB_CLASS_AUDIO,
 148	.bInterfaceSubClass =	USB_SUBCLASS_MIDISTREAMING,
 149	/* .iInterface =	DYNAMIC */
 150};
 151
 152/* B.4.2  Class-Specific MS Interface Descriptor */
 153static struct usb_ms_header_descriptor ms_header_desc = {
 154	.bLength =		USB_DT_MS_HEADER_SIZE,
 155	.bDescriptorType =	USB_DT_CS_INTERFACE,
 156	.bDescriptorSubtype =	USB_MS_HEADER,
 157	.bcdMSC =		cpu_to_le16(0x0100),
 158	/* .wTotalLength =	DYNAMIC */
 159};
 160
 161/* B.5.1  Standard Bulk OUT Endpoint Descriptor */
 162static struct usb_endpoint_descriptor bulk_out_desc = {
 163	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 164	.bDescriptorType =	USB_DT_ENDPOINT,
 165	.bEndpointAddress =	USB_DIR_OUT,
 166	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 167};
 168
 169static struct usb_ss_ep_comp_descriptor bulk_out_ss_comp_desc = {
 170	.bLength                = sizeof(bulk_out_ss_comp_desc),
 171	.bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 172	/* .bMaxBurst           = 0, */
 173	/* .bmAttributes        = 0, */
 174};
 175
 176/* B.5.2  Class-specific MS Bulk OUT Endpoint Descriptor */
 177static struct usb_ms_endpoint_descriptor_16 ms_out_desc = {
 178	/* .bLength =		DYNAMIC */
 179	.bDescriptorType =	USB_DT_CS_ENDPOINT,
 180	.bDescriptorSubtype =	USB_MS_GENERAL,
 181	/* .bNumEmbMIDIJack =	DYNAMIC */
 182	/* .baAssocJackID =	DYNAMIC */
 183};
 184
 185/* B.6.1  Standard Bulk IN Endpoint Descriptor */
 186static struct usb_endpoint_descriptor bulk_in_desc = {
 187	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 188	.bDescriptorType =	USB_DT_ENDPOINT,
 189	.bEndpointAddress =	USB_DIR_IN,
 190	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 191};
 192
 193static struct usb_ss_ep_comp_descriptor bulk_in_ss_comp_desc = {
 194	.bLength                = sizeof(bulk_in_ss_comp_desc),
 195	.bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
 196	/* .bMaxBurst           = 0, */
 197	/* .bmAttributes        = 0, */
 198};
 199
 200/* B.6.2  Class-specific MS Bulk IN Endpoint Descriptor */
 201static struct usb_ms_endpoint_descriptor_16 ms_in_desc = {
 202	/* .bLength =		DYNAMIC */
 203	.bDescriptorType =	USB_DT_CS_ENDPOINT,
 204	.bDescriptorSubtype =	USB_MS_GENERAL,
 205	/* .bNumEmbMIDIJack =	DYNAMIC */
 206	/* .baAssocJackID =	DYNAMIC */
 207};
 208
 209/* string IDs are assigned dynamically */
 210
 211#define STRING_FUNC_IDX			0
 212
 213static struct usb_string midi_string_defs[] = {
 214	[STRING_FUNC_IDX].s = "MIDI function",
 215	{  } /* end of list */
 216};
 217
 218static struct usb_gadget_strings midi_stringtab = {
 219	.language	= 0x0409,	/* en-us */
 220	.strings	= midi_string_defs,
 221};
 222
 223static struct usb_gadget_strings *midi_strings[] = {
 224	&midi_stringtab,
 225	NULL,
 226};
 227
 228static inline struct usb_request *midi_alloc_ep_req(struct usb_ep *ep,
 229						    unsigned length)
 230{
 231	return alloc_ep_req(ep, length);
 232}
 233
 234static const uint8_t f_midi_cin_length[] = {
 235	0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
 236};
 237
 238/*
 239 * Receives a chunk of MIDI data.
 240 */
 241static void f_midi_read_data(struct usb_ep *ep, int cable,
 242			     uint8_t *data, int length)
 243{
 244	struct f_midi *midi = ep->driver_data;
 245	struct snd_rawmidi_substream *substream = midi->out_substream[cable];
 246
 247	if (!substream)
 248		/* Nobody is listening - throw it on the floor. */
 249		return;
 250
 251	if (!test_bit(cable, &midi->out_triggered))
 252		return;
 253
 254	snd_rawmidi_receive(substream, data, length);
 255}
 256
 257static void f_midi_handle_out_data(struct usb_ep *ep, struct usb_request *req)
 258{
 259	unsigned int i;
 260	u8 *buf = req->buf;
 261
 262	for (i = 0; i + 3 < req->actual; i += 4)
 263		if (buf[i] != 0) {
 264			int cable = buf[i] >> 4;
 265			int length = f_midi_cin_length[buf[i] & 0x0f];
 266			f_midi_read_data(ep, cable, &buf[i + 1], length);
 267		}
 268}
 269
 270static void
 271f_midi_complete(struct usb_ep *ep, struct usb_request *req)
 272{
 273	struct f_midi *midi = ep->driver_data;
 274	struct usb_composite_dev *cdev = midi->func.config->cdev;
 275	int status = req->status;
 276
 277	switch (status) {
 278	case 0:			 /* normal completion */
 279		if (ep == midi->out_ep) {
 280			/* We received stuff. req is queued again, below */
 281			f_midi_handle_out_data(ep, req);
 282		} else if (ep == midi->in_ep) {
 283			/* Our transmit completed. See if there's more to go.
 284			 * f_midi_transmit eats req, don't queue it again. */
 285			req->length = 0;
 286			queue_work(system_highpri_wq, &midi->work);
 287			return;
 288		}
 289		break;
 290
 291	/* this endpoint is normally active while we're configured */
 292	case -ECONNABORTED:	/* hardware forced ep reset */
 293	case -ECONNRESET:	/* request dequeued */
 294	case -ESHUTDOWN:	/* disconnect from host */
 295		VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
 296				req->actual, req->length);
 297		if (ep == midi->out_ep) {
 298			f_midi_handle_out_data(ep, req);
 299			/* We don't need to free IN requests because it's handled
 300			 * by the midi->in_req_fifo. */
 301			free_ep_req(ep, req);
 302		}
 303		return;
 304
 305	case -EOVERFLOW:	/* buffer overrun on read means that
 306				 * we didn't provide a big enough buffer.
 307				 */
 308	default:
 309		DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
 310				status, req->actual, req->length);
 311		break;
 312	case -EREMOTEIO:	/* short read */
 313		break;
 314	}
 315
 316	status = usb_ep_queue(ep, req, GFP_ATOMIC);
 317	if (status) {
 318		ERROR(cdev, "kill %s:  resubmit %d bytes --> %d\n",
 319				ep->name, req->length, status);
 320		usb_ep_set_halt(ep);
 321		/* FIXME recover later ... somehow */
 322	}
 323}
 324
 325static void f_midi_drop_out_substreams(struct f_midi *midi)
 326{
 327	unsigned int i;
 328
 329	for (i = 0; i < midi->in_ports; i++) {
 330		struct gmidi_in_port *port = midi->in_ports_array + i;
 331		struct snd_rawmidi_substream *substream = port->substream;
 332
 333		if (port->active && substream)
 334			snd_rawmidi_drop_output(substream);
 335	}
 336}
 337
 338static int f_midi_start_ep(struct f_midi *midi,
 339			   struct usb_function *f,
 340			   struct usb_ep *ep)
 341{
 342	int err;
 343	struct usb_composite_dev *cdev = f->config->cdev;
 344
 345	usb_ep_disable(ep);
 346
 347	err = config_ep_by_speed(midi->gadget, f, ep);
 348	if (err) {
 349		ERROR(cdev, "can't configure %s: %d\n", ep->name, err);
 350		return err;
 351	}
 352
 353	err = usb_ep_enable(ep);
 354	if (err) {
 355		ERROR(cdev, "can't start %s: %d\n", ep->name, err);
 356		return err;
 357	}
 358
 359	ep->driver_data = midi;
 360
 361	return 0;
 362}
 363
 364static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 365{
 366	struct f_midi *midi = func_to_midi(f);
 367	unsigned i;
 368	int err;
 369
 370	/* we only set alt for MIDIStreaming interface */
 371	if (intf != midi->ms_id)
 372		return 0;
 373
 374	err = f_midi_start_ep(midi, f, midi->in_ep);
 375	if (err)
 376		return err;
 377
 378	err = f_midi_start_ep(midi, f, midi->out_ep);
 379	if (err)
 380		return err;
 381
 382	/* pre-allocate write usb requests to use on f_midi_transmit. */
 383	while (kfifo_avail(&midi->in_req_fifo)) {
 384		struct usb_request *req =
 385			midi_alloc_ep_req(midi->in_ep, midi->buflen);
 386
 387		if (req == NULL)
 388			return -ENOMEM;
 389
 390		req->length = 0;
 391		req->complete = f_midi_complete;
 392
 393		kfifo_put(&midi->in_req_fifo, req);
 394	}
 395
 396	/* allocate a bunch of read buffers and queue them all at once. */
 397	for (i = 0; i < midi->qlen && err == 0; i++) {
 398		struct usb_request *req =
 399			midi_alloc_ep_req(midi->out_ep, midi->buflen);
 400
 401		if (req == NULL)
 402			return -ENOMEM;
 403
 404		req->complete = f_midi_complete;
 405		err = usb_ep_queue(midi->out_ep, req, GFP_ATOMIC);
 406		if (err) {
 407			ERROR(midi, "%s: couldn't enqueue request: %d\n",
 408				    midi->out_ep->name, err);
 409			if (req->buf != NULL)
 410				free_ep_req(midi->out_ep, req);
 411			return err;
 412		}
 413	}
 414
 415	return 0;
 416}
 417
 418static void f_midi_disable(struct usb_function *f)
 419{
 420	struct f_midi *midi = func_to_midi(f);
 421	struct usb_composite_dev *cdev = f->config->cdev;
 422	struct usb_request *req = NULL;
 423
 424	DBG(cdev, "disable\n");
 425
 426	/*
 427	 * just disable endpoints, forcing completion of pending i/o.
 428	 * all our completion handlers free their requests in this case.
 429	 */
 430	usb_ep_disable(midi->in_ep);
 431	usb_ep_disable(midi->out_ep);
 432
 433	/* release IN requests */
 434	while (kfifo_get(&midi->in_req_fifo, &req))
 435		free_ep_req(midi->in_ep, req);
 436
 437	f_midi_drop_out_substreams(midi);
 438}
 439
 440static int f_midi_snd_free(struct snd_device *device)
 441{
 442	return 0;
 443}
 444
 445/*
 446 * Converts MIDI commands to USB MIDI packets.
 447 */
 448static void f_midi_transmit_byte(struct usb_request *req,
 449				 struct gmidi_in_port *port, uint8_t b)
 450{
 451	uint8_t p[4] = { port->cable << 4, 0, 0, 0 };
 452	uint8_t next_state = STATE_INITIAL;
 453
 454	switch (b) {
 455	case 0xf8 ... 0xff:
 456		/* System Real-Time Messages */
 457		p[0] |= 0x0f;
 458		p[1] = b;
 459		next_state = port->state;
 460		port->state = STATE_REAL_TIME;
 461		break;
 462
 463	case 0xf7:
 464		/* End of SysEx */
 465		switch (port->state) {
 466		case STATE_SYSEX_0:
 467			p[0] |= 0x05;
 468			p[1] = 0xf7;
 469			next_state = STATE_FINISHED;
 470			break;
 471		case STATE_SYSEX_1:
 472			p[0] |= 0x06;
 473			p[1] = port->data[0];
 474			p[2] = 0xf7;
 475			next_state = STATE_FINISHED;
 476			break;
 477		case STATE_SYSEX_2:
 478			p[0] |= 0x07;
 479			p[1] = port->data[0];
 480			p[2] = port->data[1];
 481			p[3] = 0xf7;
 482			next_state = STATE_FINISHED;
 483			break;
 484		default:
 485			/* Ignore byte */
 486			next_state = port->state;
 487			port->state = STATE_INITIAL;
 488		}
 489		break;
 490
 491	case 0xf0 ... 0xf6:
 492		/* System Common Messages */
 493		port->data[0] = port->data[1] = 0;
 494		port->state = STATE_INITIAL;
 495		switch (b) {
 496		case 0xf0:
 497			port->data[0] = b;
 498			port->data[1] = 0;
 499			next_state = STATE_SYSEX_1;
 500			break;
 501		case 0xf1:
 502		case 0xf3:
 503			port->data[0] = b;
 504			next_state = STATE_1PARAM;
 505			break;
 506		case 0xf2:
 507			port->data[0] = b;
 508			next_state = STATE_2PARAM_1;
 509			break;
 510		case 0xf4:
 511		case 0xf5:
 512			next_state = STATE_INITIAL;
 513			break;
 514		case 0xf6:
 515			p[0] |= 0x05;
 516			p[1] = 0xf6;
 517			next_state = STATE_FINISHED;
 518			break;
 519		}
 520		break;
 521
 522	case 0x80 ... 0xef:
 523		/*
 524		 * Channel Voice Messages, Channel Mode Messages
 525		 * and Control Change Messages.
 526		 */
 527		port->data[0] = b;
 528		port->data[1] = 0;
 529		port->state = STATE_INITIAL;
 530		if (b >= 0xc0 && b <= 0xdf)
 531			next_state = STATE_1PARAM;
 532		else
 533			next_state = STATE_2PARAM_1;
 534		break;
 535
 536	case 0x00 ... 0x7f:
 537		/* Message parameters */
 538		switch (port->state) {
 539		case STATE_1PARAM:
 540			if (port->data[0] < 0xf0)
 541				p[0] |= port->data[0] >> 4;
 542			else
 543				p[0] |= 0x02;
 544
 545			p[1] = port->data[0];
 546			p[2] = b;
 547			/* This is to allow Running State Messages */
 548			next_state = STATE_1PARAM;
 549			break;
 550		case STATE_2PARAM_1:
 551			port->data[1] = b;
 552			next_state = STATE_2PARAM_2;
 553			break;
 554		case STATE_2PARAM_2:
 555			if (port->data[0] < 0xf0)
 556				p[0] |= port->data[0] >> 4;
 557			else
 558				p[0] |= 0x03;
 559
 560			p[1] = port->data[0];
 561			p[2] = port->data[1];
 562			p[3] = b;
 563			/* This is to allow Running State Messages */
 564			next_state = STATE_2PARAM_1;
 565			break;
 566		case STATE_SYSEX_0:
 567			port->data[0] = b;
 568			next_state = STATE_SYSEX_1;
 569			break;
 570		case STATE_SYSEX_1:
 571			port->data[1] = b;
 572			next_state = STATE_SYSEX_2;
 573			break;
 574		case STATE_SYSEX_2:
 575			p[0] |= 0x04;
 576			p[1] = port->data[0];
 577			p[2] = port->data[1];
 578			p[3] = b;
 579			next_state = STATE_SYSEX_0;
 580			break;
 581		}
 582		break;
 583	}
 584
 585	/* States where we have to write into the USB request */
 586	if (next_state == STATE_FINISHED ||
 587	    port->state == STATE_SYSEX_2 ||
 588	    port->state == STATE_1PARAM ||
 589	    port->state == STATE_2PARAM_2 ||
 590	    port->state == STATE_REAL_TIME) {
 591
 592		unsigned int length = req->length;
 593		u8 *buf = (u8 *)req->buf + length;
 594
 595		memcpy(buf, p, sizeof(p));
 596		req->length = length + sizeof(p);
 597
 598		if (next_state == STATE_FINISHED) {
 599			next_state = STATE_INITIAL;
 600			port->data[0] = port->data[1] = 0;
 601		}
 602	}
 603
 604	port->state = next_state;
 605}
 606
 607static int f_midi_do_transmit(struct f_midi *midi, struct usb_ep *ep)
 608{
 609	struct usb_request *req = NULL;
 610	unsigned int len, i;
 611	bool active = false;
 612	int err;
 613
 614	/*
 615	 * We peek the request in order to reuse it if it fails to enqueue on
 616	 * its endpoint
 617	 */
 618	len = kfifo_peek(&midi->in_req_fifo, &req);
 619	if (len != 1) {
 620		ERROR(midi, "%s: Couldn't get usb request\n", __func__);
 621		return -1;
 622	}
 623
 624	/*
 625	 * If buffer overrun, then we ignore this transmission.
 626	 * IMPORTANT: This will cause the user-space rawmidi device to block
 627	 * until a) usb requests have been completed or b) snd_rawmidi_write()
 628	 * times out.
 629	 */
 630	if (req->length > 0)
 631		return 0;
 632
 633	for (i = midi->in_last_port; i < midi->in_ports; ++i) {
 634		struct gmidi_in_port *port = midi->in_ports_array + i;
 635		struct snd_rawmidi_substream *substream = port->substream;
 636
 637		if (!port->active || !substream)
 638			continue;
 639
 640		while (req->length + 3 < midi->buflen) {
 641			uint8_t b;
 642
 643			if (snd_rawmidi_transmit(substream, &b, 1) != 1) {
 644				port->active = 0;
 645				break;
 646			}
 647			f_midi_transmit_byte(req, port, b);
 648		}
 649
 650		active = !!port->active;
 651		if (active)
 652			break;
 653	}
 654	midi->in_last_port = active ? i : 0;
 655
 656	if (req->length <= 0)
 657		goto done;
 658
 659	err = usb_ep_queue(ep, req, GFP_ATOMIC);
 660	if (err < 0) {
 661		ERROR(midi, "%s failed to queue req: %d\n",
 662		      midi->in_ep->name, err);
 663		req->length = 0; /* Re-use request next time. */
 664	} else {
 665		/* Upon success, put request at the back of the queue. */
 666		kfifo_skip(&midi->in_req_fifo);
 667		kfifo_put(&midi->in_req_fifo, req);
 668	}
 669
 670done:
 671	return active;
 672}
 673
 674static void f_midi_transmit(struct f_midi *midi)
 675{
 676	struct usb_ep *ep = midi->in_ep;
 677	int ret;
 678	unsigned long flags;
 679
 680	/* We only care about USB requests if IN endpoint is enabled */
 681	if (!ep || !ep->enabled)
 682		goto drop_out;
 683
 684	spin_lock_irqsave(&midi->transmit_lock, flags);
 685
 686	do {
 687		ret = f_midi_do_transmit(midi, ep);
 688		if (ret < 0) {
 689			spin_unlock_irqrestore(&midi->transmit_lock, flags);
 690			goto drop_out;
 691		}
 692	} while (ret);
 693
 694	spin_unlock_irqrestore(&midi->transmit_lock, flags);
 695
 696	return;
 697
 698drop_out:
 699	f_midi_drop_out_substreams(midi);
 700}
 701
 702static void f_midi_in_work(struct work_struct *work)
 703{
 704	struct f_midi *midi;
 705
 706	midi = container_of(work, struct f_midi, work);
 707	f_midi_transmit(midi);
 708}
 709
 710static int f_midi_in_open(struct snd_rawmidi_substream *substream)
 711{
 712	struct f_midi *midi = substream->rmidi->private_data;
 713	struct gmidi_in_port *port;
 714
 715	if (substream->number >= midi->in_ports)
 716		return -EINVAL;
 717
 718	VDBG(midi, "%s()\n", __func__);
 719	port = midi->in_ports_array + substream->number;
 720	port->substream = substream;
 721	port->state = STATE_INITIAL;
 722	return 0;
 723}
 724
 725static int f_midi_in_close(struct snd_rawmidi_substream *substream)
 726{
 727	struct f_midi *midi = substream->rmidi->private_data;
 728
 729	VDBG(midi, "%s()\n", __func__);
 730	return 0;
 731}
 732
 733static void f_midi_in_trigger(struct snd_rawmidi_substream *substream, int up)
 734{
 735	struct f_midi *midi = substream->rmidi->private_data;
 736
 737	if (substream->number >= midi->in_ports)
 738		return;
 739
 740	VDBG(midi, "%s() %d\n", __func__, up);
 741	midi->in_ports_array[substream->number].active = up;
 742	if (up)
 743		queue_work(system_highpri_wq, &midi->work);
 744}
 745
 746static int f_midi_out_open(struct snd_rawmidi_substream *substream)
 747{
 748	struct f_midi *midi = substream->rmidi->private_data;
 749
 750	if (substream->number >= MAX_PORTS)
 751		return -EINVAL;
 752
 753	VDBG(midi, "%s()\n", __func__);
 754	midi->out_substream[substream->number] = substream;
 755	return 0;
 756}
 757
 758static int f_midi_out_close(struct snd_rawmidi_substream *substream)
 759{
 760	struct f_midi *midi = substream->rmidi->private_data;
 761
 762	VDBG(midi, "%s()\n", __func__);
 763	return 0;
 764}
 765
 766static void f_midi_out_trigger(struct snd_rawmidi_substream *substream, int up)
 767{
 768	struct f_midi *midi = substream->rmidi->private_data;
 769
 770	VDBG(midi, "%s()\n", __func__);
 771
 772	if (up)
 773		set_bit(substream->number, &midi->out_triggered);
 774	else
 775		clear_bit(substream->number, &midi->out_triggered);
 776}
 777
 778static const struct snd_rawmidi_ops gmidi_in_ops = {
 779	.open = f_midi_in_open,
 780	.close = f_midi_in_close,
 781	.trigger = f_midi_in_trigger,
 782};
 783
 784static const struct snd_rawmidi_ops gmidi_out_ops = {
 785	.open = f_midi_out_open,
 786	.close = f_midi_out_close,
 787	.trigger = f_midi_out_trigger
 788};
 789
 790static inline void f_midi_unregister_card(struct f_midi *midi)
 791{
 792	if (midi->card) {
 793		snd_card_free(midi->card);
 794		midi->card = NULL;
 795	}
 796}
 797
 798/* register as a sound "card" */
 799static int f_midi_register_card(struct f_midi *midi)
 800{
 801	struct snd_card *card;
 802	struct snd_rawmidi *rmidi;
 803	int err;
 804	static struct snd_device_ops ops = {
 805		.dev_free = f_midi_snd_free,
 806	};
 807
 808	err = snd_card_new(&midi->gadget->dev, midi->index, midi->id,
 809			   THIS_MODULE, 0, &card);
 810	if (err < 0) {
 811		ERROR(midi, "snd_card_new() failed\n");
 812		goto fail;
 813	}
 814	midi->card = card;
 815
 816	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, midi, &ops);
 817	if (err < 0) {
 818		ERROR(midi, "snd_device_new() failed: error %d\n", err);
 819		goto fail;
 820	}
 821
 822	strscpy(card->driver, f_midi_longname);
 823	strscpy(card->longname, f_midi_longname);
 824	strscpy(card->shortname, f_midi_shortname);
 825
 826	/* Set up rawmidi */
 827	snd_component_add(card, "MIDI");
 828	err = snd_rawmidi_new(card, card->longname, 0,
 829			      midi->out_ports, midi->in_ports, &rmidi);
 830	if (err < 0) {
 831		ERROR(midi, "snd_rawmidi_new() failed: error %d\n", err);
 832		goto fail;
 833	}
 834	midi->rmidi = rmidi;
 835	midi->in_last_port = 0;
 836	strscpy(rmidi->name, card->shortname);
 837	rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
 838			    SNDRV_RAWMIDI_INFO_INPUT |
 839			    SNDRV_RAWMIDI_INFO_DUPLEX;
 840	rmidi->private_data = midi;
 841	rmidi->private_free = f_midi_rmidi_free;
 842	midi->free_ref++;
 843
 844	/*
 845	 * Yes, rawmidi OUTPUT = USB IN, and rawmidi INPUT = USB OUT.
 846	 * It's an upside-down world being a gadget.
 847	 */
 848	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &gmidi_in_ops);
 849	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &gmidi_out_ops);
 850
 851	/* register it - we're ready to go */
 852	err = snd_card_register(card);
 853	if (err < 0) {
 854		ERROR(midi, "snd_card_register() failed\n");
 855		goto fail;
 856	}
 857
 858	VDBG(midi, "%s() finished ok\n", __func__);
 859	return 0;
 860
 861fail:
 862	f_midi_unregister_card(midi);
 863	return err;
 864}
 865
 866/* MIDI function driver setup/binding */
 867
 868static int f_midi_bind(struct usb_configuration *c, struct usb_function *f)
 869{
 870	struct usb_descriptor_header **midi_function;
 871	struct usb_midi_in_jack_descriptor jack_in_ext_desc[MAX_PORTS];
 872	struct usb_midi_in_jack_descriptor jack_in_emb_desc[MAX_PORTS];
 873	struct usb_midi_out_jack_descriptor_1 jack_out_ext_desc[MAX_PORTS];
 874	struct usb_midi_out_jack_descriptor_1 jack_out_emb_desc[MAX_PORTS];
 875	struct usb_composite_dev *cdev = c->cdev;
 876	struct f_midi *midi = func_to_midi(f);
 877	struct usb_string *us;
 878	int status, n, jack = 1, i = 0, endpoint_descriptor_index = 0;
 879
 880	midi->gadget = cdev->gadget;
 881	INIT_WORK(&midi->work, f_midi_in_work);
 882	status = f_midi_register_card(midi);
 883	if (status < 0)
 884		goto fail_register;
 885
 886	/* maybe allocate device-global string ID */
 887	us = usb_gstrings_attach(c->cdev, midi_strings,
 888				 ARRAY_SIZE(midi_string_defs));
 889	if (IS_ERR(us)) {
 890		status = PTR_ERR(us);
 891		goto fail;
 892	}
 893	ac_interface_desc.iInterface = us[STRING_FUNC_IDX].id;
 894
 895	/* We have two interfaces, AudioControl and MIDIStreaming */
 896	status = usb_interface_id(c, f);
 897	if (status < 0)
 898		goto fail;
 899	ac_interface_desc.bInterfaceNumber = status;
 900
 901	status = usb_interface_id(c, f);
 902	if (status < 0)
 903		goto fail;
 904	ms_interface_desc.bInterfaceNumber = status;
 905	ac_header_desc.baInterfaceNr[0] = status;
 906	midi->ms_id = status;
 907
 908	status = -ENODEV;
 909
 910	/*
 911	 * Reset wMaxPacketSize with maximum packet size of FS bulk transfer before
 912	 * endpoint claim. This ensures that the wMaxPacketSize does not exceed the
 913	 * limit during bind retries where configured dwc3 TX/RX FIFO's maxpacket
 914	 * size of 512 bytes for IN/OUT endpoints in support HS speed only.
 915	 */
 916	bulk_in_desc.wMaxPacketSize = cpu_to_le16(64);
 917	bulk_out_desc.wMaxPacketSize = cpu_to_le16(64);
 918
 919	/* allocate instance-specific endpoints */
 920	midi->in_ep = usb_ep_autoconfig(cdev->gadget, &bulk_in_desc);
 921	if (!midi->in_ep)
 922		goto fail;
 923
 924	midi->out_ep = usb_ep_autoconfig(cdev->gadget, &bulk_out_desc);
 925	if (!midi->out_ep)
 926		goto fail;
 927
 928	/* allocate temporary function list */
 929	midi_function = kcalloc((MAX_PORTS * 4) + 11, sizeof(*midi_function),
 930				GFP_KERNEL);
 931	if (!midi_function) {
 932		status = -ENOMEM;
 933		goto fail;
 934	}
 935
 936	/*
 937	 * construct the function's descriptor set. As the number of
 938	 * input and output MIDI ports is configurable, we have to do
 939	 * it that way.
 940	 */
 941
 942	/* add the headers - these are always the same */
 943	midi_function[i++] = (struct usb_descriptor_header *) &ac_interface_desc;
 944	midi_function[i++] = (struct usb_descriptor_header *) &ac_header_desc;
 945	midi_function[i++] = (struct usb_descriptor_header *) &ms_interface_desc;
 946
 947	/* calculate the header's wTotalLength */
 948	n = USB_DT_MS_HEADER_SIZE
 949		+ (midi->in_ports + midi->out_ports) *
 950			(USB_DT_MIDI_IN_SIZE + USB_DT_MIDI_OUT_SIZE(1));
 951	ms_header_desc.wTotalLength = cpu_to_le16(n);
 952
 953	midi_function[i++] = (struct usb_descriptor_header *) &ms_header_desc;
 954
 955	/* configure the external IN jacks, each linked to an embedded OUT jack */
 956	for (n = 0; n < midi->in_ports; n++) {
 957		struct usb_midi_in_jack_descriptor *in_ext = &jack_in_ext_desc[n];
 958		struct usb_midi_out_jack_descriptor_1 *out_emb = &jack_out_emb_desc[n];
 959
 960		in_ext->bLength			= USB_DT_MIDI_IN_SIZE;
 961		in_ext->bDescriptorType		= USB_DT_CS_INTERFACE;
 962		in_ext->bDescriptorSubtype	= USB_MS_MIDI_IN_JACK;
 963		in_ext->bJackType		= USB_MS_EXTERNAL;
 964		in_ext->bJackID			= jack++;
 965		in_ext->iJack			= 0;
 966		midi_function[i++] = (struct usb_descriptor_header *) in_ext;
 967
 968		out_emb->bLength		= USB_DT_MIDI_OUT_SIZE(1);
 969		out_emb->bDescriptorType	= USB_DT_CS_INTERFACE;
 970		out_emb->bDescriptorSubtype	= USB_MS_MIDI_OUT_JACK;
 971		out_emb->bJackType		= USB_MS_EMBEDDED;
 972		out_emb->bJackID		= jack++;
 973		out_emb->bNrInputPins		= 1;
 974		out_emb->pins[0].baSourcePin	= 1;
 975		out_emb->pins[0].baSourceID	= in_ext->bJackID;
 976		out_emb->iJack			= 0;
 977		midi_function[i++] = (struct usb_descriptor_header *) out_emb;
 978
 979		/* link it to the endpoint */
 980		ms_in_desc.baAssocJackID[n] = out_emb->bJackID;
 981	}
 982
 983	/* configure the external OUT jacks, each linked to an embedded IN jack */
 984	for (n = 0; n < midi->out_ports; n++) {
 985		struct usb_midi_in_jack_descriptor *in_emb = &jack_in_emb_desc[n];
 986		struct usb_midi_out_jack_descriptor_1 *out_ext = &jack_out_ext_desc[n];
 987
 988		in_emb->bLength			= USB_DT_MIDI_IN_SIZE;
 989		in_emb->bDescriptorType		= USB_DT_CS_INTERFACE;
 990		in_emb->bDescriptorSubtype	= USB_MS_MIDI_IN_JACK;
 991		in_emb->bJackType		= USB_MS_EMBEDDED;
 992		in_emb->bJackID			= jack++;
 993		in_emb->iJack			= 0;
 994		midi_function[i++] = (struct usb_descriptor_header *) in_emb;
 995
 996		out_ext->bLength =		USB_DT_MIDI_OUT_SIZE(1);
 997		out_ext->bDescriptorType =	USB_DT_CS_INTERFACE;
 998		out_ext->bDescriptorSubtype =	USB_MS_MIDI_OUT_JACK;
 999		out_ext->bJackType =		USB_MS_EXTERNAL;
1000		out_ext->bJackID =		jack++;
1001		out_ext->bNrInputPins =		1;
1002		out_ext->iJack =		0;
1003		out_ext->pins[0].baSourceID =	in_emb->bJackID;
1004		out_ext->pins[0].baSourcePin =	1;
1005		midi_function[i++] = (struct usb_descriptor_header *) out_ext;
1006
1007		/* link it to the endpoint */
1008		ms_out_desc.baAssocJackID[n] = in_emb->bJackID;
1009	}
1010
1011	/* configure the endpoint descriptors ... */
1012	ms_out_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->out_ports);
1013	ms_out_desc.bNumEmbMIDIJack = midi->out_ports;
1014
1015	ms_in_desc.bLength = USB_DT_MS_ENDPOINT_SIZE(midi->in_ports);
1016	ms_in_desc.bNumEmbMIDIJack = midi->in_ports;
1017
1018	/* ... and add them to the list */
1019	endpoint_descriptor_index = i;
1020	midi_function[i++] = (struct usb_descriptor_header *) &bulk_out_desc;
1021	midi_function[i++] = (struct usb_descriptor_header *) &ms_out_desc;
1022	midi_function[i++] = (struct usb_descriptor_header *) &bulk_in_desc;
1023	midi_function[i++] = (struct usb_descriptor_header *) &ms_in_desc;
1024	midi_function[i++] = NULL;
1025
1026	/*
1027	 * support all relevant hardware speeds... we expect that when
1028	 * hardware is dual speed, all bulk-capable endpoints work at
1029	 * both speeds
1030	 */
1031	/* copy descriptors, and track endpoint copies */
1032	f->fs_descriptors = usb_copy_descriptors(midi_function);
1033	if (!f->fs_descriptors)
1034		goto fail_f_midi;
1035
1036	bulk_in_desc.wMaxPacketSize = cpu_to_le16(512);
1037	bulk_out_desc.wMaxPacketSize = cpu_to_le16(512);
1038	f->hs_descriptors = usb_copy_descriptors(midi_function);
1039	if (!f->hs_descriptors)
1040		goto fail_f_midi;
1041
1042	bulk_in_desc.wMaxPacketSize = cpu_to_le16(1024);
1043	bulk_out_desc.wMaxPacketSize = cpu_to_le16(1024);
1044	i = endpoint_descriptor_index;
1045	midi_function[i++] = (struct usb_descriptor_header *)
1046			     &bulk_out_desc;
1047	midi_function[i++] = (struct usb_descriptor_header *)
1048			     &bulk_out_ss_comp_desc;
1049	midi_function[i++] = (struct usb_descriptor_header *)
1050			     &ms_out_desc;
1051	midi_function[i++] = (struct usb_descriptor_header *)
1052			     &bulk_in_desc;
1053	midi_function[i++] = (struct usb_descriptor_header *)
1054			     &bulk_in_ss_comp_desc;
1055	midi_function[i++] = (struct usb_descriptor_header *)
1056			     &ms_in_desc;
1057	f->ss_descriptors = usb_copy_descriptors(midi_function);
1058	if (!f->ss_descriptors)
1059		goto fail_f_midi;
1060
1061	kfree(midi_function);
1062
1063	return 0;
1064
1065fail_f_midi:
1066	kfree(midi_function);
1067	usb_free_all_descriptors(f);
1068fail:
1069	f_midi_unregister_card(midi);
1070fail_register:
1071	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
1072
1073	return status;
1074}
1075
1076static inline struct f_midi_opts *to_f_midi_opts(struct config_item *item)
1077{
1078	return container_of(to_config_group(item), struct f_midi_opts,
1079			    func_inst.group);
1080}
1081
1082static void midi_attr_release(struct config_item *item)
1083{
1084	struct f_midi_opts *opts = to_f_midi_opts(item);
1085
1086	usb_put_function_instance(&opts->func_inst);
1087}
1088
1089static struct configfs_item_operations midi_item_ops = {
1090	.release	= midi_attr_release,
1091};
1092
1093#define F_MIDI_OPT(name, test_limit, limit)				\
1094static ssize_t f_midi_opts_##name##_show(struct config_item *item, char *page) \
1095{									\
1096	struct f_midi_opts *opts = to_f_midi_opts(item);		\
1097	int result;							\
1098									\
1099	mutex_lock(&opts->lock);					\
1100	result = sprintf(page, "%u\n", opts->name);			\
1101	mutex_unlock(&opts->lock);					\
1102									\
1103	return result;							\
1104}									\
1105									\
1106static ssize_t f_midi_opts_##name##_store(struct config_item *item,	\
1107					 const char *page, size_t len)	\
1108{									\
1109	struct f_midi_opts *opts = to_f_midi_opts(item);		\
1110	int ret;							\
1111	u32 num;							\
1112									\
1113	mutex_lock(&opts->lock);					\
1114	if (opts->refcnt > 1) {						\
1115		ret = -EBUSY;						\
1116		goto end;						\
1117	}								\
1118									\
1119	ret = kstrtou32(page, 0, &num);					\
1120	if (ret)							\
1121		goto end;						\
1122									\
1123	if (test_limit && num > limit) {				\
1124		ret = -EINVAL;						\
1125		goto end;						\
1126	}								\
1127	opts->name = num;						\
1128	ret = len;							\
1129									\
1130end:									\
1131	mutex_unlock(&opts->lock);					\
1132	return ret;							\
1133}									\
1134									\
1135CONFIGFS_ATTR(f_midi_opts_, name);
1136
1137#define F_MIDI_OPT_SIGNED(name, test_limit, limit)				\
1138static ssize_t f_midi_opts_##name##_show(struct config_item *item, char *page) \
1139{									\
1140	struct f_midi_opts *opts = to_f_midi_opts(item);		\
1141	int result;							\
1142									\
1143	mutex_lock(&opts->lock);					\
1144	result = sprintf(page, "%d\n", opts->name);			\
1145	mutex_unlock(&opts->lock);					\
1146									\
1147	return result;							\
1148}									\
1149									\
1150static ssize_t f_midi_opts_##name##_store(struct config_item *item,	\
1151					 const char *page, size_t len)	\
1152{									\
1153	struct f_midi_opts *opts = to_f_midi_opts(item);		\
1154	int ret;							\
1155	s32 num;							\
1156									\
1157	mutex_lock(&opts->lock);					\
1158	if (opts->refcnt > 1) {						\
1159		ret = -EBUSY;						\
1160		goto end;						\
1161	}								\
1162									\
1163	ret = kstrtos32(page, 0, &num);					\
1164	if (ret)							\
1165		goto end;						\
1166									\
1167	if (test_limit && num > limit) {				\
1168		ret = -EINVAL;						\
1169		goto end;						\
1170	}								\
1171	opts->name = num;						\
1172	ret = len;							\
1173									\
1174end:									\
1175	mutex_unlock(&opts->lock);					\
1176	return ret;							\
1177}									\
1178									\
1179CONFIGFS_ATTR(f_midi_opts_, name);
1180
1181F_MIDI_OPT_SIGNED(index, true, SNDRV_CARDS);
1182F_MIDI_OPT(buflen, false, 0);
1183F_MIDI_OPT(qlen, false, 0);
1184F_MIDI_OPT(in_ports, true, MAX_PORTS);
1185F_MIDI_OPT(out_ports, true, MAX_PORTS);
1186
1187static ssize_t f_midi_opts_id_show(struct config_item *item, char *page)
1188{
1189	struct f_midi_opts *opts = to_f_midi_opts(item);
1190	ssize_t result;
1191
1192	mutex_lock(&opts->lock);
1193	if (opts->id) {
1194		result = strscpy(page, opts->id, PAGE_SIZE);
1195	} else {
1196		page[0] = 0;
1197		result = 0;
1198	}
1199
1200	mutex_unlock(&opts->lock);
1201
1202	return result;
1203}
1204
1205static ssize_t f_midi_opts_id_store(struct config_item *item,
1206				    const char *page, size_t len)
1207{
1208	struct f_midi_opts *opts = to_f_midi_opts(item);
1209	int ret;
1210	char *c;
1211
1212	mutex_lock(&opts->lock);
1213	if (opts->refcnt > 1) {
1214		ret = -EBUSY;
1215		goto end;
1216	}
1217
1218	c = kstrndup(page, len, GFP_KERNEL);
1219	if (!c) {
1220		ret = -ENOMEM;
1221		goto end;
1222	}
1223	if (opts->id_allocated)
1224		kfree(opts->id);
1225	opts->id = c;
1226	opts->id_allocated = true;
1227	ret = len;
1228end:
1229	mutex_unlock(&opts->lock);
1230	return ret;
1231}
1232
1233CONFIGFS_ATTR(f_midi_opts_, id);
1234
1235static struct configfs_attribute *midi_attrs[] = {
1236	&f_midi_opts_attr_index,
1237	&f_midi_opts_attr_buflen,
1238	&f_midi_opts_attr_qlen,
1239	&f_midi_opts_attr_in_ports,
1240	&f_midi_opts_attr_out_ports,
1241	&f_midi_opts_attr_id,
1242	NULL,
1243};
1244
1245static const struct config_item_type midi_func_type = {
1246	.ct_item_ops	= &midi_item_ops,
1247	.ct_attrs	= midi_attrs,
1248	.ct_owner	= THIS_MODULE,
1249};
1250
1251static void f_midi_free_inst(struct usb_function_instance *f)
1252{
1253	struct f_midi_opts *opts;
1254	bool free = false;
1255
1256	opts = container_of(f, struct f_midi_opts, func_inst);
1257
1258	mutex_lock(&opts->lock);
1259	if (!--opts->refcnt) {
1260		free = true;
1261	}
1262	mutex_unlock(&opts->lock);
1263
1264	if (free) {
1265		if (opts->id_allocated)
1266			kfree(opts->id);
1267		kfree(opts);
1268	}
1269}
1270
1271static struct usb_function_instance *f_midi_alloc_inst(void)
1272{
1273	struct f_midi_opts *opts;
1274
1275	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1276	if (!opts)
1277		return ERR_PTR(-ENOMEM);
1278
1279	mutex_init(&opts->lock);
1280	opts->func_inst.free_func_inst = f_midi_free_inst;
1281	opts->index = SNDRV_DEFAULT_IDX1;
1282	opts->id = SNDRV_DEFAULT_STR1;
1283	opts->buflen = 512;
1284	opts->qlen = 32;
1285	opts->in_ports = 1;
1286	opts->out_ports = 1;
1287	opts->refcnt = 1;
1288
1289	config_group_init_type_name(&opts->func_inst.group, "",
1290				    &midi_func_type);
1291
1292	return &opts->func_inst;
1293}
1294
1295static void f_midi_free(struct usb_function *f)
1296{
1297	struct f_midi *midi;
1298	struct f_midi_opts *opts;
1299	bool free = false;
1300
1301	midi = func_to_midi(f);
1302	opts = container_of(f->fi, struct f_midi_opts, func_inst);
1303	mutex_lock(&opts->lock);
1304	if (!--midi->free_ref) {
1305		kfree(midi->id);
1306		kfifo_free(&midi->in_req_fifo);
1307		kfree(midi);
1308		free = true;
1309	}
1310	mutex_unlock(&opts->lock);
1311
1312	if (free)
1313		f_midi_free_inst(&opts->func_inst);
1314}
1315
1316static void f_midi_rmidi_free(struct snd_rawmidi *rmidi)
1317{
1318	f_midi_free(rmidi->private_data);
1319}
1320
1321static void f_midi_unbind(struct usb_configuration *c, struct usb_function *f)
1322{
1323	struct usb_composite_dev *cdev = f->config->cdev;
1324	struct f_midi *midi = func_to_midi(f);
1325	struct snd_card *card;
1326
1327	DBG(cdev, "unbind\n");
1328
1329	/* just to be sure */
1330	f_midi_disable(f);
1331
1332	card = midi->card;
1333	midi->card = NULL;
1334	if (card)
1335		snd_card_free_when_closed(card);
1336
1337	usb_free_all_descriptors(f);
1338}
1339
1340static struct usb_function *f_midi_alloc(struct usb_function_instance *fi)
1341{
1342	struct f_midi *midi = NULL;
1343	struct f_midi_opts *opts;
1344	int status, i;
1345
1346	opts = container_of(fi, struct f_midi_opts, func_inst);
1347
1348	mutex_lock(&opts->lock);
1349	/* sanity check */
1350	if (opts->in_ports > MAX_PORTS || opts->out_ports > MAX_PORTS) {
1351		status = -EINVAL;
1352		goto setup_fail;
1353	}
1354
1355	/* allocate and initialize one new instance */
1356	midi = kzalloc(struct_size(midi, in_ports_array, opts->in_ports),
1357		       GFP_KERNEL);
1358	if (!midi) {
1359		status = -ENOMEM;
1360		goto setup_fail;
1361	}
1362	midi->in_ports = opts->in_ports;
1363
1364	for (i = 0; i < opts->in_ports; i++)
1365		midi->in_ports_array[i].cable = i;
1366
1367	/* set up ALSA midi devices */
1368	midi->id = kstrdup(opts->id, GFP_KERNEL);
1369	if (opts->id && !midi->id) {
1370		status = -ENOMEM;
1371		goto midi_free;
1372	}
1373	midi->out_ports = opts->out_ports;
1374	midi->index = opts->index;
1375	midi->buflen = opts->buflen;
1376	midi->qlen = opts->qlen;
1377	midi->in_last_port = 0;
1378	midi->free_ref = 1;
1379
1380	status = kfifo_alloc(&midi->in_req_fifo, midi->qlen, GFP_KERNEL);
1381	if (status)
1382		goto midi_free;
1383
1384	spin_lock_init(&midi->transmit_lock);
1385
1386	++opts->refcnt;
1387	mutex_unlock(&opts->lock);
1388
1389	midi->func.name		= "gmidi function";
1390	midi->func.bind		= f_midi_bind;
1391	midi->func.unbind	= f_midi_unbind;
1392	midi->func.set_alt	= f_midi_set_alt;
1393	midi->func.disable	= f_midi_disable;
1394	midi->func.free_func	= f_midi_free;
1395
1396	return &midi->func;
1397
1398midi_free:
1399	if (midi)
1400		kfree(midi->id);
1401	kfree(midi);
1402setup_fail:
1403	mutex_unlock(&opts->lock);
1404
1405	return ERR_PTR(status);
1406}
1407
1408DECLARE_USB_FUNCTION_INIT(midi, f_midi_alloc_inst, f_midi_alloc);