1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * trans_usbg.c - USB peripheral usb9pfs configuration driver and transport. 4 * 5 * Copyright (C) 2024 Michael Grzeschik <m.grzeschik@pengutronix.de> 6 */ 7 8 /* Gadget usb9pfs only needs two bulk endpoints, and will use the usb9pfs 9 * transport to mount host exported filesystem via usb gadget. 10 */ 11 12 /* +--------------------------+ | +--------------------------+ 13 * | 9PFS mounting client | | | 9PFS exporting server | 14 * SW | | | | | 15 * | (this:trans_usbg) | | |(e.g. diod or nfs-ganesha)| 16 * +-------------^------------+ | +-------------^------------+ 17 * | | | 18 * ------------------|------------------------------------|------------- 19 * | | | 20 * +-------------v------------+ | +-------------v------------+ 21 * | | | | | 22 * HW | USB Device Controller <---------> USB Host Controller | 23 * | | | | | 24 * +--------------------------+ | +--------------------------+ 25 */ 26 27 #include <linux/cleanup.h> 28 #include <linux/kernel.h> 29 #include <linux/module.h> 30 #include <linux/fs_context.h> 31 #include <linux/usb/composite.h> 32 #include <linux/usb/func_utils.h> 33 34 #include <net/9p/9p.h> 35 #include <net/9p/client.h> 36 #include <net/9p/transport.h> 37 38 #define DEFAULT_BUFLEN 16384 39 40 struct f_usb9pfs { 41 struct p9_client *client; 42 43 /* 9p request lock for en/dequeue */ 44 spinlock_t lock; 45 46 struct usb_request *in_req; 47 struct usb_request *out_req; 48 49 struct usb_ep *in_ep; 50 struct usb_ep *out_ep; 51 52 struct completion send; 53 struct completion received; 54 55 unsigned int buflen; 56 57 struct usb_function function; 58 }; 59 60 static inline struct f_usb9pfs *func_to_usb9pfs(struct usb_function *f) 61 { 62 return container_of(f, struct f_usb9pfs, function); 63 } 64 65 struct f_usb9pfs_opts { 66 struct usb_function_instance func_inst; 67 unsigned int buflen; 68 69 struct f_usb9pfs_dev *dev; 70 71 /* Read/write access to configfs attributes is handled by configfs. 72 * 73 * This is to protect the data from concurrent access by read/write 74 * and create symlink/remove symlink. 75 */ 76 struct mutex lock; 77 int refcnt; 78 }; 79 80 struct f_usb9pfs_dev { 81 struct f_usb9pfs *usb9pfs; 82 struct f_usb9pfs_opts *opts; 83 char tag[41]; 84 bool inuse; 85 86 struct list_head usb9pfs_instance; 87 }; 88 89 static DEFINE_MUTEX(usb9pfs_lock); 90 static struct list_head usbg_instance_list; 91 92 static int usb9pfs_queue_tx(struct f_usb9pfs *usb9pfs, struct p9_req_t *p9_tx_req, 93 gfp_t gfp_flags) 94 { 95 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev; 96 struct usb_request *req = usb9pfs->in_req; 97 int ret; 98 99 if (!(p9_tx_req->tc.size % usb9pfs->in_ep->maxpacket)) 100 req->zero = 1; 101 102 req->buf = p9_tx_req->tc.sdata; 103 req->length = p9_tx_req->tc.size; 104 req->context = p9_tx_req; 105 106 dev_dbg(&cdev->gadget->dev, "%s usb9pfs send --> %d/%d, zero: %d\n", 107 usb9pfs->in_ep->name, req->actual, req->length, req->zero); 108 109 ret = usb_ep_queue(usb9pfs->in_ep, req, gfp_flags); 110 if (ret) 111 req->context = NULL; 112 113 dev_dbg(&cdev->gadget->dev, "tx submit --> %d\n", ret); 114 115 return ret; 116 } 117 118 static int usb9pfs_queue_rx(struct f_usb9pfs *usb9pfs, struct usb_request *req, 119 gfp_t gfp_flags) 120 { 121 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev; 122 int ret; 123 124 ret = usb_ep_queue(usb9pfs->out_ep, req, gfp_flags); 125 126 dev_dbg(&cdev->gadget->dev, "rx submit --> %d\n", ret); 127 128 return ret; 129 } 130 131 static int usb9pfs_transmit(struct f_usb9pfs *usb9pfs, struct p9_req_t *p9_req) 132 { 133 int ret = 0; 134 135 guard(spinlock_irqsave)(&usb9pfs->lock); 136 137 ret = usb9pfs_queue_tx(usb9pfs, p9_req, GFP_ATOMIC); 138 if (ret) 139 return ret; 140 141 list_del(&p9_req->req_list); 142 143 p9_req_get(p9_req); 144 145 return ret; 146 } 147 148 static void usb9pfs_tx_complete(struct usb_ep *ep, struct usb_request *req) 149 { 150 struct f_usb9pfs *usb9pfs = ep->driver_data; 151 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev; 152 struct p9_req_t *p9_tx_req = req->context; 153 unsigned long flags; 154 155 /* reset zero packages */ 156 req->zero = 0; 157 158 if (req->status) { 159 dev_err(&cdev->gadget->dev, "%s usb9pfs complete --> %d, %d/%d\n", 160 ep->name, req->status, req->actual, req->length); 161 return; 162 } 163 164 dev_dbg(&cdev->gadget->dev, "%s usb9pfs complete --> %d, %d/%d\n", 165 ep->name, req->status, req->actual, req->length); 166 167 spin_lock_irqsave(&usb9pfs->lock, flags); 168 WRITE_ONCE(p9_tx_req->status, REQ_STATUS_SENT); 169 170 p9_req_put(usb9pfs->client, p9_tx_req); 171 172 req->context = NULL; 173 174 spin_unlock_irqrestore(&usb9pfs->lock, flags); 175 176 complete(&usb9pfs->send); 177 } 178 179 static struct p9_req_t *usb9pfs_rx_header(struct f_usb9pfs *usb9pfs, void *buf) 180 { 181 struct p9_req_t *p9_rx_req; 182 struct p9_fcall rc; 183 int ret; 184 185 /* start by reading header */ 186 rc.sdata = buf; 187 rc.offset = 0; 188 rc.capacity = P9_HDRSZ; 189 rc.size = P9_HDRSZ; 190 191 p9_debug(P9_DEBUG_TRANS, "mux %p got %zu bytes\n", usb9pfs, 192 rc.capacity - rc.offset); 193 194 ret = p9_parse_header(&rc, &rc.size, NULL, NULL, 0); 195 if (ret) { 196 p9_debug(P9_DEBUG_ERROR, 197 "error parsing header: %d\n", ret); 198 return NULL; 199 } 200 201 p9_debug(P9_DEBUG_TRANS, 202 "mux %p pkt: size: %d bytes tag: %d\n", 203 usb9pfs, rc.size, rc.tag); 204 205 p9_rx_req = p9_tag_lookup(usb9pfs->client, rc.tag); 206 if (!p9_rx_req || p9_rx_req->status != REQ_STATUS_SENT) { 207 p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n", rc.tag); 208 return NULL; 209 } 210 211 if (rc.size > p9_rx_req->rc.capacity) { 212 p9_debug(P9_DEBUG_ERROR, 213 "requested packet size too big: %d for tag %d with capacity %zd\n", 214 rc.size, rc.tag, p9_rx_req->rc.capacity); 215 p9_req_put(usb9pfs->client, p9_rx_req); 216 return NULL; 217 } 218 219 if (!p9_rx_req->rc.sdata) { 220 p9_debug(P9_DEBUG_ERROR, 221 "No recv fcall for tag %d (req %p), disconnecting!\n", 222 rc.tag, p9_rx_req); 223 p9_req_put(usb9pfs->client, p9_rx_req); 224 return NULL; 225 } 226 227 return p9_rx_req; 228 } 229 230 static void usb9pfs_rx_complete(struct usb_ep *ep, struct usb_request *req) 231 { 232 struct f_usb9pfs *usb9pfs = ep->driver_data; 233 struct usb_composite_dev *cdev = usb9pfs->function.config->cdev; 234 struct p9_req_t *p9_rx_req; 235 unsigned int req_size = req->actual; 236 int status = REQ_STATUS_RCVD; 237 238 if (req->status) { 239 dev_err(&cdev->gadget->dev, "%s usb9pfs complete --> %d, %d/%d\n", 240 ep->name, req->status, req->actual, req->length); 241 return; 242 } 243 244 p9_rx_req = usb9pfs_rx_header(usb9pfs, req->buf); 245 if (!p9_rx_req) 246 return; 247 248 if (req_size > p9_rx_req->rc.capacity) { 249 dev_err(&cdev->gadget->dev, 250 "%s received data size %u exceeds buffer capacity %zu\n", 251 ep->name, req_size, p9_rx_req->rc.capacity); 252 req_size = 0; 253 status = REQ_STATUS_ERROR; 254 } 255 256 memcpy(p9_rx_req->rc.sdata, req->buf, req_size); 257 258 p9_rx_req->rc.size = req_size; 259 260 p9_client_cb(usb9pfs->client, p9_rx_req, status); 261 p9_req_put(usb9pfs->client, p9_rx_req); 262 263 complete(&usb9pfs->received); 264 } 265 266 static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep) 267 { 268 int value; 269 270 value = usb_ep_disable(ep); 271 if (value < 0) 272 dev_info(&cdev->gadget->dev, 273 "disable %s --> %d\n", ep->name, value); 274 } 275 276 static void disable_usb9pfs(struct f_usb9pfs *usb9pfs) 277 { 278 struct usb_composite_dev *cdev = 279 usb9pfs->function.config->cdev; 280 281 if (usb9pfs->in_req) { 282 usb_ep_free_request(usb9pfs->in_ep, usb9pfs->in_req); 283 usb9pfs->in_req = NULL; 284 } 285 286 if (usb9pfs->out_req) { 287 usb_ep_free_request(usb9pfs->out_ep, usb9pfs->out_req); 288 usb9pfs->out_req = NULL; 289 } 290 291 disable_ep(cdev, usb9pfs->in_ep); 292 disable_ep(cdev, usb9pfs->out_ep); 293 dev_dbg(&cdev->gadget->dev, "%s disabled\n", 294 usb9pfs->function.name); 295 } 296 297 static int alloc_requests(struct usb_composite_dev *cdev, 298 struct f_usb9pfs *usb9pfs) 299 { 300 int ret; 301 302 usb9pfs->in_req = usb_ep_alloc_request(usb9pfs->in_ep, GFP_ATOMIC); 303 if (!usb9pfs->in_req) { 304 ret = -ENOENT; 305 goto fail; 306 } 307 308 usb9pfs->out_req = alloc_ep_req(usb9pfs->out_ep, usb9pfs->buflen); 309 if (!usb9pfs->out_req) { 310 ret = -ENOENT; 311 goto fail_in; 312 } 313 314 usb9pfs->in_req->complete = usb9pfs_tx_complete; 315 usb9pfs->out_req->complete = usb9pfs_rx_complete; 316 317 /* length will be set in complete routine */ 318 usb9pfs->in_req->context = usb9pfs; 319 usb9pfs->out_req->context = usb9pfs; 320 321 return 0; 322 323 fail_in: 324 usb_ep_free_request(usb9pfs->in_ep, usb9pfs->in_req); 325 fail: 326 return ret; 327 } 328 329 static int enable_endpoint(struct usb_composite_dev *cdev, 330 struct f_usb9pfs *usb9pfs, struct usb_ep *ep) 331 { 332 int ret; 333 334 ret = config_ep_by_speed(cdev->gadget, &usb9pfs->function, ep); 335 if (ret) 336 return ret; 337 338 ret = usb_ep_enable(ep); 339 if (ret < 0) 340 return ret; 341 342 ep->driver_data = usb9pfs; 343 344 return 0; 345 } 346 347 static int 348 enable_usb9pfs(struct usb_composite_dev *cdev, struct f_usb9pfs *usb9pfs) 349 { 350 struct p9_client *client; 351 int ret = 0; 352 353 ret = enable_endpoint(cdev, usb9pfs, usb9pfs->in_ep); 354 if (ret) 355 goto out; 356 357 ret = enable_endpoint(cdev, usb9pfs, usb9pfs->out_ep); 358 if (ret) 359 goto disable_in; 360 361 ret = alloc_requests(cdev, usb9pfs); 362 if (ret) 363 goto disable_out; 364 365 client = usb9pfs->client; 366 if (client) 367 client->status = Connected; 368 369 dev_dbg(&cdev->gadget->dev, "%s enabled\n", usb9pfs->function.name); 370 return 0; 371 372 disable_out: 373 usb_ep_disable(usb9pfs->out_ep); 374 disable_in: 375 usb_ep_disable(usb9pfs->in_ep); 376 out: 377 return ret; 378 } 379 380 static int p9_usbg_create(struct p9_client *client, struct fs_context *fc) 381 { 382 const char *devname = fc->source; 383 struct f_usb9pfs_dev *dev; 384 struct f_usb9pfs *usb9pfs; 385 int ret = -ENOENT; 386 int found = 0; 387 388 if (!devname) 389 return -EINVAL; 390 391 guard(mutex)(&usb9pfs_lock); 392 393 list_for_each_entry(dev, &usbg_instance_list, usb9pfs_instance) { 394 if (!strncmp(devname, dev->tag, strlen(devname))) { 395 if (!dev->inuse) { 396 dev->inuse = true; 397 found = 1; 398 break; 399 } 400 ret = -EBUSY; 401 break; 402 } 403 } 404 405 if (!found) { 406 pr_err("no channels available for device %s\n", devname); 407 return ret; 408 } 409 410 usb9pfs = dev->usb9pfs; 411 if (!usb9pfs) 412 return -EINVAL; 413 414 client->trans = (void *)usb9pfs; 415 if (!usb9pfs->in_req) 416 client->status = Disconnected; 417 else 418 client->status = Connected; 419 usb9pfs->client = client; 420 421 client->trans_mod->maxsize = usb9pfs->buflen; 422 423 complete(&usb9pfs->received); 424 425 return 0; 426 } 427 428 static void usb9pfs_clear_tx(struct f_usb9pfs *usb9pfs) 429 { 430 struct p9_req_t *req; 431 432 guard(spinlock_irqsave)(&usb9pfs->lock); 433 434 req = usb9pfs->in_req->context; 435 if (!req) 436 return; 437 438 if (!req->t_err) 439 req->t_err = -ECONNRESET; 440 441 p9_client_cb(usb9pfs->client, req, REQ_STATUS_ERROR); 442 } 443 444 static void p9_usbg_close(struct p9_client *client) 445 { 446 struct f_usb9pfs *usb9pfs; 447 struct f_usb9pfs_dev *dev; 448 struct f_usb9pfs_opts *opts; 449 450 if (!client) 451 return; 452 453 usb9pfs = client->trans; 454 if (!usb9pfs) 455 return; 456 457 client->status = Disconnected; 458 459 usb9pfs_clear_tx(usb9pfs); 460 461 opts = container_of(usb9pfs->function.fi, 462 struct f_usb9pfs_opts, func_inst); 463 464 dev = opts->dev; 465 466 mutex_lock(&usb9pfs_lock); 467 dev->inuse = false; 468 mutex_unlock(&usb9pfs_lock); 469 } 470 471 static int p9_usbg_request(struct p9_client *client, struct p9_req_t *p9_req) 472 { 473 struct f_usb9pfs *usb9pfs = client->trans; 474 int ret; 475 476 if (client->status != Connected) 477 return -EBUSY; 478 479 ret = wait_for_completion_killable(&usb9pfs->received); 480 if (ret) 481 return ret; 482 483 ret = usb9pfs_transmit(usb9pfs, p9_req); 484 if (ret) 485 return ret; 486 487 ret = wait_for_completion_killable(&usb9pfs->send); 488 if (ret) 489 return ret; 490 491 return usb9pfs_queue_rx(usb9pfs, usb9pfs->out_req, GFP_ATOMIC); 492 } 493 494 static int p9_usbg_cancel(struct p9_client *client, struct p9_req_t *req) 495 { 496 struct f_usb9pfs *usb9pfs = client->trans; 497 int ret = 1; 498 499 p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req); 500 501 guard(spinlock_irqsave)(&usb9pfs->lock); 502 503 if (req->status == REQ_STATUS_UNSENT) { 504 list_del(&req->req_list); 505 WRITE_ONCE(req->status, REQ_STATUS_FLSHD); 506 p9_req_put(client, req); 507 ret = 0; 508 } 509 510 return ret; 511 } 512 513 static struct p9_trans_module p9_usbg_trans = { 514 .name = "usbg", 515 .create = p9_usbg_create, 516 .close = p9_usbg_close, 517 .request = p9_usbg_request, 518 .cancel = p9_usbg_cancel, 519 .supports_vmalloc = false, 520 .owner = THIS_MODULE, 521 }; 522 523 /*-------------------------------------------------------------------------*/ 524 525 #define USB_PROTOCOL_9PFS 0x09 526 527 static struct usb_interface_descriptor usb9pfs_intf = { 528 .bLength = sizeof(usb9pfs_intf), 529 .bDescriptorType = USB_DT_INTERFACE, 530 531 .bNumEndpoints = 2, 532 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 533 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC, 534 .bInterfaceProtocol = USB_PROTOCOL_9PFS, 535 536 /* .iInterface = DYNAMIC */ 537 }; 538 539 /* full speed support: */ 540 541 static struct usb_endpoint_descriptor fs_usb9pfs_source_desc = { 542 .bLength = USB_DT_ENDPOINT_SIZE, 543 .bDescriptorType = USB_DT_ENDPOINT, 544 545 .bEndpointAddress = USB_DIR_IN, 546 .bmAttributes = USB_ENDPOINT_XFER_BULK, 547 }; 548 549 static struct usb_endpoint_descriptor fs_usb9pfs_sink_desc = { 550 .bLength = USB_DT_ENDPOINT_SIZE, 551 .bDescriptorType = USB_DT_ENDPOINT, 552 553 .bEndpointAddress = USB_DIR_OUT, 554 .bmAttributes = USB_ENDPOINT_XFER_BULK, 555 }; 556 557 static struct usb_descriptor_header *fs_usb9pfs_descs[] = { 558 (struct usb_descriptor_header *)&usb9pfs_intf, 559 (struct usb_descriptor_header *)&fs_usb9pfs_sink_desc, 560 (struct usb_descriptor_header *)&fs_usb9pfs_source_desc, 561 NULL, 562 }; 563 564 /* high speed support: */ 565 566 static struct usb_endpoint_descriptor hs_usb9pfs_source_desc = { 567 .bLength = USB_DT_ENDPOINT_SIZE, 568 .bDescriptorType = USB_DT_ENDPOINT, 569 570 .bmAttributes = USB_ENDPOINT_XFER_BULK, 571 .wMaxPacketSize = cpu_to_le16(512), 572 }; 573 574 static struct usb_endpoint_descriptor hs_usb9pfs_sink_desc = { 575 .bLength = USB_DT_ENDPOINT_SIZE, 576 .bDescriptorType = USB_DT_ENDPOINT, 577 578 .bmAttributes = USB_ENDPOINT_XFER_BULK, 579 .wMaxPacketSize = cpu_to_le16(512), 580 }; 581 582 static struct usb_descriptor_header *hs_usb9pfs_descs[] = { 583 (struct usb_descriptor_header *)&usb9pfs_intf, 584 (struct usb_descriptor_header *)&hs_usb9pfs_source_desc, 585 (struct usb_descriptor_header *)&hs_usb9pfs_sink_desc, 586 NULL, 587 }; 588 589 /* super speed support: */ 590 591 static struct usb_endpoint_descriptor ss_usb9pfs_source_desc = { 592 .bLength = USB_DT_ENDPOINT_SIZE, 593 .bDescriptorType = USB_DT_ENDPOINT, 594 595 .bmAttributes = USB_ENDPOINT_XFER_BULK, 596 .wMaxPacketSize = cpu_to_le16(1024), 597 }; 598 599 static struct usb_ss_ep_comp_descriptor ss_usb9pfs_source_comp_desc = { 600 .bLength = USB_DT_SS_EP_COMP_SIZE, 601 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 602 .bMaxBurst = 0, 603 .bmAttributes = 0, 604 .wBytesPerInterval = 0, 605 }; 606 607 static struct usb_endpoint_descriptor ss_usb9pfs_sink_desc = { 608 .bLength = USB_DT_ENDPOINT_SIZE, 609 .bDescriptorType = USB_DT_ENDPOINT, 610 611 .bmAttributes = USB_ENDPOINT_XFER_BULK, 612 .wMaxPacketSize = cpu_to_le16(1024), 613 }; 614 615 static struct usb_ss_ep_comp_descriptor ss_usb9pfs_sink_comp_desc = { 616 .bLength = USB_DT_SS_EP_COMP_SIZE, 617 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, 618 .bMaxBurst = 0, 619 .bmAttributes = 0, 620 .wBytesPerInterval = 0, 621 }; 622 623 static struct usb_descriptor_header *ss_usb9pfs_descs[] = { 624 (struct usb_descriptor_header *)&usb9pfs_intf, 625 (struct usb_descriptor_header *)&ss_usb9pfs_source_desc, 626 (struct usb_descriptor_header *)&ss_usb9pfs_source_comp_desc, 627 (struct usb_descriptor_header *)&ss_usb9pfs_sink_desc, 628 (struct usb_descriptor_header *)&ss_usb9pfs_sink_comp_desc, 629 NULL, 630 }; 631 632 /* function-specific strings: */ 633 static struct usb_string strings_usb9pfs[] = { 634 [0].s = "usb9pfs input to output", 635 { } /* end of list */ 636 }; 637 638 static struct usb_gadget_strings stringtab_usb9pfs = { 639 .language = 0x0409, /* en-us */ 640 .strings = strings_usb9pfs, 641 }; 642 643 static struct usb_gadget_strings *usb9pfs_strings[] = { 644 &stringtab_usb9pfs, 645 NULL, 646 }; 647 648 /*-------------------------------------------------------------------------*/ 649 650 static int usb9pfs_func_bind(struct usb_configuration *c, 651 struct usb_function *f) 652 { 653 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f); 654 struct f_usb9pfs_opts *opts; 655 struct usb_composite_dev *cdev = c->cdev; 656 int ret; 657 int id; 658 659 /* allocate interface ID(s) */ 660 id = usb_interface_id(c, f); 661 if (id < 0) 662 return id; 663 usb9pfs_intf.bInterfaceNumber = id; 664 665 id = usb_string_id(cdev); 666 if (id < 0) 667 return id; 668 strings_usb9pfs[0].id = id; 669 usb9pfs_intf.iInterface = id; 670 671 /* allocate endpoints */ 672 usb9pfs->in_ep = usb_ep_autoconfig(cdev->gadget, 673 &fs_usb9pfs_source_desc); 674 if (!usb9pfs->in_ep) 675 goto autoconf_fail; 676 677 usb9pfs->out_ep = usb_ep_autoconfig(cdev->gadget, 678 &fs_usb9pfs_sink_desc); 679 if (!usb9pfs->out_ep) 680 goto autoconf_fail; 681 682 /* support high speed hardware */ 683 hs_usb9pfs_source_desc.bEndpointAddress = 684 fs_usb9pfs_source_desc.bEndpointAddress; 685 hs_usb9pfs_sink_desc.bEndpointAddress = 686 fs_usb9pfs_sink_desc.bEndpointAddress; 687 688 /* support super speed hardware */ 689 ss_usb9pfs_source_desc.bEndpointAddress = 690 fs_usb9pfs_source_desc.bEndpointAddress; 691 ss_usb9pfs_sink_desc.bEndpointAddress = 692 fs_usb9pfs_sink_desc.bEndpointAddress; 693 694 ret = usb_assign_descriptors(f, fs_usb9pfs_descs, hs_usb9pfs_descs, 695 ss_usb9pfs_descs, ss_usb9pfs_descs); 696 if (ret) 697 return ret; 698 699 opts = container_of(f->fi, struct f_usb9pfs_opts, func_inst); 700 opts->dev->usb9pfs = usb9pfs; 701 702 dev_dbg(&cdev->gadget->dev, "%s speed %s: IN/%s, OUT/%s\n", 703 (gadget_is_superspeed(c->cdev->gadget) ? "super" : 704 (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")), 705 f->name, usb9pfs->in_ep->name, usb9pfs->out_ep->name); 706 707 return 0; 708 709 autoconf_fail: 710 ERROR(cdev, "%s: can't autoconfigure on %s\n", 711 f->name, cdev->gadget->name); 712 return -ENODEV; 713 } 714 715 static void usb9pfs_func_unbind(struct usb_configuration *c, 716 struct usb_function *f) 717 { 718 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f); 719 720 disable_usb9pfs(usb9pfs); 721 } 722 723 static void usb9pfs_free_func(struct usb_function *f) 724 { 725 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f); 726 struct f_usb9pfs_opts *opts; 727 728 kfree(usb9pfs); 729 730 opts = container_of(f->fi, struct f_usb9pfs_opts, func_inst); 731 732 mutex_lock(&opts->lock); 733 opts->refcnt--; 734 mutex_unlock(&opts->lock); 735 736 usb_free_all_descriptors(f); 737 } 738 739 static int usb9pfs_set_alt(struct usb_function *f, 740 unsigned int intf, unsigned int alt) 741 { 742 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f); 743 struct usb_composite_dev *cdev = f->config->cdev; 744 745 return enable_usb9pfs(cdev, usb9pfs); 746 } 747 748 static void usb9pfs_disable(struct usb_function *f) 749 { 750 struct f_usb9pfs *usb9pfs = func_to_usb9pfs(f); 751 752 usb9pfs_clear_tx(usb9pfs); 753 } 754 755 static struct usb_function *usb9pfs_alloc(struct usb_function_instance *fi) 756 { 757 struct f_usb9pfs_opts *usb9pfs_opts; 758 struct f_usb9pfs *usb9pfs; 759 760 usb9pfs = kzalloc(sizeof(*usb9pfs), GFP_KERNEL); 761 if (!usb9pfs) 762 return ERR_PTR(-ENOMEM); 763 764 spin_lock_init(&usb9pfs->lock); 765 766 init_completion(&usb9pfs->send); 767 init_completion(&usb9pfs->received); 768 769 usb9pfs_opts = container_of(fi, struct f_usb9pfs_opts, func_inst); 770 771 mutex_lock(&usb9pfs_opts->lock); 772 usb9pfs_opts->refcnt++; 773 mutex_unlock(&usb9pfs_opts->lock); 774 775 usb9pfs->buflen = usb9pfs_opts->buflen; 776 777 usb9pfs->function.name = "usb9pfs"; 778 usb9pfs->function.bind = usb9pfs_func_bind; 779 usb9pfs->function.unbind = usb9pfs_func_unbind; 780 usb9pfs->function.set_alt = usb9pfs_set_alt; 781 usb9pfs->function.disable = usb9pfs_disable; 782 usb9pfs->function.strings = usb9pfs_strings; 783 784 usb9pfs->function.free_func = usb9pfs_free_func; 785 786 return &usb9pfs->function; 787 } 788 789 static inline struct f_usb9pfs_opts *to_f_usb9pfs_opts(struct config_item *item) 790 { 791 return container_of(to_config_group(item), struct f_usb9pfs_opts, 792 func_inst.group); 793 } 794 795 static inline struct f_usb9pfs_opts *fi_to_f_usb9pfs_opts(struct usb_function_instance *fi) 796 { 797 return container_of(fi, struct f_usb9pfs_opts, func_inst); 798 } 799 800 static void usb9pfs_attr_release(struct config_item *item) 801 { 802 struct f_usb9pfs_opts *usb9pfs_opts = to_f_usb9pfs_opts(item); 803 804 usb_put_function_instance(&usb9pfs_opts->func_inst); 805 } 806 807 static struct configfs_item_operations usb9pfs_item_ops = { 808 .release = usb9pfs_attr_release, 809 }; 810 811 static ssize_t f_usb9pfs_opts_buflen_show(struct config_item *item, char *page) 812 { 813 struct f_usb9pfs_opts *opts = to_f_usb9pfs_opts(item); 814 int ret; 815 816 mutex_lock(&opts->lock); 817 ret = sysfs_emit(page, "%d\n", opts->buflen); 818 mutex_unlock(&opts->lock); 819 820 return ret; 821 } 822 823 static ssize_t f_usb9pfs_opts_buflen_store(struct config_item *item, 824 const char *page, size_t len) 825 { 826 struct f_usb9pfs_opts *opts = to_f_usb9pfs_opts(item); 827 int ret; 828 u32 num; 829 830 guard(mutex)(&opts->lock); 831 832 if (opts->refcnt) 833 return -EBUSY; 834 835 ret = kstrtou32(page, 0, &num); 836 if (ret) 837 return ret; 838 839 opts->buflen = num; 840 841 return len; 842 } 843 844 CONFIGFS_ATTR(f_usb9pfs_opts_, buflen); 845 846 static struct configfs_attribute *usb9pfs_attrs[] = { 847 &f_usb9pfs_opts_attr_buflen, 848 NULL, 849 }; 850 851 static const struct config_item_type usb9pfs_func_type = { 852 .ct_item_ops = &usb9pfs_item_ops, 853 .ct_attrs = usb9pfs_attrs, 854 .ct_owner = THIS_MODULE, 855 }; 856 857 static struct f_usb9pfs_dev *_usb9pfs_do_find_dev(const char *tag) 858 { 859 struct f_usb9pfs_dev *usb9pfs_dev; 860 861 if (!tag) 862 return NULL; 863 864 list_for_each_entry(usb9pfs_dev, &usbg_instance_list, usb9pfs_instance) { 865 if (strcmp(usb9pfs_dev->tag, tag) == 0) 866 return usb9pfs_dev; 867 } 868 869 return NULL; 870 } 871 872 static int usb9pfs_tag_instance(struct f_usb9pfs_dev *dev, const char *tag) 873 { 874 struct f_usb9pfs_dev *existing; 875 int ret = 0; 876 877 guard(mutex)(&usb9pfs_lock); 878 879 existing = _usb9pfs_do_find_dev(tag); 880 if (!existing) 881 strscpy(dev->tag, tag, ARRAY_SIZE(dev->tag)); 882 else if (existing != dev) 883 ret = -EBUSY; 884 885 return ret; 886 } 887 888 static int usb9pfs_set_inst_tag(struct usb_function_instance *fi, const char *tag) 889 { 890 if (strlen(tag) >= sizeof_field(struct f_usb9pfs_dev, tag)) 891 return -ENAMETOOLONG; 892 return usb9pfs_tag_instance(fi_to_f_usb9pfs_opts(fi)->dev, tag); 893 } 894 895 static void usb9pfs_free_instance(struct usb_function_instance *fi) 896 { 897 struct f_usb9pfs_opts *usb9pfs_opts = 898 container_of(fi, struct f_usb9pfs_opts, func_inst); 899 struct f_usb9pfs_dev *dev = usb9pfs_opts->dev; 900 901 mutex_lock(&usb9pfs_lock); 902 list_del(&dev->usb9pfs_instance); 903 mutex_unlock(&usb9pfs_lock); 904 905 kfree(usb9pfs_opts); 906 } 907 908 static struct usb_function_instance *usb9pfs_alloc_instance(void) 909 { 910 struct f_usb9pfs_opts *usb9pfs_opts; 911 struct f_usb9pfs_dev *dev; 912 913 usb9pfs_opts = kzalloc(sizeof(*usb9pfs_opts), GFP_KERNEL); 914 if (!usb9pfs_opts) 915 return ERR_PTR(-ENOMEM); 916 917 mutex_init(&usb9pfs_opts->lock); 918 919 usb9pfs_opts->func_inst.set_inst_name = usb9pfs_set_inst_tag; 920 usb9pfs_opts->func_inst.free_func_inst = usb9pfs_free_instance; 921 922 usb9pfs_opts->buflen = DEFAULT_BUFLEN; 923 924 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 925 if (!dev) { 926 kfree(usb9pfs_opts); 927 return ERR_PTR(-ENOMEM); 928 } 929 930 usb9pfs_opts->dev = dev; 931 dev->opts = usb9pfs_opts; 932 933 config_group_init_type_name(&usb9pfs_opts->func_inst.group, "", 934 &usb9pfs_func_type); 935 936 mutex_lock(&usb9pfs_lock); 937 list_add_tail(&dev->usb9pfs_instance, &usbg_instance_list); 938 mutex_unlock(&usb9pfs_lock); 939 940 return &usb9pfs_opts->func_inst; 941 } 942 DECLARE_USB_FUNCTION(usb9pfs, usb9pfs_alloc_instance, usb9pfs_alloc); 943 944 static int __init usb9pfs_modinit(void) 945 { 946 int ret; 947 948 INIT_LIST_HEAD(&usbg_instance_list); 949 950 ret = usb_function_register(&usb9pfsusb_func); 951 if (!ret) 952 v9fs_register_trans(&p9_usbg_trans); 953 954 return ret; 955 } 956 957 static void __exit usb9pfs_modexit(void) 958 { 959 usb_function_unregister(&usb9pfsusb_func); 960 v9fs_unregister_trans(&p9_usbg_trans); 961 } 962 963 module_init(usb9pfs_modinit); 964 module_exit(usb9pfs_modexit); 965 966 MODULE_ALIAS_9P("usbg"); 967 MODULE_LICENSE("GPL"); 968 MODULE_DESCRIPTION("USB gadget 9pfs transport"); 969 MODULE_AUTHOR("Michael Grzeschik"); 970