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