?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.2.1
[linux/fpc-iii.git] / drivers / usb / gadget / legacy / tcm_usb_gadget.c
blobc3c48088fced7b90703b068b2527635a6a5e01ea
1 /* Target based USB-Gadget
2 *
3 * UAS protocol handling, target callbacks, configfs handling,
4 * BBB (USB Mass Storage Class Bulk-Only (BBB) and Transport protocol handling.
5 *
6 * Author: Sebastian Andrzej Siewior <bigeasy at linutronix dot de>
7 * License: GPLv2 as published by FSF.
8 */
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/types.h>
12 #include <linux/string.h>
13 #include <linux/configfs.h>
14 #include <linux/ctype.h>
15 #include <linux/usb/ch9.h>
16 #include <linux/usb/composite.h>
17 #include <linux/usb/gadget.h>
18 #include <linux/usb/storage.h>
19 #include <scsi/scsi_tcq.h>
20 #include <target/target_core_base.h>
21 #include <target/target_core_fabric.h>
22 #include <target/target_core_fabric_configfs.h>
23 #include <target/configfs_macros.h>
24 #include <asm/unaligned.h>
25
26 #include "tcm_usb_gadget.h"
27
28 USB_GADGET_COMPOSITE_OPTIONS();
29
30 static inline struct f_uas *to_f_uas(struct usb_function *f)
31 {
32 return container_of(f, struct f_uas, function);
33 }
34
35 static void usbg_cmd_release(struct kref *);
36
37 static inline void usbg_cleanup_cmd(struct usbg_cmd *cmd)
38 {
39 kref_put(&cmd->ref, usbg_cmd_release);
40 }
41
42 /* Start bot.c code */
43
44 static int bot_enqueue_cmd_cbw(struct f_uas *fu)
45 {
46 int ret;
47
48 if (fu->flags & USBG_BOT_CMD_PEND)
49 return 0;
50
51 ret = usb_ep_queue(fu->ep_out, fu->cmd.req, GFP_ATOMIC);
52 if (!ret)
53 fu->flags |= USBG_BOT_CMD_PEND;
54 return ret;
55 }
56
57 static void bot_status_complete(struct usb_ep *ep, struct usb_request *req)
58 {
59 struct usbg_cmd *cmd = req->context;
60 struct f_uas *fu = cmd->fu;
61
62 usbg_cleanup_cmd(cmd);
63 if (req->status < 0) {
64 pr_err("ERR %s(%d)\n", __func__, __LINE__);
65 return;
66 }
67
68 /* CSW completed, wait for next CBW */
69 bot_enqueue_cmd_cbw(fu);
70 }
71
72 static void bot_enqueue_sense_code(struct f_uas *fu, struct usbg_cmd *cmd)
73 {
74 struct bulk_cs_wrap *csw = &fu->bot_status.csw;
75 int ret;
76 u8 *sense;
77 unsigned int csw_stat;
78
79 csw_stat = cmd->csw_code;
80
81 /*
82 * We can't send SENSE as a response. So we take ASC & ASCQ from our
83 * sense buffer and queue it and hope the host sends a REQUEST_SENSE
84 * command where it learns why we failed.
85 */
86 sense = cmd->sense_iu.sense;
87
88 csw->Tag = cmd->bot_tag;
89 csw->Status = csw_stat;
90 fu->bot_status.req->context = cmd;
91 ret = usb_ep_queue(fu->ep_in, fu->bot_status.req, GFP_ATOMIC);
92 if (ret)
93 pr_err("%s(%d) ERR: %d\n", __func__, __LINE__, ret);
94 }
95
96 static void bot_err_compl(struct usb_ep *ep, struct usb_request *req)
97 {
98 struct usbg_cmd *cmd = req->context;
99 struct f_uas *fu = cmd->fu;
100
101 if (req->status < 0)
102 pr_err("ERR %s(%d)\n", __func__, __LINE__);
103
104 if (cmd->data_len) {
105 if (cmd->data_len > ep->maxpacket) {
106 req->length = ep->maxpacket;
107 cmd->data_len -= ep->maxpacket;
108 } else {
109 req->length = cmd->data_len;
110 cmd->data_len = 0;
111 }
112
113 usb_ep_queue(ep, req, GFP_ATOMIC);
114 return ;
115 }
116 bot_enqueue_sense_code(fu, cmd);
117 }
118
119 static void bot_send_bad_status(struct usbg_cmd *cmd)
120 {
121 struct f_uas *fu = cmd->fu;
122 struct bulk_cs_wrap *csw = &fu->bot_status.csw;
123 struct usb_request *req;
124 struct usb_ep *ep;
125
126 csw->Residue = cpu_to_le32(cmd->data_len);
127
128 if (cmd->data_len) {
129 if (cmd->is_read) {
130 ep = fu->ep_in;
131 req = fu->bot_req_in;
132 } else {
133 ep = fu->ep_out;
134 req = fu->bot_req_out;
135 }
136
137 if (cmd->data_len > fu->ep_in->maxpacket) {
138 req->length = ep->maxpacket;
139 cmd->data_len -= ep->maxpacket;
140 } else {
141 req->length = cmd->data_len;
142 cmd->data_len = 0;
143 }
144 req->complete = bot_err_compl;
145 req->context = cmd;
146 req->buf = fu->cmd.buf;
147 usb_ep_queue(ep, req, GFP_KERNEL);
148 } else {
149 bot_enqueue_sense_code(fu, cmd);
150 }
151 }
152
153 static int bot_send_status(struct usbg_cmd *cmd, bool moved_data)
154 {
155 struct f_uas *fu = cmd->fu;
156 struct bulk_cs_wrap *csw = &fu->bot_status.csw;
157 int ret;
158
159 if (cmd->se_cmd.scsi_status == SAM_STAT_GOOD) {
160 if (!moved_data && cmd->data_len) {
161 /*
162 * the host wants to move data, we don't. Fill / empty
163 * the pipe and then send the csw with reside set.
164 */
165 cmd->csw_code = US_BULK_STAT_OK;
166 bot_send_bad_status(cmd);
167 return 0;
168 }
169
170 csw->Tag = cmd->bot_tag;
171 csw->Residue = cpu_to_le32(0);
172 csw->Status = US_BULK_STAT_OK;
173 fu->bot_status.req->context = cmd;
174
175 ret = usb_ep_queue(fu->ep_in, fu->bot_status.req, GFP_KERNEL);
176 if (ret)
177 pr_err("%s(%d) ERR: %d\n", __func__, __LINE__, ret);
178 } else {
179 cmd->csw_code = US_BULK_STAT_FAIL;
180 bot_send_bad_status(cmd);
181 }
182 return 0;
183 }
184
185 /*
186 * Called after command (no data transfer) or after the write (to device)
187 * operation is completed
188 */
189 static int bot_send_status_response(struct usbg_cmd *cmd)
190 {
191 bool moved_data = false;
192
193 if (!cmd->is_read)
194 moved_data = true;
195 return bot_send_status(cmd, moved_data);
196 }
197
198 /* Read request completed, now we have to send the CSW */
199 static void bot_read_compl(struct usb_ep *ep, struct usb_request *req)
200 {
201 struct usbg_cmd *cmd = req->context;
202
203 if (req->status < 0)
204 pr_err("ERR %s(%d)\n", __func__, __LINE__);
205
206 bot_send_status(cmd, true);
207 }
208
209 static int bot_send_read_response(struct usbg_cmd *cmd)
210 {
211 struct f_uas *fu = cmd->fu;
212 struct se_cmd *se_cmd = &cmd->se_cmd;
213 struct usb_gadget *gadget = fuas_to_gadget(fu);
214 int ret;
215
216 if (!cmd->data_len) {
217 cmd->csw_code = US_BULK_STAT_PHASE;
218 bot_send_bad_status(cmd);
219 return 0;
220 }
221
222 if (!gadget->sg_supported) {
223 cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);
224 if (!cmd->data_buf)
225 return -ENOMEM;
226
227 sg_copy_to_buffer(se_cmd->t_data_sg,
228 se_cmd->t_data_nents,
229 cmd->data_buf,
230 se_cmd->data_length);
231
232 fu->bot_req_in->buf = cmd->data_buf;
233 } else {
234 fu->bot_req_in->buf = NULL;
235 fu->bot_req_in->num_sgs = se_cmd->t_data_nents;
236 fu->bot_req_in->sg = se_cmd->t_data_sg;
237 }
238
239 fu->bot_req_in->complete = bot_read_compl;
240 fu->bot_req_in->length = se_cmd->data_length;
241 fu->bot_req_in->context = cmd;
242 ret = usb_ep_queue(fu->ep_in, fu->bot_req_in, GFP_ATOMIC);
243 if (ret)
244 pr_err("%s(%d)\n", __func__, __LINE__);
245 return 0;
246 }
247
248 static void usbg_data_write_cmpl(struct usb_ep *, struct usb_request *);
249 static int usbg_prepare_w_request(struct usbg_cmd *, struct usb_request *);
250
251 static int bot_send_write_request(struct usbg_cmd *cmd)
252 {
253 struct f_uas *fu = cmd->fu;
254 struct se_cmd *se_cmd = &cmd->se_cmd;
255 struct usb_gadget *gadget = fuas_to_gadget(fu);
256 int ret;
257
258 init_completion(&cmd->write_complete);
259 cmd->fu = fu;
260
261 if (!cmd->data_len) {
262 cmd->csw_code = US_BULK_STAT_PHASE;
263 return -EINVAL;
264 }
265
266 if (!gadget->sg_supported) {
267 cmd->data_buf = kmalloc(se_cmd->data_length, GFP_KERNEL);
268 if (!cmd->data_buf)
269 return -ENOMEM;
270
271 fu->bot_req_out->buf = cmd->data_buf;
272 } else {
273 fu->bot_req_out->buf = NULL;
274 fu->bot_req_out->num_sgs = se_cmd->t_data_nents;
275 fu->bot_req_out->sg = se_cmd->t_data_sg;
276 }
277
278 fu->bot_req_out->complete = usbg_data_write_cmpl;
279 fu->bot_req_out->length = se_cmd->data_length;
280 fu->bot_req_out->context = cmd;
281
282 ret = usbg_prepare_w_request(cmd, fu->bot_req_out);
283 if (ret)
284 goto cleanup;
285 ret = usb_ep_queue(fu->ep_out, fu->bot_req_out, GFP_KERNEL);
286 if (ret)
287 pr_err("%s(%d)\n", __func__, __LINE__);
288
289 wait_for_completion(&cmd->write_complete);
290 target_execute_cmd(se_cmd);
291 cleanup:
292 return ret;
293 }
294
295 static int bot_submit_command(struct f_uas *, void *, unsigned int);
296
297 static void bot_cmd_complete(struct usb_ep *ep, struct usb_request *req)
298 {
299 struct f_uas *fu = req->context;
300 int ret;
301
302 fu->flags &= ~USBG_BOT_CMD_PEND;
303
304 if (req->status < 0)
305 return;
306
307 ret = bot_submit_command(fu, req->buf, req->actual);
308 if (ret)
309 pr_err("%s(%d): %d\n", __func__, __LINE__, ret);
310 }
311
312 static int bot_prepare_reqs(struct f_uas *fu)
313 {
314 int ret;
315
316 fu->bot_req_in = usb_ep_alloc_request(fu->ep_in, GFP_KERNEL);
317 if (!fu->bot_req_in)
318 goto err;
319
320 fu->bot_req_out = usb_ep_alloc_request(fu->ep_out, GFP_KERNEL);
321 if (!fu->bot_req_out)
322 goto err_out;
323
324 fu->cmd.req = usb_ep_alloc_request(fu->ep_out, GFP_KERNEL);
325 if (!fu->cmd.req)
326 goto err_cmd;
327
328 fu->bot_status.req = usb_ep_alloc_request(fu->ep_in, GFP_KERNEL);
329 if (!fu->bot_status.req)
330 goto err_sts;
331
332 fu->bot_status.req->buf = &fu->bot_status.csw;
333 fu->bot_status.req->length = US_BULK_CS_WRAP_LEN;
334 fu->bot_status.req->complete = bot_status_complete;
335 fu->bot_status.csw.Signature = cpu_to_le32(US_BULK_CS_SIGN);
336
337 fu->cmd.buf = kmalloc(fu->ep_out->maxpacket, GFP_KERNEL);
338 if (!fu->cmd.buf)
339 goto err_buf;
340
341 fu->cmd.req->complete = bot_cmd_complete;
342 fu->cmd.req->buf = fu->cmd.buf;
343 fu->cmd.req->length = fu->ep_out->maxpacket;
344 fu->cmd.req->context = fu;
345
346 ret = bot_enqueue_cmd_cbw(fu);
347 if (ret)
348 goto err_queue;
349 return 0;
350 err_queue:
351 kfree(fu->cmd.buf);
352 fu->cmd.buf = NULL;
353 err_buf:
354 usb_ep_free_request(fu->ep_in, fu->bot_status.req);
355 err_sts:
356 usb_ep_free_request(fu->ep_out, fu->cmd.req);
357 fu->cmd.req = NULL;
358 err_cmd:
359 usb_ep_free_request(fu->ep_out, fu->bot_req_out);
360 fu->bot_req_out = NULL;
361 err_out:
362 usb_ep_free_request(fu->ep_in, fu->bot_req_in);
363 fu->bot_req_in = NULL;
364 err:
365 pr_err("BOT: endpoint setup failed\n");
366 return -ENOMEM;
367 }
368
369 static void bot_cleanup_old_alt(struct f_uas *fu)
370 {
371 if (!(fu->flags & USBG_ENABLED))
372 return;
373
374 usb_ep_disable(fu->ep_in);
375 usb_ep_disable(fu->ep_out);
376
377 if (!fu->bot_req_in)
378 return;
379
380 usb_ep_free_request(fu->ep_in, fu->bot_req_in);
381 usb_ep_free_request(fu->ep_out, fu->bot_req_out);
382 usb_ep_free_request(fu->ep_out, fu->cmd.req);
383 usb_ep_free_request(fu->ep_out, fu->bot_status.req);
384
385 kfree(fu->cmd.buf);
386
387 fu->bot_req_in = NULL;
388 fu->bot_req_out = NULL;
389 fu->cmd.req = NULL;
390 fu->bot_status.req = NULL;
391 fu->cmd.buf = NULL;
392 }
393
394 static void bot_set_alt(struct f_uas *fu)
395 {
396 struct usb_function *f = &fu->function;
397 struct usb_gadget *gadget = f->config->cdev->gadget;
398 int ret;
399
400 fu->flags = USBG_IS_BOT;
401
402 config_ep_by_speed(gadget, f, fu->ep_in);
403 ret = usb_ep_enable(fu->ep_in);
404 if (ret)
405 goto err_b_in;
406
407 config_ep_by_speed(gadget, f, fu->ep_out);
408 ret = usb_ep_enable(fu->ep_out);
409 if (ret)
410 goto err_b_out;
411
412 ret = bot_prepare_reqs(fu);
413 if (ret)
414 goto err_wq;
415 fu->flags |= USBG_ENABLED;
416 pr_info("Using the BOT protocol\n");
417 return;
418 err_wq:
419 usb_ep_disable(fu->ep_out);
420 err_b_out:
421 usb_ep_disable(fu->ep_in);
422 err_b_in:
423 fu->flags = USBG_IS_BOT;
424 }
425
426 static int usbg_bot_setup(struct usb_function *f,
427 const struct usb_ctrlrequest *ctrl)
428 {
429 struct f_uas *fu = to_f_uas(f);
430 struct usb_composite_dev *cdev = f->config->cdev;
431 u16 w_value = le16_to_cpu(ctrl->wValue);
432 u16 w_length = le16_to_cpu(ctrl->wLength);
433 int luns;
434 u8 *ret_lun;
435
436 switch (ctrl->bRequest) {
437 case US_BULK_GET_MAX_LUN:
438 if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_CLASS |
439 USB_RECIP_INTERFACE))
440 return -ENOTSUPP;
441
442 if (w_length < 1)
443 return -EINVAL;
444 if (w_value != 0)
445 return -EINVAL;
446 luns = atomic_read(&fu->tpg->tpg_port_count);
447 if (!luns) {
448 pr_err("No LUNs configured?\n");
449 return -EINVAL;
450 }
451 /*
452 * If 4 LUNs are present we return 3 i.e. LUN 0..3 can be
453 * accessed. The upper limit is 0xf
454 */
455 luns--;
456 if (luns > 0xf) {
457 pr_info_once("Limiting the number of luns to 16\n");
458 luns = 0xf;
459 }
460 ret_lun = cdev->req->buf;
461 *ret_lun = luns;
462 cdev->req->length = 1;
463 return usb_ep_queue(cdev->gadget->ep0, cdev->req, GFP_ATOMIC);
464 break;
465
466 case US_BULK_RESET_REQUEST:
467 /* XXX maybe we should remove previous requests for IN + OUT */
468 bot_enqueue_cmd_cbw(fu);
469 return 0;
470 break;
471 }
472 return -ENOTSUPP;
473 }
474
475 /* Start uas.c code */
476
477 static void uasp_cleanup_one_stream(struct f_uas *fu, struct uas_stream *stream)
478 {
479 /* We have either all three allocated or none */
480 if (!stream->req_in)
481 return;
482
483 usb_ep_free_request(fu->ep_in, stream->req_in);
484 usb_ep_free_request(fu->ep_out, stream->req_out);
485 usb_ep_free_request(fu->ep_status, stream->req_status);
486
487 stream->req_in = NULL;
488 stream->req_out = NULL;
489 stream->req_status = NULL;
490 }
491
492 static void uasp_free_cmdreq(struct f_uas *fu)
493 {
494 usb_ep_free_request(fu->ep_cmd, fu->cmd.req);
495 kfree(fu->cmd.buf);
496 fu->cmd.req = NULL;
497 fu->cmd.buf = NULL;
498 }
499
500 static void uasp_cleanup_old_alt(struct f_uas *fu)
501 {
502 int i;
503
504 if (!(fu->flags & USBG_ENABLED))
505 return;
506
507 usb_ep_disable(fu->ep_in);
508 usb_ep_disable(fu->ep_out);
509 usb_ep_disable(fu->ep_status);
510 usb_ep_disable(fu->ep_cmd);
511
512 for (i = 0; i < UASP_SS_EP_COMP_NUM_STREAMS; i++)
513 uasp_cleanup_one_stream(fu, &fu->stream[i]);
514 uasp_free_cmdreq(fu);
515 }
516
517 static void uasp_status_data_cmpl(struct usb_ep *ep, struct usb_request *req);
518
519 static int uasp_prepare_r_request(struct usbg_cmd *cmd)
520 {
521 struct se_cmd *se_cmd = &cmd->se_cmd;
522 struct f_uas *fu = cmd->fu;
523 struct usb_gadget *gadget = fuas_to_gadget(fu);
524 struct uas_stream *stream = cmd->stream;
525
526 if (!gadget->sg_supported) {
527 cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);
528 if (!cmd->data_buf)
529 return -ENOMEM;
530
531 sg_copy_to_buffer(se_cmd->t_data_sg,
532 se_cmd->t_data_nents,
533 cmd->data_buf,
534 se_cmd->data_length);
535
536 stream->req_in->buf = cmd->data_buf;
537 } else {
538 stream->req_in->buf = NULL;
539 stream->req_in->num_sgs = se_cmd->t_data_nents;
540 stream->req_in->sg = se_cmd->t_data_sg;
541 }
542
543 stream->req_in->complete = uasp_status_data_cmpl;
544 stream->req_in->length = se_cmd->data_length;
545 stream->req_in->context = cmd;
546
547 cmd->state = UASP_SEND_STATUS;
548 return 0;
549 }
550
551 static void uasp_prepare_status(struct usbg_cmd *cmd)
552 {
553 struct se_cmd *se_cmd = &cmd->se_cmd;
554 struct sense_iu *iu = &cmd->sense_iu;
555 struct uas_stream *stream = cmd->stream;
556
557 cmd->state = UASP_QUEUE_COMMAND;
558 iu->iu_id = IU_ID_STATUS;
559 iu->tag = cpu_to_be16(cmd->tag);
560
561 /*
562 * iu->status_qual = cpu_to_be16(STATUS QUALIFIER SAM-4. Where R U?);
563 */
564 iu->len = cpu_to_be16(se_cmd->scsi_sense_length);
565 iu->status = se_cmd->scsi_status;
566 stream->req_status->context = cmd;
567 stream->req_status->length = se_cmd->scsi_sense_length + 16;
568 stream->req_status->buf = iu;
569 stream->req_status->complete = uasp_status_data_cmpl;
570 }
571
572 static void uasp_status_data_cmpl(struct usb_ep *ep, struct usb_request *req)
573 {
574 struct usbg_cmd *cmd = req->context;
575 struct uas_stream *stream = cmd->stream;
576 struct f_uas *fu = cmd->fu;
577 int ret;
578
579 if (req->status < 0)
580 goto cleanup;
581
582 switch (cmd->state) {
583 case UASP_SEND_DATA:
584 ret = uasp_prepare_r_request(cmd);
585 if (ret)
586 goto cleanup;
587 ret = usb_ep_queue(fu->ep_in, stream->req_in, GFP_ATOMIC);
588 if (ret)
589 pr_err("%s(%d) => %d\n", __func__, __LINE__, ret);
590 break;
591
592 case UASP_RECEIVE_DATA:
593 ret = usbg_prepare_w_request(cmd, stream->req_out);
594 if (ret)
595 goto cleanup;
596 ret = usb_ep_queue(fu->ep_out, stream->req_out, GFP_ATOMIC);
597 if (ret)
598 pr_err("%s(%d) => %d\n", __func__, __LINE__, ret);
599 break;
600
601 case UASP_SEND_STATUS:
602 uasp_prepare_status(cmd);
603 ret = usb_ep_queue(fu->ep_status, stream->req_status,
604 GFP_ATOMIC);
605 if (ret)
606 pr_err("%s(%d) => %d\n", __func__, __LINE__, ret);
607 break;
608
609 case UASP_QUEUE_COMMAND:
610 usbg_cleanup_cmd(cmd);
611 usb_ep_queue(fu->ep_cmd, fu->cmd.req, GFP_ATOMIC);
612 break;
613
614 default:
615 BUG();
616 }
617 return;
618
619 cleanup:
620 usbg_cleanup_cmd(cmd);
621 }
622
623 static int uasp_send_status_response(struct usbg_cmd *cmd)
624 {
625 struct f_uas *fu = cmd->fu;
626 struct uas_stream *stream = cmd->stream;
627 struct sense_iu *iu = &cmd->sense_iu;
628
629 iu->tag = cpu_to_be16(cmd->tag);
630 stream->req_status->complete = uasp_status_data_cmpl;
631 stream->req_status->context = cmd;
632 cmd->fu = fu;
633 uasp_prepare_status(cmd);
634 return usb_ep_queue(fu->ep_status, stream->req_status, GFP_ATOMIC);
635 }
636
637 static int uasp_send_read_response(struct usbg_cmd *cmd)
638 {
639 struct f_uas *fu = cmd->fu;
640 struct uas_stream *stream = cmd->stream;
641 struct sense_iu *iu = &cmd->sense_iu;
642 int ret;
643
644 cmd->fu = fu;
645
646 iu->tag = cpu_to_be16(cmd->tag);
647 if (fu->flags & USBG_USE_STREAMS) {
648
649 ret = uasp_prepare_r_request(cmd);
650 if (ret)
651 goto out;
652 ret = usb_ep_queue(fu->ep_in, stream->req_in, GFP_ATOMIC);
653 if (ret) {
654 pr_err("%s(%d) => %d\n", __func__, __LINE__, ret);
655 kfree(cmd->data_buf);
656 cmd->data_buf = NULL;
657 }
658
659 } else {
660
661 iu->iu_id = IU_ID_READ_READY;
662 iu->tag = cpu_to_be16(cmd->tag);
663
664 stream->req_status->complete = uasp_status_data_cmpl;
665 stream->req_status->context = cmd;
666
667 cmd->state = UASP_SEND_DATA;
668 stream->req_status->buf = iu;
669 stream->req_status->length = sizeof(struct iu);
670
671 ret = usb_ep_queue(fu->ep_status, stream->req_status,
672 GFP_ATOMIC);
673 if (ret)
674 pr_err("%s(%d) => %d\n", __func__, __LINE__, ret);
675 }
676 out:
677 return ret;
678 }
679
680 static int uasp_send_write_request(struct usbg_cmd *cmd)
681 {
682 struct f_uas *fu = cmd->fu;
683 struct se_cmd *se_cmd = &cmd->se_cmd;
684 struct uas_stream *stream = cmd->stream;
685 struct sense_iu *iu = &cmd->sense_iu;
686 int ret;
687
688 init_completion(&cmd->write_complete);
689 cmd->fu = fu;
690
691 iu->tag = cpu_to_be16(cmd->tag);
692
693 if (fu->flags & USBG_USE_STREAMS) {
694
695 ret = usbg_prepare_w_request(cmd, stream->req_out);
696 if (ret)
697 goto cleanup;
698 ret = usb_ep_queue(fu->ep_out, stream->req_out, GFP_ATOMIC);
699 if (ret)
700 pr_err("%s(%d)\n", __func__, __LINE__);
701
702 } else {
703
704 iu->iu_id = IU_ID_WRITE_READY;
705 iu->tag = cpu_to_be16(cmd->tag);
706
707 stream->req_status->complete = uasp_status_data_cmpl;
708 stream->req_status->context = cmd;
709
710 cmd->state = UASP_RECEIVE_DATA;
711 stream->req_status->buf = iu;
712 stream->req_status->length = sizeof(struct iu);
713
714 ret = usb_ep_queue(fu->ep_status, stream->req_status,
715 GFP_ATOMIC);
716 if (ret)
717 pr_err("%s(%d)\n", __func__, __LINE__);
718 }
719
720 wait_for_completion(&cmd->write_complete);
721 target_execute_cmd(se_cmd);
722 cleanup:
723 return ret;
724 }
725
726 static int usbg_submit_command(struct f_uas *, void *, unsigned int);
727
728 static void uasp_cmd_complete(struct usb_ep *ep, struct usb_request *req)
729 {
730 struct f_uas *fu = req->context;
731 int ret;
732
733 if (req->status < 0)
734 return;
735
736 ret = usbg_submit_command(fu, req->buf, req->actual);
737 /*
738 * Once we tune for performance enqueue the command req here again so
739 * we can receive a second command while we processing this one. Pay
740 * attention to properly sync STAUS endpoint with DATA IN + OUT so you
741 * don't break HS.
742 */
743 if (!ret)
744 return;
745 usb_ep_queue(fu->ep_cmd, fu->cmd.req, GFP_ATOMIC);
746 }
747
748 static int uasp_alloc_stream_res(struct f_uas *fu, struct uas_stream *stream)
749 {
750 stream->req_in = usb_ep_alloc_request(fu->ep_in, GFP_KERNEL);
751 if (!stream->req_in)
752 goto out;
753
754 stream->req_out = usb_ep_alloc_request(fu->ep_out, GFP_KERNEL);
755 if (!stream->req_out)
756 goto err_out;
757
758 stream->req_status = usb_ep_alloc_request(fu->ep_status, GFP_KERNEL);
759 if (!stream->req_status)
760 goto err_sts;
761
762 return 0;
763 err_sts:
764 usb_ep_free_request(fu->ep_status, stream->req_status);
765 stream->req_status = NULL;
766 err_out:
767 usb_ep_free_request(fu->ep_out, stream->req_out);
768 stream->req_out = NULL;
769 out:
770 return -ENOMEM;
771 }
772
773 static int uasp_alloc_cmd(struct f_uas *fu)
774 {
775 fu->cmd.req = usb_ep_alloc_request(fu->ep_cmd, GFP_KERNEL);
776 if (!fu->cmd.req)
777 goto err;
778
779 fu->cmd.buf = kmalloc(fu->ep_cmd->maxpacket, GFP_KERNEL);
780 if (!fu->cmd.buf)
781 goto err_buf;
782
783 fu->cmd.req->complete = uasp_cmd_complete;
784 fu->cmd.req->buf = fu->cmd.buf;
785 fu->cmd.req->length = fu->ep_cmd->maxpacket;
786 fu->cmd.req->context = fu;
787 return 0;
788
789 err_buf:
790 usb_ep_free_request(fu->ep_cmd, fu->cmd.req);
791 err:
792 return -ENOMEM;
793 }
794
795 static void uasp_setup_stream_res(struct f_uas *fu, int max_streams)
796 {
797 int i;
798
799 for (i = 0; i < max_streams; i++) {
800 struct uas_stream *s = &fu->stream[i];
801
802 s->req_in->stream_id = i + 1;
803 s->req_out->stream_id = i + 1;
804 s->req_status->stream_id = i + 1;
805 }
806 }
807
808 static int uasp_prepare_reqs(struct f_uas *fu)
809 {
810 int ret;
811 int i;
812 int max_streams;
813
814 if (fu->flags & USBG_USE_STREAMS)
815 max_streams = UASP_SS_EP_COMP_NUM_STREAMS;
816 else
817 max_streams = 1;
818
819 for (i = 0; i < max_streams; i++) {
820 ret = uasp_alloc_stream_res(fu, &fu->stream[i]);
821 if (ret)
822 goto err_cleanup;
823 }
824
825 ret = uasp_alloc_cmd(fu);
826 if (ret)
827 goto err_free_stream;
828 uasp_setup_stream_res(fu, max_streams);
829
830 ret = usb_ep_queue(fu->ep_cmd, fu->cmd.req, GFP_ATOMIC);
831 if (ret)
832 goto err_free_stream;
833
834 return 0;
835
836 err_free_stream:
837 uasp_free_cmdreq(fu);
838
839 err_cleanup:
840 if (i) {
841 do {
842 uasp_cleanup_one_stream(fu, &fu->stream[i - 1]);
843 i--;
844 } while (i);
845 }
846 pr_err("UASP: endpoint setup failed\n");
847 return ret;
848 }
849
850 static void uasp_set_alt(struct f_uas *fu)
851 {
852 struct usb_function *f = &fu->function;
853 struct usb_gadget *gadget = f->config->cdev->gadget;
854 int ret;
855
856 fu->flags = USBG_IS_UAS;
857
858 if (gadget->speed == USB_SPEED_SUPER)
859 fu->flags |= USBG_USE_STREAMS;
860
861 config_ep_by_speed(gadget, f, fu->ep_in);
862 ret = usb_ep_enable(fu->ep_in);
863 if (ret)
864 goto err_b_in;
865
866 config_ep_by_speed(gadget, f, fu->ep_out);
867 ret = usb_ep_enable(fu->ep_out);
868 if (ret)
869 goto err_b_out;
870
871 config_ep_by_speed(gadget, f, fu->ep_cmd);
872 ret = usb_ep_enable(fu->ep_cmd);
873 if (ret)
874 goto err_cmd;
875 config_ep_by_speed(gadget, f, fu->ep_status);
876 ret = usb_ep_enable(fu->ep_status);
877 if (ret)
878 goto err_status;
879
880 ret = uasp_prepare_reqs(fu);
881 if (ret)
882 goto err_wq;
883 fu->flags |= USBG_ENABLED;
884
885 pr_info("Using the UAS protocol\n");
886 return;
887 err_wq:
888 usb_ep_disable(fu->ep_status);
889 err_status:
890 usb_ep_disable(fu->ep_cmd);
891 err_cmd:
892 usb_ep_disable(fu->ep_out);
893 err_b_out:
894 usb_ep_disable(fu->ep_in);
895 err_b_in:
896 fu->flags = 0;
897 }
898
899 static int get_cmd_dir(const unsigned char *cdb)
900 {
901 int ret;
902
903 switch (cdb[0]) {
904 case READ_6:
905 case READ_10:
906 case READ_12:
907 case READ_16:
908 case INQUIRY:
909 case MODE_SENSE:
910 case MODE_SENSE_10:
911 case SERVICE_ACTION_IN_16:
912 case MAINTENANCE_IN:
913 case PERSISTENT_RESERVE_IN:
914 case SECURITY_PROTOCOL_IN:
915 case ACCESS_CONTROL_IN:
916 case REPORT_LUNS:
917 case READ_BLOCK_LIMITS:
918 case READ_POSITION:
919 case READ_CAPACITY:
920 case READ_TOC:
921 case READ_FORMAT_CAPACITIES:
922 case REQUEST_SENSE:
923 ret = DMA_FROM_DEVICE;
924 break;
925
926 case WRITE_6:
927 case WRITE_10:
928 case WRITE_12:
929 case WRITE_16:
930 case MODE_SELECT:
931 case MODE_SELECT_10:
932 case WRITE_VERIFY:
933 case WRITE_VERIFY_12:
934 case PERSISTENT_RESERVE_OUT:
935 case MAINTENANCE_OUT:
936 case SECURITY_PROTOCOL_OUT:
937 case ACCESS_CONTROL_OUT:
938 ret = DMA_TO_DEVICE;
939 break;
940 case ALLOW_MEDIUM_REMOVAL:
941 case TEST_UNIT_READY:
942 case SYNCHRONIZE_CACHE:
943 case START_STOP:
944 case ERASE:
945 case REZERO_UNIT:
946 case SEEK_10:
947 case SPACE:
948 case VERIFY:
949 case WRITE_FILEMARKS:
950 ret = DMA_NONE;
951 break;
952 default:
953 pr_warn("target: Unknown data direction for SCSI Opcode "
954 "0x%02x\n", cdb[0]);
955 ret = -EINVAL;
956 }
957 return ret;
958 }
959
960 static void usbg_data_write_cmpl(struct usb_ep *ep, struct usb_request *req)
961 {
962 struct usbg_cmd *cmd = req->context;
963 struct se_cmd *se_cmd = &cmd->se_cmd;
964
965 if (req->status < 0) {
966 pr_err("%s() state %d transfer failed\n", __func__, cmd->state);
967 goto cleanup;
968 }
969
970 if (req->num_sgs == 0) {
971 sg_copy_from_buffer(se_cmd->t_data_sg,
972 se_cmd->t_data_nents,
973 cmd->data_buf,
974 se_cmd->data_length);
975 }
976
977 complete(&cmd->write_complete);
978 return;
979
980 cleanup:
981 usbg_cleanup_cmd(cmd);
982 }
983
984 static int usbg_prepare_w_request(struct usbg_cmd *cmd, struct usb_request *req)
985 {
986 struct se_cmd *se_cmd = &cmd->se_cmd;
987 struct f_uas *fu = cmd->fu;
988 struct usb_gadget *gadget = fuas_to_gadget(fu);
989
990 if (!gadget->sg_supported) {
991 cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);
992 if (!cmd->data_buf)
993 return -ENOMEM;
994
995 req->buf = cmd->data_buf;
996 } else {
997 req->buf = NULL;
998 req->num_sgs = se_cmd->t_data_nents;
999 req->sg = se_cmd->t_data_sg;
1000 }
1001
1002 req->complete = usbg_data_write_cmpl;
1003 req->length = se_cmd->data_length;
1004 req->context = cmd;
1005 return 0;
1006 }
1007
1008 static int usbg_send_status_response(struct se_cmd *se_cmd)
1009 {
1010 struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
1011 se_cmd);
1012 struct f_uas *fu = cmd->fu;
1013
1014 if (fu->flags & USBG_IS_BOT)
1015 return bot_send_status_response(cmd);
1016 else
1017 return uasp_send_status_response(cmd);
1018 }
1019
1020 static int usbg_send_write_request(struct se_cmd *se_cmd)
1021 {
1022 struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
1023 se_cmd);
1024 struct f_uas *fu = cmd->fu;
1025
1026 if (fu->flags & USBG_IS_BOT)
1027 return bot_send_write_request(cmd);
1028 else
1029 return uasp_send_write_request(cmd);
1030 }
1031
1032 static int usbg_send_read_response(struct se_cmd *se_cmd)
1033 {
1034 struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
1035 se_cmd);
1036 struct f_uas *fu = cmd->fu;
1037
1038 if (fu->flags & USBG_IS_BOT)
1039 return bot_send_read_response(cmd);
1040 else
1041 return uasp_send_read_response(cmd);
1042 }
1043
1044 static void usbg_cmd_work(struct work_struct *work)
1045 {
1046 struct usbg_cmd *cmd = container_of(work, struct usbg_cmd, work);
1047 struct se_cmd *se_cmd;
1048 struct tcm_usbg_nexus *tv_nexus;
1049 struct usbg_tpg *tpg;
1050 int dir;
1051
1052 se_cmd = &cmd->se_cmd;
1053 tpg = cmd->fu->tpg;
1054 tv_nexus = tpg->tpg_nexus;
1055 dir = get_cmd_dir(cmd->cmd_buf);
1056 if (dir < 0) {
1057 transport_init_se_cmd(se_cmd,
1058 tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo,
1059 tv_nexus->tvn_se_sess, cmd->data_len, DMA_NONE,
1060 cmd->prio_attr, cmd->sense_iu.sense);
1061 goto out;
1062 }
1063
1064 if (target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
1065 cmd->cmd_buf, cmd->sense_iu.sense, cmd->unpacked_lun,
1066 0, cmd->prio_attr, dir, TARGET_SCF_UNKNOWN_SIZE) < 0)
1067 goto out;
1068
1069 return;
1070
1071 out:
1072 transport_send_check_condition_and_sense(se_cmd,
1073 TCM_UNSUPPORTED_SCSI_OPCODE, 1);
1074 usbg_cleanup_cmd(cmd);
1075 }
1076
1077 static int usbg_submit_command(struct f_uas *fu,
1078 void *cmdbuf, unsigned int len)
1079 {
1080 struct command_iu *cmd_iu = cmdbuf;
1081 struct usbg_cmd *cmd;
1082 struct usbg_tpg *tpg;
1083 struct se_cmd *se_cmd;
1084 struct tcm_usbg_nexus *tv_nexus;
1085 u32 cmd_len;
1086 int ret;
1087
1088 if (cmd_iu->iu_id != IU_ID_COMMAND) {
1089 pr_err("Unsupported type %d\n", cmd_iu->iu_id);
1090 return -EINVAL;
1091 }
1092
1093 cmd = kzalloc(sizeof *cmd, GFP_ATOMIC);
1094 if (!cmd)
1095 return -ENOMEM;
1096
1097 cmd->fu = fu;
1098
1099 /* XXX until I figure out why I can't free in on complete */
1100 kref_init(&cmd->ref);
1101 kref_get(&cmd->ref);
1102
1103 tpg = fu->tpg;
1104 cmd_len = (cmd_iu->len & ~0x3) + 16;
1105 if (cmd_len > USBG_MAX_CMD)
1106 goto err;
1107
1108 memcpy(cmd->cmd_buf, cmd_iu->cdb, cmd_len);
1109
1110 cmd->tag = be16_to_cpup(&cmd_iu->tag);
1111 cmd->se_cmd.tag = cmd->tag;
1112 if (fu->flags & USBG_USE_STREAMS) {
1113 if (cmd->tag > UASP_SS_EP_COMP_NUM_STREAMS)
1114 goto err;
1115 if (!cmd->tag)
1116 cmd->stream = &fu->stream[0];
1117 else
1118 cmd->stream = &fu->stream[cmd->tag - 1];
1119 } else {
1120 cmd->stream = &fu->stream[0];
1121 }
1122
1123 tv_nexus = tpg->tpg_nexus;
1124 if (!tv_nexus) {
1125 pr_err("Missing nexus, ignoring command\n");
1126 goto err;
1127 }
1128
1129 switch (cmd_iu->prio_attr & 0x7) {
1130 case UAS_HEAD_TAG:
1131 cmd->prio_attr = TCM_HEAD_TAG;
1132 break;
1133 case UAS_ORDERED_TAG:
1134 cmd->prio_attr = TCM_ORDERED_TAG;
1135 break;
1136 case UAS_ACA:
1137 cmd->prio_attr = TCM_ACA_TAG;
1138 break;
1139 default:
1140 pr_debug_once("Unsupported prio_attr: %02x.\n",
1141 cmd_iu->prio_attr);
1142 case UAS_SIMPLE_TAG:
1143 cmd->prio_attr = TCM_SIMPLE_TAG;
1144 break;
1145 }
1146
1147 se_cmd = &cmd->se_cmd;
1148 cmd->unpacked_lun = scsilun_to_int(&cmd_iu->lun);
1149
1150 INIT_WORK(&cmd->work, usbg_cmd_work);
1151 ret = queue_work(tpg->workqueue, &cmd->work);
1152 if (ret < 0)
1153 goto err;
1154
1155 return 0;
1156 err:
1157 kfree(cmd);
1158 return -EINVAL;
1159 }
1160
1161 static void bot_cmd_work(struct work_struct *work)
1162 {
1163 struct usbg_cmd *cmd = container_of(work, struct usbg_cmd, work);
1164 struct se_cmd *se_cmd;
1165 struct tcm_usbg_nexus *tv_nexus;
1166 struct usbg_tpg *tpg;
1167 int dir;
1168
1169 se_cmd = &cmd->se_cmd;
1170 tpg = cmd->fu->tpg;
1171 tv_nexus = tpg->tpg_nexus;
1172 dir = get_cmd_dir(cmd->cmd_buf);
1173 if (dir < 0) {
1174 transport_init_se_cmd(se_cmd,
1175 tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo,
1176 tv_nexus->tvn_se_sess, cmd->data_len, DMA_NONE,
1177 cmd->prio_attr, cmd->sense_iu.sense);
1178 goto out;
1179 }
1180
1181 if (target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
1182 cmd->cmd_buf, cmd->sense_iu.sense, cmd->unpacked_lun,
1183 cmd->data_len, cmd->prio_attr, dir, 0) < 0)
1184 goto out;
1185
1186 return;
1187
1188 out:
1189 transport_send_check_condition_and_sense(se_cmd,
1190 TCM_UNSUPPORTED_SCSI_OPCODE, 1);
1191 usbg_cleanup_cmd(cmd);
1192 }
1193
1194 static int bot_submit_command(struct f_uas *fu,
1195 void *cmdbuf, unsigned int len)
1196 {
1197 struct bulk_cb_wrap *cbw = cmdbuf;
1198 struct usbg_cmd *cmd;
1199 struct usbg_tpg *tpg;
1200 struct se_cmd *se_cmd;
1201 struct tcm_usbg_nexus *tv_nexus;
1202 u32 cmd_len;
1203 int ret;
1204
1205 if (cbw->Signature != cpu_to_le32(US_BULK_CB_SIGN)) {
1206 pr_err("Wrong signature on CBW\n");
1207 return -EINVAL;
1208 }
1209 if (len != 31) {
1210 pr_err("Wrong length for CBW\n");
1211 return -EINVAL;
1212 }
1213
1214 cmd_len = cbw->Length;
1215 if (cmd_len < 1 || cmd_len > 16)
1216 return -EINVAL;
1217
1218 cmd = kzalloc(sizeof *cmd, GFP_ATOMIC);
1219 if (!cmd)
1220 return -ENOMEM;
1221
1222 cmd->fu = fu;
1223
1224 /* XXX until I figure out why I can't free in on complete */
1225 kref_init(&cmd->ref);
1226 kref_get(&cmd->ref);
1227
1228 tpg = fu->tpg;
1229
1230 memcpy(cmd->cmd_buf, cbw->CDB, cmd_len);
1231
1232 cmd->bot_tag = cbw->Tag;
1233
1234 tv_nexus = tpg->tpg_nexus;
1235 if (!tv_nexus) {
1236 pr_err("Missing nexus, ignoring command\n");
1237 goto err;
1238 }
1239
1240 cmd->prio_attr = TCM_SIMPLE_TAG;
1241 se_cmd = &cmd->se_cmd;
1242 cmd->unpacked_lun = cbw->Lun;
1243 cmd->is_read = cbw->Flags & US_BULK_FLAG_IN ? 1 : 0;
1244 cmd->data_len = le32_to_cpu(cbw->DataTransferLength);
1245 cmd->se_cmd.tag = le32_to_cpu(cmd->bot_tag);
1246
1247 INIT_WORK(&cmd->work, bot_cmd_work);
1248 ret = queue_work(tpg->workqueue, &cmd->work);
1249 if (ret < 0)
1250 goto err;
1251
1252 return 0;
1253 err:
1254 kfree(cmd);
1255 return -EINVAL;
1256 }
1257
1258 /* Start fabric.c code */
1259
1260 static int usbg_check_true(struct se_portal_group *se_tpg)
1261 {
1262 return 1;
1263 }
1264
1265 static int usbg_check_false(struct se_portal_group *se_tpg)
1266 {
1267 return 0;
1268 }
1269
1270 static char *usbg_get_fabric_name(void)
1271 {
1272 return "usb_gadget";
1273 }
1274
1275 static char *usbg_get_fabric_wwn(struct se_portal_group *se_tpg)
1276 {
1277 struct usbg_tpg *tpg = container_of(se_tpg,
1278 struct usbg_tpg, se_tpg);
1279 struct usbg_tport *tport = tpg->tport;
1280
1281 return &tport->tport_name[0];
1282 }
1283
1284 static u16 usbg_get_tag(struct se_portal_group *se_tpg)
1285 {
1286 struct usbg_tpg *tpg = container_of(se_tpg,
1287 struct usbg_tpg, se_tpg);
1288 return tpg->tport_tpgt;
1289 }
1290
1291 static u32 usbg_tpg_get_inst_index(struct se_portal_group *se_tpg)
1292 {
1293 return 1;
1294 }
1295
1296 static void usbg_cmd_release(struct kref *ref)
1297 {
1298 struct usbg_cmd *cmd = container_of(ref, struct usbg_cmd,
1299 ref);
1300
1301 transport_generic_free_cmd(&cmd->se_cmd, 0);
1302 }
1303
1304 static void usbg_release_cmd(struct se_cmd *se_cmd)
1305 {
1306 struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
1307 se_cmd);
1308 kfree(cmd->data_buf);
1309 kfree(cmd);
1310 return;
1311 }
1312
1313 static int usbg_shutdown_session(struct se_session *se_sess)
1314 {
1315 return 0;
1316 }
1317
1318 static void usbg_close_session(struct se_session *se_sess)
1319 {
1320 return;
1321 }
1322
1323 static u32 usbg_sess_get_index(struct se_session *se_sess)
1324 {
1325 return 0;
1326 }
1327
1328 /*
1329 * XXX Error recovery: return != 0 if we expect writes. Dunno when that could be
1330 */
1331 static int usbg_write_pending_status(struct se_cmd *se_cmd)
1332 {
1333 return 0;
1334 }
1335
1336 static void usbg_set_default_node_attrs(struct se_node_acl *nacl)
1337 {
1338 return;
1339 }
1340
1341 static int usbg_get_cmd_state(struct se_cmd *se_cmd)
1342 {
1343 return 0;
1344 }
1345
1346 static void usbg_queue_tm_rsp(struct se_cmd *se_cmd)
1347 {
1348 }
1349
1350 static void usbg_aborted_task(struct se_cmd *se_cmd)
1351 {
1352 return;
1353 }
1354
1355 static const char *usbg_check_wwn(const char *name)
1356 {
1357 const char *n;
1358 unsigned int len;
1359
1360 n = strstr(name, "naa.");
1361 if (!n)
1362 return NULL;
1363 n += 4;
1364 len = strlen(n);
1365 if (len == 0 || len > USBG_NAMELEN - 1)
1366 return NULL;
1367 return n;
1368 }
1369
1370 static int usbg_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
1371 {
1372 if (!usbg_check_wwn(name))
1373 return -EINVAL;
1374 return 0;
1375 }
1376
1377 struct usbg_tpg *the_only_tpg_I_currently_have;
1378
1379 static struct se_portal_group *usbg_make_tpg(
1380 struct se_wwn *wwn,
1381 struct config_group *group,
1382 const char *name)
1383 {
1384 struct usbg_tport *tport = container_of(wwn, struct usbg_tport,
1385 tport_wwn);
1386 struct usbg_tpg *tpg;
1387 unsigned long tpgt;
1388 int ret;
1389
1390 if (strstr(name, "tpgt_") != name)
1391 return ERR_PTR(-EINVAL);
1392 if (kstrtoul(name + 5, 0, &tpgt) || tpgt > UINT_MAX)
1393 return ERR_PTR(-EINVAL);
1394 if (the_only_tpg_I_currently_have) {
1395 pr_err("Until the gadget framework can't handle multiple\n");
1396 pr_err("gadgets, you can't do this here.\n");
1397 return ERR_PTR(-EBUSY);
1398 }
1399
1400 tpg = kzalloc(sizeof(struct usbg_tpg), GFP_KERNEL);
1401 if (!tpg)
1402 return ERR_PTR(-ENOMEM);
1403 mutex_init(&tpg->tpg_mutex);
1404 atomic_set(&tpg->tpg_port_count, 0);
1405 tpg->workqueue = alloc_workqueue("tcm_usb_gadget", 0, 1);
1406 if (!tpg->workqueue) {
1407 kfree(tpg);
1408 return NULL;
1409 }
1410
1411 tpg->tport = tport;
1412 tpg->tport_tpgt = tpgt;
1413
1414 /*
1415 * SPC doesn't assign a protocol identifier for USB-SCSI, so we
1416 * pretend to be SAS..
1417 */
1418 ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SAS);
1419 if (ret < 0) {
1420 destroy_workqueue(tpg->workqueue);
1421 kfree(tpg);
1422 return NULL;
1423 }
1424 the_only_tpg_I_currently_have = tpg;
1425 return &tpg->se_tpg;
1426 }
1427
1428 static void usbg_drop_tpg(struct se_portal_group *se_tpg)
1429 {
1430 struct usbg_tpg *tpg = container_of(se_tpg,
1431 struct usbg_tpg, se_tpg);
1432
1433 core_tpg_deregister(se_tpg);
1434 destroy_workqueue(tpg->workqueue);
1435 kfree(tpg);
1436 the_only_tpg_I_currently_have = NULL;
1437 }
1438
1439 static struct se_wwn *usbg_make_tport(
1440 struct target_fabric_configfs *tf,
1441 struct config_group *group,
1442 const char *name)
1443 {
1444 struct usbg_tport *tport;
1445 const char *wnn_name;
1446 u64 wwpn = 0;
1447
1448 wnn_name = usbg_check_wwn(name);
1449 if (!wnn_name)
1450 return ERR_PTR(-EINVAL);
1451
1452 tport = kzalloc(sizeof(struct usbg_tport), GFP_KERNEL);
1453 if (!(tport))
1454 return ERR_PTR(-ENOMEM);
1455 tport->tport_wwpn = wwpn;
1456 snprintf(tport->tport_name, sizeof(tport->tport_name), "%s", wnn_name);
1457 return &tport->tport_wwn;
1458 }
1459
1460 static void usbg_drop_tport(struct se_wwn *wwn)
1461 {
1462 struct usbg_tport *tport = container_of(wwn,
1463 struct usbg_tport, tport_wwn);
1464 kfree(tport);
1465 }
1466
1467 /*
1468 * If somebody feels like dropping the version property, go ahead.
1469 */
1470 static ssize_t usbg_wwn_show_attr_version(
1471 struct target_fabric_configfs *tf,
1472 char *page)
1473 {
1474 return sprintf(page, "usb-gadget fabric module\n");
1475 }
1476 TF_WWN_ATTR_RO(usbg, version);
1477
1478 static struct configfs_attribute *usbg_wwn_attrs[] = {
1479 &usbg_wwn_version.attr,
1480 NULL,
1481 };
1482
1483 static ssize_t tcm_usbg_tpg_show_enable(
1484 struct se_portal_group *se_tpg,
1485 char *page)
1486 {
1487 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1488
1489 return snprintf(page, PAGE_SIZE, "%u\n", tpg->gadget_connect);
1490 }
1491
1492 static int usbg_attach(struct usbg_tpg *);
1493 static void usbg_detach(struct usbg_tpg *);
1494
1495 static ssize_t tcm_usbg_tpg_store_enable(
1496 struct se_portal_group *se_tpg,
1497 const char *page,
1498 size_t count)
1499 {
1500 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1501 unsigned long op;
1502 ssize_t ret;
1503
1504 ret = kstrtoul(page, 0, &op);
1505 if (ret < 0)
1506 return -EINVAL;
1507 if (op > 1)
1508 return -EINVAL;
1509
1510 if (op && tpg->gadget_connect)
1511 goto out;
1512 if (!op && !tpg->gadget_connect)
1513 goto out;
1514
1515 if (op) {
1516 ret = usbg_attach(tpg);
1517 if (ret)
1518 goto out;
1519 } else {
1520 usbg_detach(tpg);
1521 }
1522 tpg->gadget_connect = op;
1523 out:
1524 return count;
1525 }
1526 TF_TPG_BASE_ATTR(tcm_usbg, enable, S_IRUGO | S_IWUSR);
1527
1528 static ssize_t tcm_usbg_tpg_show_nexus(
1529 struct se_portal_group *se_tpg,
1530 char *page)
1531 {
1532 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1533 struct tcm_usbg_nexus *tv_nexus;
1534 ssize_t ret;
1535
1536 mutex_lock(&tpg->tpg_mutex);
1537 tv_nexus = tpg->tpg_nexus;
1538 if (!tv_nexus) {
1539 ret = -ENODEV;
1540 goto out;
1541 }
1542 ret = snprintf(page, PAGE_SIZE, "%s\n",
1543 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1544 out:
1545 mutex_unlock(&tpg->tpg_mutex);
1546 return ret;
1547 }
1548
1549 static int tcm_usbg_make_nexus(struct usbg_tpg *tpg, char *name)
1550 {
1551 struct se_portal_group *se_tpg;
1552 struct tcm_usbg_nexus *tv_nexus;
1553 int ret;
1554
1555 mutex_lock(&tpg->tpg_mutex);
1556 if (tpg->tpg_nexus) {
1557 ret = -EEXIST;
1558 pr_debug("tpg->tpg_nexus already exists\n");
1559 goto err_unlock;
1560 }
1561 se_tpg = &tpg->se_tpg;
1562
1563 ret = -ENOMEM;
1564 tv_nexus = kzalloc(sizeof(*tv_nexus), GFP_KERNEL);
1565 if (!tv_nexus)
1566 goto err_unlock;
1567 tv_nexus->tvn_se_sess = transport_init_session(TARGET_PROT_NORMAL);
1568 if (IS_ERR(tv_nexus->tvn_se_sess))
1569 goto err_free;
1570
1571 /*
1572 * Since we are running in 'demo mode' this call with generate a
1573 * struct se_node_acl for the tcm_vhost struct se_portal_group with
1574 * the SCSI Initiator port name of the passed configfs group 'name'.
1575 */
1576 tv_nexus->tvn_se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
1577 se_tpg, name);
1578 if (!tv_nexus->tvn_se_sess->se_node_acl) {
1579 pr_debug("core_tpg_check_initiator_node_acl() failed"
1580 " for %s\n", name);
1581 goto err_session;
1582 }
1583 /*
1584 * Now register the TCM vHost virtual I_T Nexus as active.
1585 */
1586 transport_register_session(se_tpg, tv_nexus->tvn_se_sess->se_node_acl,
1587 tv_nexus->tvn_se_sess, tv_nexus);
1588 tpg->tpg_nexus = tv_nexus;
1589 mutex_unlock(&tpg->tpg_mutex);
1590 return 0;
1591
1592 err_session:
1593 transport_free_session(tv_nexus->tvn_se_sess);
1594 err_free:
1595 kfree(tv_nexus);
1596 err_unlock:
1597 mutex_unlock(&tpg->tpg_mutex);
1598 return ret;
1599 }
1600
1601 static int tcm_usbg_drop_nexus(struct usbg_tpg *tpg)
1602 {
1603 struct se_session *se_sess;
1604 struct tcm_usbg_nexus *tv_nexus;
1605 int ret = -ENODEV;
1606
1607 mutex_lock(&tpg->tpg_mutex);
1608 tv_nexus = tpg->tpg_nexus;
1609 if (!tv_nexus)
1610 goto out;
1611
1612 se_sess = tv_nexus->tvn_se_sess;
1613 if (!se_sess)
1614 goto out;
1615
1616 if (atomic_read(&tpg->tpg_port_count)) {
1617 ret = -EPERM;
1618 pr_err("Unable to remove Host I_T Nexus with"
1619 " active TPG port count: %d\n",
1620 atomic_read(&tpg->tpg_port_count));
1621 goto out;
1622 }
1623
1624 pr_debug("Removing I_T Nexus to Initiator Port: %s\n",
1625 tv_nexus->tvn_se_sess->se_node_acl->initiatorname);
1626 /*
1627 * Release the SCSI I_T Nexus to the emulated vHost Target Port
1628 */
1629 transport_deregister_session(tv_nexus->tvn_se_sess);
1630 tpg->tpg_nexus = NULL;
1631
1632 kfree(tv_nexus);
1633 ret = 0;
1634 out:
1635 mutex_unlock(&tpg->tpg_mutex);
1636 return ret;
1637 }
1638
1639 static ssize_t tcm_usbg_tpg_store_nexus(
1640 struct se_portal_group *se_tpg,
1641 const char *page,
1642 size_t count)
1643 {
1644 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1645 unsigned char i_port[USBG_NAMELEN], *ptr;
1646 int ret;
1647
1648 if (!strncmp(page, "NULL", 4)) {
1649 ret = tcm_usbg_drop_nexus(tpg);
1650 return (!ret) ? count : ret;
1651 }
1652 if (strlen(page) >= USBG_NAMELEN) {
1653 pr_err("Emulated NAA Sas Address: %s, exceeds"
1654 " max: %d\n", page, USBG_NAMELEN);
1655 return -EINVAL;
1656 }
1657 snprintf(i_port, USBG_NAMELEN, "%s", page);
1658
1659 ptr = strstr(i_port, "naa.");
1660 if (!ptr) {
1661 pr_err("Missing 'naa.' prefix\n");
1662 return -EINVAL;
1663 }
1664
1665 if (i_port[strlen(i_port) - 1] == '\n')
1666 i_port[strlen(i_port) - 1] = '\0';
1667
1668 ret = tcm_usbg_make_nexus(tpg, &i_port[4]);
1669 if (ret < 0)
1670 return ret;
1671 return count;
1672 }
1673 TF_TPG_BASE_ATTR(tcm_usbg, nexus, S_IRUGO | S_IWUSR);
1674
1675 static struct configfs_attribute *usbg_base_attrs[] = {
1676 &tcm_usbg_tpg_enable.attr,
1677 &tcm_usbg_tpg_nexus.attr,
1678 NULL,
1679 };
1680
1681 static int usbg_port_link(struct se_portal_group *se_tpg, struct se_lun *lun)
1682 {
1683 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1684
1685 atomic_inc(&tpg->tpg_port_count);
1686 smp_mb__after_atomic();
1687 return 0;
1688 }
1689
1690 static void usbg_port_unlink(struct se_portal_group *se_tpg,
1691 struct se_lun *se_lun)
1692 {
1693 struct usbg_tpg *tpg = container_of(se_tpg, struct usbg_tpg, se_tpg);
1694
1695 atomic_dec(&tpg->tpg_port_count);
1696 smp_mb__after_atomic();
1697 }
1698
1699 static int usbg_check_stop_free(struct se_cmd *se_cmd)
1700 {
1701 struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
1702 se_cmd);
1703
1704 kref_put(&cmd->ref, usbg_cmd_release);
1705 return 1;
1706 }
1707
1708 static const struct target_core_fabric_ops usbg_ops = {
1709 .module = THIS_MODULE,
1710 .name = "usb_gadget",
1711 .get_fabric_name = usbg_get_fabric_name,
1712 .tpg_get_wwn = usbg_get_fabric_wwn,
1713 .tpg_get_tag = usbg_get_tag,
1714 .tpg_check_demo_mode = usbg_check_true,
1715 .tpg_check_demo_mode_cache = usbg_check_false,
1716 .tpg_check_demo_mode_write_protect = usbg_check_false,
1717 .tpg_check_prod_mode_write_protect = usbg_check_false,
1718 .tpg_get_inst_index = usbg_tpg_get_inst_index,
1719 .release_cmd = usbg_release_cmd,
1720 .shutdown_session = usbg_shutdown_session,
1721 .close_session = usbg_close_session,
1722 .sess_get_index = usbg_sess_get_index,
1723 .sess_get_initiator_sid = NULL,
1724 .write_pending = usbg_send_write_request,
1725 .write_pending_status = usbg_write_pending_status,
1726 .set_default_node_attributes = usbg_set_default_node_attrs,
1727 .get_cmd_state = usbg_get_cmd_state,
1728 .queue_data_in = usbg_send_read_response,
1729 .queue_status = usbg_send_status_response,
1730 .queue_tm_rsp = usbg_queue_tm_rsp,
1731 .aborted_task = usbg_aborted_task,
1732 .check_stop_free = usbg_check_stop_free,
1733
1734 .fabric_make_wwn = usbg_make_tport,
1735 .fabric_drop_wwn = usbg_drop_tport,
1736 .fabric_make_tpg = usbg_make_tpg,
1737 .fabric_drop_tpg = usbg_drop_tpg,
1738 .fabric_post_link = usbg_port_link,
1739 .fabric_pre_unlink = usbg_port_unlink,
1740 .fabric_init_nodeacl = usbg_init_nodeacl,
1741
1742 .tfc_wwn_attrs = usbg_wwn_attrs,
1743 .tfc_tpg_base_attrs = usbg_base_attrs,
1744 };
1745
1746 /* Start gadget.c code */
1747
1748 static struct usb_interface_descriptor bot_intf_desc = {
1749 .bLength = sizeof(bot_intf_desc),
1750 .bDescriptorType = USB_DT_INTERFACE,
1751 .bNumEndpoints = 2,
1752 .bAlternateSetting = USB_G_ALT_INT_BBB,
1753 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
1754 .bInterfaceSubClass = USB_SC_SCSI,
1755 .bInterfaceProtocol = USB_PR_BULK,
1756 };
1757
1758 static struct usb_interface_descriptor uasp_intf_desc = {
1759 .bLength = sizeof(uasp_intf_desc),
1760 .bDescriptorType = USB_DT_INTERFACE,
1761 .bNumEndpoints = 4,
1762 .bAlternateSetting = USB_G_ALT_INT_UAS,
1763 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
1764 .bInterfaceSubClass = USB_SC_SCSI,
1765 .bInterfaceProtocol = USB_PR_UAS,
1766 };
1767
1768 static struct usb_endpoint_descriptor uasp_bi_desc = {
1769 .bLength = USB_DT_ENDPOINT_SIZE,
1770 .bDescriptorType = USB_DT_ENDPOINT,
1771 .bEndpointAddress = USB_DIR_IN,
1772 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1773 .wMaxPacketSize = cpu_to_le16(512),
1774 };
1775
1776 static struct usb_endpoint_descriptor uasp_fs_bi_desc = {
1777 .bLength = USB_DT_ENDPOINT_SIZE,
1778 .bDescriptorType = USB_DT_ENDPOINT,
1779 .bEndpointAddress = USB_DIR_IN,
1780 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1781 };
1782
1783 static struct usb_pipe_usage_descriptor uasp_bi_pipe_desc = {
1784 .bLength = sizeof(uasp_bi_pipe_desc),
1785 .bDescriptorType = USB_DT_PIPE_USAGE,
1786 .bPipeID = DATA_IN_PIPE_ID,
1787 };
1788
1789 static struct usb_endpoint_descriptor uasp_ss_bi_desc = {
1790 .bLength = USB_DT_ENDPOINT_SIZE,
1791 .bDescriptorType = USB_DT_ENDPOINT,
1792 .bEndpointAddress = USB_DIR_IN,
1793 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1794 .wMaxPacketSize = cpu_to_le16(1024),
1795 };
1796
1797 static struct usb_ss_ep_comp_descriptor uasp_bi_ep_comp_desc = {
1798 .bLength = sizeof(uasp_bi_ep_comp_desc),
1799 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1800 .bMaxBurst = 0,
1801 .bmAttributes = UASP_SS_EP_COMP_LOG_STREAMS,
1802 .wBytesPerInterval = 0,
1803 };
1804
1805 static struct usb_ss_ep_comp_descriptor bot_bi_ep_comp_desc = {
1806 .bLength = sizeof(bot_bi_ep_comp_desc),
1807 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1808 .bMaxBurst = 0,
1809 };
1810
1811 static struct usb_endpoint_descriptor uasp_bo_desc = {
1812 .bLength = USB_DT_ENDPOINT_SIZE,
1813 .bDescriptorType = USB_DT_ENDPOINT,
1814 .bEndpointAddress = USB_DIR_OUT,
1815 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1816 .wMaxPacketSize = cpu_to_le16(512),
1817 };
1818
1819 static struct usb_endpoint_descriptor uasp_fs_bo_desc = {
1820 .bLength = USB_DT_ENDPOINT_SIZE,
1821 .bDescriptorType = USB_DT_ENDPOINT,
1822 .bEndpointAddress = USB_DIR_OUT,
1823 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1824 };
1825
1826 static struct usb_pipe_usage_descriptor uasp_bo_pipe_desc = {
1827 .bLength = sizeof(uasp_bo_pipe_desc),
1828 .bDescriptorType = USB_DT_PIPE_USAGE,
1829 .bPipeID = DATA_OUT_PIPE_ID,
1830 };
1831
1832 static struct usb_endpoint_descriptor uasp_ss_bo_desc = {
1833 .bLength = USB_DT_ENDPOINT_SIZE,
1834 .bDescriptorType = USB_DT_ENDPOINT,
1835 .bEndpointAddress = USB_DIR_OUT,
1836 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1837 .wMaxPacketSize = cpu_to_le16(0x400),
1838 };
1839
1840 static struct usb_ss_ep_comp_descriptor uasp_bo_ep_comp_desc = {
1841 .bLength = sizeof(uasp_bo_ep_comp_desc),
1842 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1843 .bmAttributes = UASP_SS_EP_COMP_LOG_STREAMS,
1844 };
1845
1846 static struct usb_ss_ep_comp_descriptor bot_bo_ep_comp_desc = {
1847 .bLength = sizeof(bot_bo_ep_comp_desc),
1848 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1849 };
1850
1851 static struct usb_endpoint_descriptor uasp_status_desc = {
1852 .bLength = USB_DT_ENDPOINT_SIZE,
1853 .bDescriptorType = USB_DT_ENDPOINT,
1854 .bEndpointAddress = USB_DIR_IN,
1855 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1856 .wMaxPacketSize = cpu_to_le16(512),
1857 };
1858
1859 static struct usb_endpoint_descriptor uasp_fs_status_desc = {
1860 .bLength = USB_DT_ENDPOINT_SIZE,
1861 .bDescriptorType = USB_DT_ENDPOINT,
1862 .bEndpointAddress = USB_DIR_IN,
1863 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1864 };
1865
1866 static struct usb_pipe_usage_descriptor uasp_status_pipe_desc = {
1867 .bLength = sizeof(uasp_status_pipe_desc),
1868 .bDescriptorType = USB_DT_PIPE_USAGE,
1869 .bPipeID = STATUS_PIPE_ID,
1870 };
1871
1872 static struct usb_endpoint_descriptor uasp_ss_status_desc = {
1873 .bLength = USB_DT_ENDPOINT_SIZE,
1874 .bDescriptorType = USB_DT_ENDPOINT,
1875 .bEndpointAddress = USB_DIR_IN,
1876 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1877 .wMaxPacketSize = cpu_to_le16(1024),
1878 };
1879
1880 static struct usb_ss_ep_comp_descriptor uasp_status_in_ep_comp_desc = {
1881 .bLength = sizeof(uasp_status_in_ep_comp_desc),
1882 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1883 .bmAttributes = UASP_SS_EP_COMP_LOG_STREAMS,
1884 };
1885
1886 static struct usb_endpoint_descriptor uasp_cmd_desc = {
1887 .bLength = USB_DT_ENDPOINT_SIZE,
1888 .bDescriptorType = USB_DT_ENDPOINT,
1889 .bEndpointAddress = USB_DIR_OUT,
1890 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1891 .wMaxPacketSize = cpu_to_le16(512),
1892 };
1893
1894 static struct usb_endpoint_descriptor uasp_fs_cmd_desc = {
1895 .bLength = USB_DT_ENDPOINT_SIZE,
1896 .bDescriptorType = USB_DT_ENDPOINT,
1897 .bEndpointAddress = USB_DIR_OUT,
1898 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1899 };
1900
1901 static struct usb_pipe_usage_descriptor uasp_cmd_pipe_desc = {
1902 .bLength = sizeof(uasp_cmd_pipe_desc),
1903 .bDescriptorType = USB_DT_PIPE_USAGE,
1904 .bPipeID = CMD_PIPE_ID,
1905 };
1906
1907 static struct usb_endpoint_descriptor uasp_ss_cmd_desc = {
1908 .bLength = USB_DT_ENDPOINT_SIZE,
1909 .bDescriptorType = USB_DT_ENDPOINT,
1910 .bEndpointAddress = USB_DIR_OUT,
1911 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1912 .wMaxPacketSize = cpu_to_le16(1024),
1913 };
1914
1915 static struct usb_ss_ep_comp_descriptor uasp_cmd_comp_desc = {
1916 .bLength = sizeof(uasp_cmd_comp_desc),
1917 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
1918 };
1919
1920 static struct usb_descriptor_header *uasp_fs_function_desc[] = {
1921 (struct usb_descriptor_header *) &bot_intf_desc,
1922 (struct usb_descriptor_header *) &uasp_fs_bi_desc,
1923 (struct usb_descriptor_header *) &uasp_fs_bo_desc,
1924
1925 (struct usb_descriptor_header *) &uasp_intf_desc,
1926 (struct usb_descriptor_header *) &uasp_fs_bi_desc,
1927 (struct usb_descriptor_header *) &uasp_bi_pipe_desc,
1928 (struct usb_descriptor_header *) &uasp_fs_bo_desc,
1929 (struct usb_descriptor_header *) &uasp_bo_pipe_desc,
1930 (struct usb_descriptor_header *) &uasp_fs_status_desc,
1931 (struct usb_descriptor_header *) &uasp_status_pipe_desc,
1932 (struct usb_descriptor_header *) &uasp_fs_cmd_desc,
1933 (struct usb_descriptor_header *) &uasp_cmd_pipe_desc,
1934 NULL,
1935 };
1936
1937 static struct usb_descriptor_header *uasp_hs_function_desc[] = {
1938 (struct usb_descriptor_header *) &bot_intf_desc,
1939 (struct usb_descriptor_header *) &uasp_bi_desc,
1940 (struct usb_descriptor_header *) &uasp_bo_desc,
1941
1942 (struct usb_descriptor_header *) &uasp_intf_desc,
1943 (struct usb_descriptor_header *) &uasp_bi_desc,
1944 (struct usb_descriptor_header *) &uasp_bi_pipe_desc,
1945 (struct usb_descriptor_header *) &uasp_bo_desc,
1946 (struct usb_descriptor_header *) &uasp_bo_pipe_desc,
1947 (struct usb_descriptor_header *) &uasp_status_desc,
1948 (struct usb_descriptor_header *) &uasp_status_pipe_desc,
1949 (struct usb_descriptor_header *) &uasp_cmd_desc,
1950 (struct usb_descriptor_header *) &uasp_cmd_pipe_desc,
1951 NULL,
1952 };
1953
1954 static struct usb_descriptor_header *uasp_ss_function_desc[] = {
1955 (struct usb_descriptor_header *) &bot_intf_desc,
1956 (struct usb_descriptor_header *) &uasp_ss_bi_desc,
1957 (struct usb_descriptor_header *) &bot_bi_ep_comp_desc,
1958 (struct usb_descriptor_header *) &uasp_ss_bo_desc,
1959 (struct usb_descriptor_header *) &bot_bo_ep_comp_desc,
1960
1961 (struct usb_descriptor_header *) &uasp_intf_desc,
1962 (struct usb_descriptor_header *) &uasp_ss_bi_desc,
1963 (struct usb_descriptor_header *) &uasp_bi_ep_comp_desc,
1964 (struct usb_descriptor_header *) &uasp_bi_pipe_desc,
1965 (struct usb_descriptor_header *) &uasp_ss_bo_desc,
1966 (struct usb_descriptor_header *) &uasp_bo_ep_comp_desc,
1967 (struct usb_descriptor_header *) &uasp_bo_pipe_desc,
1968 (struct usb_descriptor_header *) &uasp_ss_status_desc,
1969 (struct usb_descriptor_header *) &uasp_status_in_ep_comp_desc,
1970 (struct usb_descriptor_header *) &uasp_status_pipe_desc,
1971 (struct usb_descriptor_header *) &uasp_ss_cmd_desc,
1972 (struct usb_descriptor_header *) &uasp_cmd_comp_desc,
1973 (struct usb_descriptor_header *) &uasp_cmd_pipe_desc,
1974 NULL,
1975 };
1976
1977 #define UAS_VENDOR_ID 0x0525 /* NetChip */
1978 #define UAS_PRODUCT_ID 0xa4a5 /* Linux-USB File-backed Storage Gadget */
1979
1980 static struct usb_device_descriptor usbg_device_desc = {
1981 .bLength = sizeof(usbg_device_desc),
1982 .bDescriptorType = USB_DT_DEVICE,
1983 .bcdUSB = cpu_to_le16(0x0200),
1984 .bDeviceClass = USB_CLASS_PER_INTERFACE,
1985 .idVendor = cpu_to_le16(UAS_VENDOR_ID),
1986 .idProduct = cpu_to_le16(UAS_PRODUCT_ID),
1987 .bNumConfigurations = 1,
1988 };
1989
1990 static struct usb_string usbg_us_strings[] = {
1991 [USB_GADGET_MANUFACTURER_IDX].s = "Target Manufactor",
1992 [USB_GADGET_PRODUCT_IDX].s = "Target Product",
1993 [USB_GADGET_SERIAL_IDX].s = "000000000001",
1994 [USB_G_STR_CONFIG].s = "default config",
1995 [USB_G_STR_INT_UAS].s = "USB Attached SCSI",
1996 [USB_G_STR_INT_BBB].s = "Bulk Only Transport",
1997 { },
1998 };
1999
2000 static struct usb_gadget_strings usbg_stringtab = {
2001 .language = 0x0409,
2002 .strings = usbg_us_strings,
2003 };
2004
2005 static struct usb_gadget_strings *usbg_strings[] = {
2006 &usbg_stringtab,
2007 NULL,
2008 };
2009
2010 static int guas_unbind(struct usb_composite_dev *cdev)
2011 {
2012 return 0;
2013 }
2014
2015 static struct usb_configuration usbg_config_driver = {
2016 .label = "Linux Target",
2017 .bConfigurationValue = 1,
2018 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
2019 };
2020
2021 static void give_back_ep(struct usb_ep **pep)
2022 {
2023 struct usb_ep *ep = *pep;
2024 if (!ep)
2025 return;
2026 ep->driver_data = NULL;
2027 }
2028
2029 static int usbg_bind(struct usb_configuration *c, struct usb_function *f)
2030 {
2031 struct f_uas *fu = to_f_uas(f);
2032 struct usb_gadget *gadget = c->cdev->gadget;
2033 struct usb_ep *ep;
2034 int iface;
2035 int ret;
2036
2037 iface = usb_interface_id(c, f);
2038 if (iface < 0)
2039 return iface;
2040
2041 bot_intf_desc.bInterfaceNumber = iface;
2042 uasp_intf_desc.bInterfaceNumber = iface;
2043 fu->iface = iface;
2044 ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bi_desc,
2045 &uasp_bi_ep_comp_desc);
2046 if (!ep)
2047 goto ep_fail;
2048
2049 ep->driver_data = fu;
2050 fu->ep_in = ep;
2051
2052 ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_bo_desc,
2053 &uasp_bo_ep_comp_desc);
2054 if (!ep)
2055 goto ep_fail;
2056 ep->driver_data = fu;
2057 fu->ep_out = ep;
2058
2059 ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_status_desc,
2060 &uasp_status_in_ep_comp_desc);
2061 if (!ep)
2062 goto ep_fail;
2063 ep->driver_data = fu;
2064 fu->ep_status = ep;
2065
2066 ep = usb_ep_autoconfig_ss(gadget, &uasp_ss_cmd_desc,
2067 &uasp_cmd_comp_desc);
2068 if (!ep)
2069 goto ep_fail;
2070 ep->driver_data = fu;
2071 fu->ep_cmd = ep;
2072
2073 /* Assume endpoint addresses are the same for both speeds */
2074 uasp_bi_desc.bEndpointAddress = uasp_ss_bi_desc.bEndpointAddress;
2075 uasp_bo_desc.bEndpointAddress = uasp_ss_bo_desc.bEndpointAddress;
2076 uasp_status_desc.bEndpointAddress =
2077 uasp_ss_status_desc.bEndpointAddress;
2078 uasp_cmd_desc.bEndpointAddress = uasp_ss_cmd_desc.bEndpointAddress;
2079
2080 uasp_fs_bi_desc.bEndpointAddress = uasp_ss_bi_desc.bEndpointAddress;
2081 uasp_fs_bo_desc.bEndpointAddress = uasp_ss_bo_desc.bEndpointAddress;
2082 uasp_fs_status_desc.bEndpointAddress =
2083 uasp_ss_status_desc.bEndpointAddress;
2084 uasp_fs_cmd_desc.bEndpointAddress = uasp_ss_cmd_desc.bEndpointAddress;
2085
2086 ret = usb_assign_descriptors(f, uasp_fs_function_desc,
2087 uasp_hs_function_desc, uasp_ss_function_desc);
2088 if (ret)
2089 goto ep_fail;
2090
2091 return 0;
2092 ep_fail:
2093 pr_err("Can't claim all required eps\n");
2094
2095 give_back_ep(&fu->ep_in);
2096 give_back_ep(&fu->ep_out);
2097 give_back_ep(&fu->ep_status);
2098 give_back_ep(&fu->ep_cmd);
2099 return -ENOTSUPP;
2100 }
2101
2102 static void usbg_unbind(struct usb_configuration *c, struct usb_function *f)
2103 {
2104 struct f_uas *fu = to_f_uas(f);
2105
2106 usb_free_all_descriptors(f);
2107 kfree(fu);
2108 }
2109
2110 struct guas_setup_wq {
2111 struct work_struct work;
2112 struct f_uas *fu;
2113 unsigned int alt;
2114 };
2115
2116 static void usbg_delayed_set_alt(struct work_struct *wq)
2117 {
2118 struct guas_setup_wq *work = container_of(wq, struct guas_setup_wq,
2119 work);
2120 struct f_uas *fu = work->fu;
2121 int alt = work->alt;
2122
2123 kfree(work);
2124
2125 if (fu->flags & USBG_IS_BOT)
2126 bot_cleanup_old_alt(fu);
2127 if (fu->flags & USBG_IS_UAS)
2128 uasp_cleanup_old_alt(fu);
2129
2130 if (alt == USB_G_ALT_INT_BBB)
2131 bot_set_alt(fu);
2132 else if (alt == USB_G_ALT_INT_UAS)
2133 uasp_set_alt(fu);
2134 usb_composite_setup_continue(fu->function.config->cdev);
2135 }
2136
2137 static int usbg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
2138 {
2139 struct f_uas *fu = to_f_uas(f);
2140
2141 if ((alt == USB_G_ALT_INT_BBB) || (alt == USB_G_ALT_INT_UAS)) {
2142 struct guas_setup_wq *work;
2143
2144 work = kmalloc(sizeof(*work), GFP_ATOMIC);
2145 if (!work)
2146 return -ENOMEM;
2147 INIT_WORK(&work->work, usbg_delayed_set_alt);
2148 work->fu = fu;
2149 work->alt = alt;
2150 schedule_work(&work->work);
2151 return USB_GADGET_DELAYED_STATUS;
2152 }
2153 return -EOPNOTSUPP;
2154 }
2155
2156 static void usbg_disable(struct usb_function *f)
2157 {
2158 struct f_uas *fu = to_f_uas(f);
2159
2160 if (fu->flags & USBG_IS_UAS)
2161 uasp_cleanup_old_alt(fu);
2162 else if (fu->flags & USBG_IS_BOT)
2163 bot_cleanup_old_alt(fu);
2164 fu->flags = 0;
2165 }
2166
2167 static int usbg_setup(struct usb_function *f,
2168 const struct usb_ctrlrequest *ctrl)
2169 {
2170 struct f_uas *fu = to_f_uas(f);
2171
2172 if (!(fu->flags & USBG_IS_BOT))
2173 return -EOPNOTSUPP;
2174
2175 return usbg_bot_setup(f, ctrl);
2176 }
2177
2178 static int usbg_cfg_bind(struct usb_configuration *c)
2179 {
2180 struct f_uas *fu;
2181 int ret;
2182
2183 fu = kzalloc(sizeof(*fu), GFP_KERNEL);
2184 if (!fu)
2185 return -ENOMEM;
2186 fu->function.name = "Target Function";
2187 fu->function.bind = usbg_bind;
2188 fu->function.unbind = usbg_unbind;
2189 fu->function.set_alt = usbg_set_alt;
2190 fu->function.setup = usbg_setup;
2191 fu->function.disable = usbg_disable;
2192 fu->tpg = the_only_tpg_I_currently_have;
2193
2194 bot_intf_desc.iInterface = usbg_us_strings[USB_G_STR_INT_BBB].id;
2195 uasp_intf_desc.iInterface = usbg_us_strings[USB_G_STR_INT_UAS].id;
2196
2197 ret = usb_add_function(c, &fu->function);
2198 if (ret)
2199 goto err;
2200
2201 return 0;
2202 err:
2203 kfree(fu);
2204 return ret;
2205 }
2206
2207 static int usb_target_bind(struct usb_composite_dev *cdev)
2208 {
2209 int ret;
2210
2211 ret = usb_string_ids_tab(cdev, usbg_us_strings);
2212 if (ret)
2213 return ret;
2214
2215 usbg_device_desc.iManufacturer =
2216 usbg_us_strings[USB_GADGET_MANUFACTURER_IDX].id;
2217 usbg_device_desc.iProduct = usbg_us_strings[USB_GADGET_PRODUCT_IDX].id;
2218 usbg_device_desc.iSerialNumber =
2219 usbg_us_strings[USB_GADGET_SERIAL_IDX].id;
2220 usbg_config_driver.iConfiguration =
2221 usbg_us_strings[USB_G_STR_CONFIG].id;
2222
2223 ret = usb_add_config(cdev, &usbg_config_driver,
2224 usbg_cfg_bind);
2225 if (ret)
2226 return ret;
2227 usb_composite_overwrite_options(cdev, &coverwrite);
2228 return 0;
2229 }
2230
2231 static struct usb_composite_driver usbg_driver = {
2232 .name = "g_target",
2233 .dev = &usbg_device_desc,
2234 .strings = usbg_strings,
2235 .max_speed = USB_SPEED_SUPER,
2236 .bind = usb_target_bind,
2237 .unbind = guas_unbind,
2238 };
2239
2240 static int usbg_attach(struct usbg_tpg *tpg)
2241 {
2242 return usb_composite_probe(&usbg_driver);
2243 }
2244
2245 static void usbg_detach(struct usbg_tpg *tpg)
2246 {
2247 usb_composite_unregister(&usbg_driver);
2248 }
2249
2250 static int __init usb_target_gadget_init(void)
2251 {
2252 return target_register_template(&usbg_ops);
2253 }
2254 module_init(usb_target_gadget_init);
2255
2256 static void __exit usb_target_gadget_exit(void)
2257 {
2258 target_unregister_template(&usbg_ops);
2259 }
2260 module_exit(usb_target_gadget_exit);
2261
2262 MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");
2263 MODULE_DESCRIPTION("usb-gadget fabric");
2264 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support