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
func_to_usb9pfs(struct usb_function * f)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
usb9pfs_queue_tx(struct f_usb9pfs * usb9pfs,struct p9_req_t * p9_tx_req,gfp_t gfp_flags)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
usb9pfs_queue_rx(struct f_usb9pfs * usb9pfs,struct usb_request * req,gfp_t gfp_flags)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
usb9pfs_transmit(struct f_usb9pfs * usb9pfs,struct p9_req_t * p9_req)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
usb9pfs_tx_complete(struct usb_ep * ep,struct usb_request * req)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
usb9pfs_rx_header(struct f_usb9pfs * usb9pfs,void * buf)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
usb9pfs_rx_complete(struct usb_ep * ep,struct usb_request * req)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
disable_ep(struct usb_composite_dev * cdev,struct usb_ep * ep)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
disable_usb9pfs(struct f_usb9pfs * usb9pfs)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
alloc_requests(struct usb_composite_dev * cdev,struct f_usb9pfs * usb9pfs)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
enable_endpoint(struct usb_composite_dev * cdev,struct f_usb9pfs * usb9pfs,struct usb_ep * ep)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
enable_usb9pfs(struct usb_composite_dev * cdev,struct f_usb9pfs * usb9pfs)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
p9_usbg_create(struct p9_client * client,struct fs_context * fc)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
usb9pfs_clear_tx(struct f_usb9pfs * usb9pfs)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
p9_usbg_close(struct p9_client * client)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
p9_usbg_request(struct p9_client * client,struct p9_req_t * p9_req)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
p9_usbg_cancel(struct p9_client * client,struct p9_req_t * req)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
usb9pfs_func_bind(struct usb_configuration * c,struct usb_function * f)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
usb9pfs_func_unbind(struct usb_configuration * c,struct usb_function * f)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
usb9pfs_free_func(struct usb_function * f)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
usb9pfs_set_alt(struct usb_function * f,unsigned int intf,unsigned int alt)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
usb9pfs_disable(struct usb_function * f)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
usb9pfs_alloc(struct usb_function_instance * fi)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
to_f_usb9pfs_opts(struct config_item * item)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
fi_to_f_usb9pfs_opts(struct usb_function_instance * fi)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
usb9pfs_attr_release(struct config_item * item)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
f_usb9pfs_opts_buflen_show(struct config_item * item,char * page)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
f_usb9pfs_opts_buflen_store(struct config_item * item,const char * page,size_t len)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
_usb9pfs_do_find_dev(const char * tag)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
usb9pfs_tag_instance(struct f_usb9pfs_dev * dev,const char * tag)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
usb9pfs_set_inst_tag(struct usb_function_instance * fi,const char * tag)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
usb9pfs_free_instance(struct usb_function_instance * fi)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
usb9pfs_alloc_instance(void)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
usb9pfs_modinit(void)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
usb9pfs_modexit(void)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