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