1 /* Target based USB-Gadget
3 * UAS protocol handling, target callbacks, configfs handling,
4 * BBB (USB Mass Storage Class Bulk-Only (BBB) and Transport protocol handling.
6 * Author: Sebastian Andrzej Siewior <bigeasy at linutronix dot de>
7 * License: GPLv2 as published by FSF.
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 <asm/unaligned.h>
28 #define TPG_INSTANCES 1
31 struct usb_function_instance
*func_inst
;
35 static struct tpg_instance tpg_instances
[TPG_INSTANCES
];
37 static DEFINE_MUTEX(tpg_instances_lock
);
39 static inline struct f_uas
*to_f_uas(struct usb_function
*f
)
41 return container_of(f
, struct f_uas
, function
);
44 /* Start bot.c code */
46 static int bot_enqueue_cmd_cbw(struct f_uas
*fu
)
50 if (fu
->flags
& USBG_BOT_CMD_PEND
)
53 ret
= usb_ep_queue(fu
->ep_out
, fu
->cmd
.req
, GFP_ATOMIC
);
55 fu
->flags
|= USBG_BOT_CMD_PEND
;
59 static void bot_status_complete(struct usb_ep
*ep
, struct usb_request
*req
)
61 struct usbg_cmd
*cmd
= req
->context
;
62 struct f_uas
*fu
= cmd
->fu
;
64 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
65 if (req
->status
< 0) {
66 pr_err("ERR %s(%d)\n", __func__
, __LINE__
);
70 /* CSW completed, wait for next CBW */
71 bot_enqueue_cmd_cbw(fu
);
74 static void bot_enqueue_sense_code(struct f_uas
*fu
, struct usbg_cmd
*cmd
)
76 struct bulk_cs_wrap
*csw
= &fu
->bot_status
.csw
;
78 unsigned int csw_stat
;
80 csw_stat
= cmd
->csw_code
;
81 csw
->Tag
= cmd
->bot_tag
;
82 csw
->Status
= csw_stat
;
83 fu
->bot_status
.req
->context
= cmd
;
84 ret
= usb_ep_queue(fu
->ep_in
, fu
->bot_status
.req
, GFP_ATOMIC
);
86 pr_err("%s(%d) ERR: %d\n", __func__
, __LINE__
, ret
);
89 static void bot_err_compl(struct usb_ep
*ep
, struct usb_request
*req
)
91 struct usbg_cmd
*cmd
= req
->context
;
92 struct f_uas
*fu
= cmd
->fu
;
95 pr_err("ERR %s(%d)\n", __func__
, __LINE__
);
98 if (cmd
->data_len
> ep
->maxpacket
) {
99 req
->length
= ep
->maxpacket
;
100 cmd
->data_len
-= ep
->maxpacket
;
102 req
->length
= cmd
->data_len
;
106 usb_ep_queue(ep
, req
, GFP_ATOMIC
);
109 bot_enqueue_sense_code(fu
, cmd
);
112 static void bot_send_bad_status(struct usbg_cmd
*cmd
)
114 struct f_uas
*fu
= cmd
->fu
;
115 struct bulk_cs_wrap
*csw
= &fu
->bot_status
.csw
;
116 struct usb_request
*req
;
119 csw
->Residue
= cpu_to_le32(cmd
->data_len
);
124 req
= fu
->bot_req_in
;
127 req
= fu
->bot_req_out
;
130 if (cmd
->data_len
> fu
->ep_in
->maxpacket
) {
131 req
->length
= ep
->maxpacket
;
132 cmd
->data_len
-= ep
->maxpacket
;
134 req
->length
= cmd
->data_len
;
137 req
->complete
= bot_err_compl
;
139 req
->buf
= fu
->cmd
.buf
;
140 usb_ep_queue(ep
, req
, GFP_KERNEL
);
142 bot_enqueue_sense_code(fu
, cmd
);
146 static int bot_send_status(struct usbg_cmd
*cmd
, bool moved_data
)
148 struct f_uas
*fu
= cmd
->fu
;
149 struct bulk_cs_wrap
*csw
= &fu
->bot_status
.csw
;
152 if (cmd
->se_cmd
.scsi_status
== SAM_STAT_GOOD
) {
153 if (!moved_data
&& cmd
->data_len
) {
155 * the host wants to move data, we don't. Fill / empty
156 * the pipe and then send the csw with reside set.
158 cmd
->csw_code
= US_BULK_STAT_OK
;
159 bot_send_bad_status(cmd
);
163 csw
->Tag
= cmd
->bot_tag
;
164 csw
->Residue
= cpu_to_le32(0);
165 csw
->Status
= US_BULK_STAT_OK
;
166 fu
->bot_status
.req
->context
= cmd
;
168 ret
= usb_ep_queue(fu
->ep_in
, fu
->bot_status
.req
, GFP_KERNEL
);
170 pr_err("%s(%d) ERR: %d\n", __func__
, __LINE__
, ret
);
172 cmd
->csw_code
= US_BULK_STAT_FAIL
;
173 bot_send_bad_status(cmd
);
179 * Called after command (no data transfer) or after the write (to device)
180 * operation is completed
182 static int bot_send_status_response(struct usbg_cmd
*cmd
)
184 bool moved_data
= false;
188 return bot_send_status(cmd
, moved_data
);
191 /* Read request completed, now we have to send the CSW */
192 static void bot_read_compl(struct usb_ep
*ep
, struct usb_request
*req
)
194 struct usbg_cmd
*cmd
= req
->context
;
197 pr_err("ERR %s(%d)\n", __func__
, __LINE__
);
199 bot_send_status(cmd
, true);
202 static int bot_send_read_response(struct usbg_cmd
*cmd
)
204 struct f_uas
*fu
= cmd
->fu
;
205 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
206 struct usb_gadget
*gadget
= fuas_to_gadget(fu
);
209 if (!cmd
->data_len
) {
210 cmd
->csw_code
= US_BULK_STAT_PHASE
;
211 bot_send_bad_status(cmd
);
215 if (!gadget
->sg_supported
) {
216 cmd
->data_buf
= kmalloc(se_cmd
->data_length
, GFP_ATOMIC
);
220 sg_copy_to_buffer(se_cmd
->t_data_sg
,
221 se_cmd
->t_data_nents
,
223 se_cmd
->data_length
);
225 fu
->bot_req_in
->buf
= cmd
->data_buf
;
227 fu
->bot_req_in
->buf
= NULL
;
228 fu
->bot_req_in
->num_sgs
= se_cmd
->t_data_nents
;
229 fu
->bot_req_in
->sg
= se_cmd
->t_data_sg
;
232 fu
->bot_req_in
->complete
= bot_read_compl
;
233 fu
->bot_req_in
->length
= se_cmd
->data_length
;
234 fu
->bot_req_in
->context
= cmd
;
235 ret
= usb_ep_queue(fu
->ep_in
, fu
->bot_req_in
, GFP_ATOMIC
);
237 pr_err("%s(%d)\n", __func__
, __LINE__
);
241 static void usbg_data_write_cmpl(struct usb_ep
*, struct usb_request
*);
242 static int usbg_prepare_w_request(struct usbg_cmd
*, struct usb_request
*);
244 static int bot_send_write_request(struct usbg_cmd
*cmd
)
246 struct f_uas
*fu
= cmd
->fu
;
247 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
248 struct usb_gadget
*gadget
= fuas_to_gadget(fu
);
251 init_completion(&cmd
->write_complete
);
254 if (!cmd
->data_len
) {
255 cmd
->csw_code
= US_BULK_STAT_PHASE
;
259 if (!gadget
->sg_supported
) {
260 cmd
->data_buf
= kmalloc(se_cmd
->data_length
, GFP_KERNEL
);
264 fu
->bot_req_out
->buf
= cmd
->data_buf
;
266 fu
->bot_req_out
->buf
= NULL
;
267 fu
->bot_req_out
->num_sgs
= se_cmd
->t_data_nents
;
268 fu
->bot_req_out
->sg
= se_cmd
->t_data_sg
;
271 fu
->bot_req_out
->complete
= usbg_data_write_cmpl
;
272 fu
->bot_req_out
->length
= se_cmd
->data_length
;
273 fu
->bot_req_out
->context
= cmd
;
275 ret
= usbg_prepare_w_request(cmd
, fu
->bot_req_out
);
278 ret
= usb_ep_queue(fu
->ep_out
, fu
->bot_req_out
, GFP_KERNEL
);
280 pr_err("%s(%d)\n", __func__
, __LINE__
);
282 wait_for_completion(&cmd
->write_complete
);
283 target_execute_cmd(se_cmd
);
288 static int bot_submit_command(struct f_uas
*, void *, unsigned int);
290 static void bot_cmd_complete(struct usb_ep
*ep
, struct usb_request
*req
)
292 struct f_uas
*fu
= req
->context
;
295 fu
->flags
&= ~USBG_BOT_CMD_PEND
;
300 ret
= bot_submit_command(fu
, req
->buf
, req
->actual
);
302 pr_err("%s(%d): %d\n", __func__
, __LINE__
, ret
);
305 static int bot_prepare_reqs(struct f_uas
*fu
)
309 fu
->bot_req_in
= usb_ep_alloc_request(fu
->ep_in
, GFP_KERNEL
);
313 fu
->bot_req_out
= usb_ep_alloc_request(fu
->ep_out
, GFP_KERNEL
);
314 if (!fu
->bot_req_out
)
317 fu
->cmd
.req
= usb_ep_alloc_request(fu
->ep_out
, GFP_KERNEL
);
321 fu
->bot_status
.req
= usb_ep_alloc_request(fu
->ep_in
, GFP_KERNEL
);
322 if (!fu
->bot_status
.req
)
325 fu
->bot_status
.req
->buf
= &fu
->bot_status
.csw
;
326 fu
->bot_status
.req
->length
= US_BULK_CS_WRAP_LEN
;
327 fu
->bot_status
.req
->complete
= bot_status_complete
;
328 fu
->bot_status
.csw
.Signature
= cpu_to_le32(US_BULK_CS_SIGN
);
330 fu
->cmd
.buf
= kmalloc(fu
->ep_out
->maxpacket
, GFP_KERNEL
);
334 fu
->cmd
.req
->complete
= bot_cmd_complete
;
335 fu
->cmd
.req
->buf
= fu
->cmd
.buf
;
336 fu
->cmd
.req
->length
= fu
->ep_out
->maxpacket
;
337 fu
->cmd
.req
->context
= fu
;
339 ret
= bot_enqueue_cmd_cbw(fu
);
347 usb_ep_free_request(fu
->ep_in
, fu
->bot_status
.req
);
349 usb_ep_free_request(fu
->ep_out
, fu
->cmd
.req
);
352 usb_ep_free_request(fu
->ep_out
, fu
->bot_req_out
);
353 fu
->bot_req_out
= NULL
;
355 usb_ep_free_request(fu
->ep_in
, fu
->bot_req_in
);
356 fu
->bot_req_in
= NULL
;
358 pr_err("BOT: endpoint setup failed\n");
362 static void bot_cleanup_old_alt(struct f_uas
*fu
)
364 if (!(fu
->flags
& USBG_ENABLED
))
367 usb_ep_disable(fu
->ep_in
);
368 usb_ep_disable(fu
->ep_out
);
373 usb_ep_free_request(fu
->ep_in
, fu
->bot_req_in
);
374 usb_ep_free_request(fu
->ep_out
, fu
->bot_req_out
);
375 usb_ep_free_request(fu
->ep_out
, fu
->cmd
.req
);
376 usb_ep_free_request(fu
->ep_out
, fu
->bot_status
.req
);
380 fu
->bot_req_in
= NULL
;
381 fu
->bot_req_out
= NULL
;
383 fu
->bot_status
.req
= NULL
;
387 static void bot_set_alt(struct f_uas
*fu
)
389 struct usb_function
*f
= &fu
->function
;
390 struct usb_gadget
*gadget
= f
->config
->cdev
->gadget
;
393 fu
->flags
= USBG_IS_BOT
;
395 config_ep_by_speed(gadget
, f
, fu
->ep_in
);
396 ret
= usb_ep_enable(fu
->ep_in
);
400 config_ep_by_speed(gadget
, f
, fu
->ep_out
);
401 ret
= usb_ep_enable(fu
->ep_out
);
405 ret
= bot_prepare_reqs(fu
);
408 fu
->flags
|= USBG_ENABLED
;
409 pr_info("Using the BOT protocol\n");
412 usb_ep_disable(fu
->ep_out
);
414 usb_ep_disable(fu
->ep_in
);
416 fu
->flags
= USBG_IS_BOT
;
419 static int usbg_bot_setup(struct usb_function
*f
,
420 const struct usb_ctrlrequest
*ctrl
)
422 struct f_uas
*fu
= to_f_uas(f
);
423 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
424 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
425 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
429 switch (ctrl
->bRequest
) {
430 case US_BULK_GET_MAX_LUN
:
431 if (ctrl
->bRequestType
!= (USB_DIR_IN
| USB_TYPE_CLASS
|
432 USB_RECIP_INTERFACE
))
439 luns
= atomic_read(&fu
->tpg
->tpg_port_count
);
441 pr_err("No LUNs configured?\n");
445 * If 4 LUNs are present we return 3 i.e. LUN 0..3 can be
446 * accessed. The upper limit is 0xf
450 pr_info_once("Limiting the number of luns to 16\n");
453 ret_lun
= cdev
->req
->buf
;
455 cdev
->req
->length
= 1;
456 return usb_ep_queue(cdev
->gadget
->ep0
, cdev
->req
, GFP_ATOMIC
);
458 case US_BULK_RESET_REQUEST
:
459 /* XXX maybe we should remove previous requests for IN + OUT */
460 bot_enqueue_cmd_cbw(fu
);
466 /* Start uas.c code */
468 static void uasp_cleanup_one_stream(struct f_uas
*fu
, struct uas_stream
*stream
)
470 /* We have either all three allocated or none */
474 usb_ep_free_request(fu
->ep_in
, stream
->req_in
);
475 usb_ep_free_request(fu
->ep_out
, stream
->req_out
);
476 usb_ep_free_request(fu
->ep_status
, stream
->req_status
);
478 stream
->req_in
= NULL
;
479 stream
->req_out
= NULL
;
480 stream
->req_status
= NULL
;
483 static void uasp_free_cmdreq(struct f_uas
*fu
)
485 usb_ep_free_request(fu
->ep_cmd
, fu
->cmd
.req
);
491 static void uasp_cleanup_old_alt(struct f_uas
*fu
)
495 if (!(fu
->flags
& USBG_ENABLED
))
498 usb_ep_disable(fu
->ep_in
);
499 usb_ep_disable(fu
->ep_out
);
500 usb_ep_disable(fu
->ep_status
);
501 usb_ep_disable(fu
->ep_cmd
);
503 for (i
= 0; i
< UASP_SS_EP_COMP_NUM_STREAMS
; i
++)
504 uasp_cleanup_one_stream(fu
, &fu
->stream
[i
]);
505 uasp_free_cmdreq(fu
);
508 static void uasp_status_data_cmpl(struct usb_ep
*ep
, struct usb_request
*req
);
510 static int uasp_prepare_r_request(struct usbg_cmd
*cmd
)
512 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
513 struct f_uas
*fu
= cmd
->fu
;
514 struct usb_gadget
*gadget
= fuas_to_gadget(fu
);
515 struct uas_stream
*stream
= cmd
->stream
;
517 if (!gadget
->sg_supported
) {
518 cmd
->data_buf
= kmalloc(se_cmd
->data_length
, GFP_ATOMIC
);
522 sg_copy_to_buffer(se_cmd
->t_data_sg
,
523 se_cmd
->t_data_nents
,
525 se_cmd
->data_length
);
527 stream
->req_in
->buf
= cmd
->data_buf
;
529 stream
->req_in
->buf
= NULL
;
530 stream
->req_in
->num_sgs
= se_cmd
->t_data_nents
;
531 stream
->req_in
->sg
= se_cmd
->t_data_sg
;
534 stream
->req_in
->complete
= uasp_status_data_cmpl
;
535 stream
->req_in
->length
= se_cmd
->data_length
;
536 stream
->req_in
->context
= cmd
;
538 cmd
->state
= UASP_SEND_STATUS
;
542 static void uasp_prepare_status(struct usbg_cmd
*cmd
)
544 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
545 struct sense_iu
*iu
= &cmd
->sense_iu
;
546 struct uas_stream
*stream
= cmd
->stream
;
548 cmd
->state
= UASP_QUEUE_COMMAND
;
549 iu
->iu_id
= IU_ID_STATUS
;
550 iu
->tag
= cpu_to_be16(cmd
->tag
);
553 * iu->status_qual = cpu_to_be16(STATUS QUALIFIER SAM-4. Where R U?);
555 iu
->len
= cpu_to_be16(se_cmd
->scsi_sense_length
);
556 iu
->status
= se_cmd
->scsi_status
;
557 stream
->req_status
->context
= cmd
;
558 stream
->req_status
->length
= se_cmd
->scsi_sense_length
+ 16;
559 stream
->req_status
->buf
= iu
;
560 stream
->req_status
->complete
= uasp_status_data_cmpl
;
563 static void uasp_status_data_cmpl(struct usb_ep
*ep
, struct usb_request
*req
)
565 struct usbg_cmd
*cmd
= req
->context
;
566 struct uas_stream
*stream
= cmd
->stream
;
567 struct f_uas
*fu
= cmd
->fu
;
573 switch (cmd
->state
) {
575 ret
= uasp_prepare_r_request(cmd
);
578 ret
= usb_ep_queue(fu
->ep_in
, stream
->req_in
, GFP_ATOMIC
);
580 pr_err("%s(%d) => %d\n", __func__
, __LINE__
, ret
);
583 case UASP_RECEIVE_DATA
:
584 ret
= usbg_prepare_w_request(cmd
, stream
->req_out
);
587 ret
= usb_ep_queue(fu
->ep_out
, stream
->req_out
, GFP_ATOMIC
);
589 pr_err("%s(%d) => %d\n", __func__
, __LINE__
, ret
);
592 case UASP_SEND_STATUS
:
593 uasp_prepare_status(cmd
);
594 ret
= usb_ep_queue(fu
->ep_status
, stream
->req_status
,
597 pr_err("%s(%d) => %d\n", __func__
, __LINE__
, ret
);
600 case UASP_QUEUE_COMMAND
:
601 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
602 usb_ep_queue(fu
->ep_cmd
, fu
->cmd
.req
, GFP_ATOMIC
);
611 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
614 static int uasp_send_status_response(struct usbg_cmd
*cmd
)
616 struct f_uas
*fu
= cmd
->fu
;
617 struct uas_stream
*stream
= cmd
->stream
;
618 struct sense_iu
*iu
= &cmd
->sense_iu
;
620 iu
->tag
= cpu_to_be16(cmd
->tag
);
621 stream
->req_status
->complete
= uasp_status_data_cmpl
;
622 stream
->req_status
->context
= cmd
;
624 uasp_prepare_status(cmd
);
625 return usb_ep_queue(fu
->ep_status
, stream
->req_status
, GFP_ATOMIC
);
628 static int uasp_send_read_response(struct usbg_cmd
*cmd
)
630 struct f_uas
*fu
= cmd
->fu
;
631 struct uas_stream
*stream
= cmd
->stream
;
632 struct sense_iu
*iu
= &cmd
->sense_iu
;
637 iu
->tag
= cpu_to_be16(cmd
->tag
);
638 if (fu
->flags
& USBG_USE_STREAMS
) {
640 ret
= uasp_prepare_r_request(cmd
);
643 ret
= usb_ep_queue(fu
->ep_in
, stream
->req_in
, GFP_ATOMIC
);
645 pr_err("%s(%d) => %d\n", __func__
, __LINE__
, ret
);
646 kfree(cmd
->data_buf
);
647 cmd
->data_buf
= NULL
;
652 iu
->iu_id
= IU_ID_READ_READY
;
653 iu
->tag
= cpu_to_be16(cmd
->tag
);
655 stream
->req_status
->complete
= uasp_status_data_cmpl
;
656 stream
->req_status
->context
= cmd
;
658 cmd
->state
= UASP_SEND_DATA
;
659 stream
->req_status
->buf
= iu
;
660 stream
->req_status
->length
= sizeof(struct iu
);
662 ret
= usb_ep_queue(fu
->ep_status
, stream
->req_status
,
665 pr_err("%s(%d) => %d\n", __func__
, __LINE__
, ret
);
671 static int uasp_send_write_request(struct usbg_cmd
*cmd
)
673 struct f_uas
*fu
= cmd
->fu
;
674 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
675 struct uas_stream
*stream
= cmd
->stream
;
676 struct sense_iu
*iu
= &cmd
->sense_iu
;
679 init_completion(&cmd
->write_complete
);
682 iu
->tag
= cpu_to_be16(cmd
->tag
);
684 if (fu
->flags
& USBG_USE_STREAMS
) {
686 ret
= usbg_prepare_w_request(cmd
, stream
->req_out
);
689 ret
= usb_ep_queue(fu
->ep_out
, stream
->req_out
, GFP_ATOMIC
);
691 pr_err("%s(%d)\n", __func__
, __LINE__
);
695 iu
->iu_id
= IU_ID_WRITE_READY
;
696 iu
->tag
= cpu_to_be16(cmd
->tag
);
698 stream
->req_status
->complete
= uasp_status_data_cmpl
;
699 stream
->req_status
->context
= cmd
;
701 cmd
->state
= UASP_RECEIVE_DATA
;
702 stream
->req_status
->buf
= iu
;
703 stream
->req_status
->length
= sizeof(struct iu
);
705 ret
= usb_ep_queue(fu
->ep_status
, stream
->req_status
,
708 pr_err("%s(%d)\n", __func__
, __LINE__
);
711 wait_for_completion(&cmd
->write_complete
);
712 target_execute_cmd(se_cmd
);
717 static int usbg_submit_command(struct f_uas
*, void *, unsigned int);
719 static void uasp_cmd_complete(struct usb_ep
*ep
, struct usb_request
*req
)
721 struct f_uas
*fu
= req
->context
;
727 ret
= usbg_submit_command(fu
, req
->buf
, req
->actual
);
729 * Once we tune for performance enqueue the command req here again so
730 * we can receive a second command while we processing this one. Pay
731 * attention to properly sync STAUS endpoint with DATA IN + OUT so you
736 usb_ep_queue(fu
->ep_cmd
, fu
->cmd
.req
, GFP_ATOMIC
);
739 static int uasp_alloc_stream_res(struct f_uas
*fu
, struct uas_stream
*stream
)
741 stream
->req_in
= usb_ep_alloc_request(fu
->ep_in
, GFP_KERNEL
);
745 stream
->req_out
= usb_ep_alloc_request(fu
->ep_out
, GFP_KERNEL
);
746 if (!stream
->req_out
)
749 stream
->req_status
= usb_ep_alloc_request(fu
->ep_status
, GFP_KERNEL
);
750 if (!stream
->req_status
)
755 usb_ep_free_request(fu
->ep_status
, stream
->req_status
);
756 stream
->req_status
= NULL
;
758 usb_ep_free_request(fu
->ep_out
, stream
->req_out
);
759 stream
->req_out
= NULL
;
764 static int uasp_alloc_cmd(struct f_uas
*fu
)
766 fu
->cmd
.req
= usb_ep_alloc_request(fu
->ep_cmd
, GFP_KERNEL
);
770 fu
->cmd
.buf
= kmalloc(fu
->ep_cmd
->maxpacket
, GFP_KERNEL
);
774 fu
->cmd
.req
->complete
= uasp_cmd_complete
;
775 fu
->cmd
.req
->buf
= fu
->cmd
.buf
;
776 fu
->cmd
.req
->length
= fu
->ep_cmd
->maxpacket
;
777 fu
->cmd
.req
->context
= fu
;
781 usb_ep_free_request(fu
->ep_cmd
, fu
->cmd
.req
);
786 static void uasp_setup_stream_res(struct f_uas
*fu
, int max_streams
)
790 for (i
= 0; i
< max_streams
; i
++) {
791 struct uas_stream
*s
= &fu
->stream
[i
];
793 s
->req_in
->stream_id
= i
+ 1;
794 s
->req_out
->stream_id
= i
+ 1;
795 s
->req_status
->stream_id
= i
+ 1;
799 static int uasp_prepare_reqs(struct f_uas
*fu
)
805 if (fu
->flags
& USBG_USE_STREAMS
)
806 max_streams
= UASP_SS_EP_COMP_NUM_STREAMS
;
810 for (i
= 0; i
< max_streams
; i
++) {
811 ret
= uasp_alloc_stream_res(fu
, &fu
->stream
[i
]);
816 ret
= uasp_alloc_cmd(fu
);
818 goto err_free_stream
;
819 uasp_setup_stream_res(fu
, max_streams
);
821 ret
= usb_ep_queue(fu
->ep_cmd
, fu
->cmd
.req
, GFP_ATOMIC
);
823 goto err_free_stream
;
828 uasp_free_cmdreq(fu
);
833 uasp_cleanup_one_stream(fu
, &fu
->stream
[i
- 1]);
837 pr_err("UASP: endpoint setup failed\n");
841 static void uasp_set_alt(struct f_uas
*fu
)
843 struct usb_function
*f
= &fu
->function
;
844 struct usb_gadget
*gadget
= f
->config
->cdev
->gadget
;
847 fu
->flags
= USBG_IS_UAS
;
849 if (gadget
->speed
== USB_SPEED_SUPER
)
850 fu
->flags
|= USBG_USE_STREAMS
;
852 config_ep_by_speed(gadget
, f
, fu
->ep_in
);
853 ret
= usb_ep_enable(fu
->ep_in
);
857 config_ep_by_speed(gadget
, f
, fu
->ep_out
);
858 ret
= usb_ep_enable(fu
->ep_out
);
862 config_ep_by_speed(gadget
, f
, fu
->ep_cmd
);
863 ret
= usb_ep_enable(fu
->ep_cmd
);
866 config_ep_by_speed(gadget
, f
, fu
->ep_status
);
867 ret
= usb_ep_enable(fu
->ep_status
);
871 ret
= uasp_prepare_reqs(fu
);
874 fu
->flags
|= USBG_ENABLED
;
876 pr_info("Using the UAS protocol\n");
879 usb_ep_disable(fu
->ep_status
);
881 usb_ep_disable(fu
->ep_cmd
);
883 usb_ep_disable(fu
->ep_out
);
885 usb_ep_disable(fu
->ep_in
);
890 static int get_cmd_dir(const unsigned char *cdb
)
902 case SERVICE_ACTION_IN_16
:
904 case PERSISTENT_RESERVE_IN
:
905 case SECURITY_PROTOCOL_IN
:
906 case ACCESS_CONTROL_IN
:
908 case READ_BLOCK_LIMITS
:
912 case READ_FORMAT_CAPACITIES
:
914 ret
= DMA_FROM_DEVICE
;
924 case WRITE_VERIFY_12
:
925 case PERSISTENT_RESERVE_OUT
:
926 case MAINTENANCE_OUT
:
927 case SECURITY_PROTOCOL_OUT
:
928 case ACCESS_CONTROL_OUT
:
931 case ALLOW_MEDIUM_REMOVAL
:
932 case TEST_UNIT_READY
:
933 case SYNCHRONIZE_CACHE
:
940 case WRITE_FILEMARKS
:
944 #define CMD_DIR_MSG "target: Unknown data direction for SCSI Opcode 0x%02x\n"
945 pr_warn(CMD_DIR_MSG
, cdb
[0]);
952 static void usbg_data_write_cmpl(struct usb_ep
*ep
, struct usb_request
*req
)
954 struct usbg_cmd
*cmd
= req
->context
;
955 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
957 if (req
->status
< 0) {
958 pr_err("%s() state %d transfer failed\n", __func__
, cmd
->state
);
962 if (req
->num_sgs
== 0) {
963 sg_copy_from_buffer(se_cmd
->t_data_sg
,
964 se_cmd
->t_data_nents
,
966 se_cmd
->data_length
);
969 complete(&cmd
->write_complete
);
973 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
976 static int usbg_prepare_w_request(struct usbg_cmd
*cmd
, struct usb_request
*req
)
978 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
979 struct f_uas
*fu
= cmd
->fu
;
980 struct usb_gadget
*gadget
= fuas_to_gadget(fu
);
982 if (!gadget
->sg_supported
) {
983 cmd
->data_buf
= kmalloc(se_cmd
->data_length
, GFP_ATOMIC
);
987 req
->buf
= cmd
->data_buf
;
990 req
->num_sgs
= se_cmd
->t_data_nents
;
991 req
->sg
= se_cmd
->t_data_sg
;
994 req
->complete
= usbg_data_write_cmpl
;
995 req
->length
= se_cmd
->data_length
;
1000 static int usbg_send_status_response(struct se_cmd
*se_cmd
)
1002 struct usbg_cmd
*cmd
= container_of(se_cmd
, struct usbg_cmd
,
1004 struct f_uas
*fu
= cmd
->fu
;
1006 if (fu
->flags
& USBG_IS_BOT
)
1007 return bot_send_status_response(cmd
);
1009 return uasp_send_status_response(cmd
);
1012 static int usbg_send_write_request(struct se_cmd
*se_cmd
)
1014 struct usbg_cmd
*cmd
= container_of(se_cmd
, struct usbg_cmd
,
1016 struct f_uas
*fu
= cmd
->fu
;
1018 if (fu
->flags
& USBG_IS_BOT
)
1019 return bot_send_write_request(cmd
);
1021 return uasp_send_write_request(cmd
);
1024 static int usbg_send_read_response(struct se_cmd
*se_cmd
)
1026 struct usbg_cmd
*cmd
= container_of(se_cmd
, struct usbg_cmd
,
1028 struct f_uas
*fu
= cmd
->fu
;
1030 if (fu
->flags
& USBG_IS_BOT
)
1031 return bot_send_read_response(cmd
);
1033 return uasp_send_read_response(cmd
);
1036 static void usbg_cmd_work(struct work_struct
*work
)
1038 struct usbg_cmd
*cmd
= container_of(work
, struct usbg_cmd
, work
);
1039 struct se_cmd
*se_cmd
;
1040 struct tcm_usbg_nexus
*tv_nexus
;
1041 struct usbg_tpg
*tpg
;
1042 int dir
, flags
= (TARGET_SCF_UNKNOWN_SIZE
| TARGET_SCF_ACK_KREF
);
1044 se_cmd
= &cmd
->se_cmd
;
1046 tv_nexus
= tpg
->tpg_nexus
;
1047 dir
= get_cmd_dir(cmd
->cmd_buf
);
1049 transport_init_se_cmd(se_cmd
,
1050 tv_nexus
->tvn_se_sess
->se_tpg
->se_tpg_tfo
,
1051 tv_nexus
->tvn_se_sess
, cmd
->data_len
, DMA_NONE
,
1052 cmd
->prio_attr
, cmd
->sense_iu
.sense
);
1056 if (target_submit_cmd(se_cmd
, tv_nexus
->tvn_se_sess
, cmd
->cmd_buf
,
1057 cmd
->sense_iu
.sense
, cmd
->unpacked_lun
, 0,
1058 cmd
->prio_attr
, dir
, flags
) < 0)
1064 transport_send_check_condition_and_sense(se_cmd
,
1065 TCM_UNSUPPORTED_SCSI_OPCODE
, 1);
1066 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
1069 static struct usbg_cmd
*usbg_get_cmd(struct f_uas
*fu
,
1070 struct tcm_usbg_nexus
*tv_nexus
, u32 scsi_tag
)
1072 struct se_session
*se_sess
= tv_nexus
->tvn_se_sess
;
1073 struct usbg_cmd
*cmd
;
1076 tag
= percpu_ida_alloc(&se_sess
->sess_tag_pool
, GFP_ATOMIC
);
1078 return ERR_PTR(-ENOMEM
);
1080 cmd
= &((struct usbg_cmd
*)se_sess
->sess_cmd_map
)[tag
];
1081 memset(cmd
, 0, sizeof(*cmd
));
1082 cmd
->se_cmd
.map_tag
= tag
;
1083 cmd
->se_cmd
.tag
= cmd
->tag
= scsi_tag
;
1089 static void usbg_release_cmd(struct se_cmd
*);
1091 static int usbg_submit_command(struct f_uas
*fu
,
1092 void *cmdbuf
, unsigned int len
)
1094 struct command_iu
*cmd_iu
= cmdbuf
;
1095 struct usbg_cmd
*cmd
;
1096 struct usbg_tpg
*tpg
= fu
->tpg
;
1097 struct tcm_usbg_nexus
*tv_nexus
= tpg
->tpg_nexus
;
1101 if (cmd_iu
->iu_id
!= IU_ID_COMMAND
) {
1102 pr_err("Unsupported type %d\n", cmd_iu
->iu_id
);
1106 tv_nexus
= tpg
->tpg_nexus
;
1108 pr_err("Missing nexus, ignoring command\n");
1112 cmd_len
= (cmd_iu
->len
& ~0x3) + 16;
1113 if (cmd_len
> USBG_MAX_CMD
)
1116 scsi_tag
= be16_to_cpup(&cmd_iu
->tag
);
1117 cmd
= usbg_get_cmd(fu
, tv_nexus
, scsi_tag
);
1119 pr_err("usbg_get_cmd failed\n");
1122 memcpy(cmd
->cmd_buf
, cmd_iu
->cdb
, cmd_len
);
1124 if (fu
->flags
& USBG_USE_STREAMS
) {
1125 if (cmd
->tag
> UASP_SS_EP_COMP_NUM_STREAMS
)
1128 cmd
->stream
= &fu
->stream
[0];
1130 cmd
->stream
= &fu
->stream
[cmd
->tag
- 1];
1132 cmd
->stream
= &fu
->stream
[0];
1135 switch (cmd_iu
->prio_attr
& 0x7) {
1137 cmd
->prio_attr
= TCM_HEAD_TAG
;
1139 case UAS_ORDERED_TAG
:
1140 cmd
->prio_attr
= TCM_ORDERED_TAG
;
1143 cmd
->prio_attr
= TCM_ACA_TAG
;
1146 pr_debug_once("Unsupported prio_attr: %02x.\n",
1148 case UAS_SIMPLE_TAG
:
1149 cmd
->prio_attr
= TCM_SIMPLE_TAG
;
1153 cmd
->unpacked_lun
= scsilun_to_int(&cmd_iu
->lun
);
1155 INIT_WORK(&cmd
->work
, usbg_cmd_work
);
1156 queue_work(tpg
->workqueue
, &cmd
->work
);
1160 usbg_release_cmd(&cmd
->se_cmd
);
1164 static void bot_cmd_work(struct work_struct
*work
)
1166 struct usbg_cmd
*cmd
= container_of(work
, struct usbg_cmd
, work
);
1167 struct se_cmd
*se_cmd
;
1168 struct tcm_usbg_nexus
*tv_nexus
;
1169 struct usbg_tpg
*tpg
;
1172 se_cmd
= &cmd
->se_cmd
;
1174 tv_nexus
= tpg
->tpg_nexus
;
1175 dir
= get_cmd_dir(cmd
->cmd_buf
);
1177 transport_init_se_cmd(se_cmd
,
1178 tv_nexus
->tvn_se_sess
->se_tpg
->se_tpg_tfo
,
1179 tv_nexus
->tvn_se_sess
, cmd
->data_len
, DMA_NONE
,
1180 cmd
->prio_attr
, cmd
->sense_iu
.sense
);
1184 if (target_submit_cmd(se_cmd
, tv_nexus
->tvn_se_sess
,
1185 cmd
->cmd_buf
, cmd
->sense_iu
.sense
, cmd
->unpacked_lun
,
1186 cmd
->data_len
, cmd
->prio_attr
, dir
, 0) < 0)
1192 transport_send_check_condition_and_sense(se_cmd
,
1193 TCM_UNSUPPORTED_SCSI_OPCODE
, 1);
1194 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
1197 static int bot_submit_command(struct f_uas
*fu
,
1198 void *cmdbuf
, unsigned int len
)
1200 struct bulk_cb_wrap
*cbw
= cmdbuf
;
1201 struct usbg_cmd
*cmd
;
1202 struct usbg_tpg
*tpg
= fu
->tpg
;
1203 struct tcm_usbg_nexus
*tv_nexus
;
1206 if (cbw
->Signature
!= cpu_to_le32(US_BULK_CB_SIGN
)) {
1207 pr_err("Wrong signature on CBW\n");
1211 pr_err("Wrong length for CBW\n");
1215 cmd_len
= cbw
->Length
;
1216 if (cmd_len
< 1 || cmd_len
> 16)
1219 tv_nexus
= tpg
->tpg_nexus
;
1221 pr_err("Missing nexus, ignoring command\n");
1225 cmd
= usbg_get_cmd(fu
, tv_nexus
, cbw
->Tag
);
1227 pr_err("usbg_get_cmd failed\n");
1230 memcpy(cmd
->cmd_buf
, cbw
->CDB
, cmd_len
);
1232 cmd
->bot_tag
= cbw
->Tag
;
1233 cmd
->prio_attr
= TCM_SIMPLE_TAG
;
1234 cmd
->unpacked_lun
= cbw
->Lun
;
1235 cmd
->is_read
= cbw
->Flags
& US_BULK_FLAG_IN
? 1 : 0;
1236 cmd
->data_len
= le32_to_cpu(cbw
->DataTransferLength
);
1237 cmd
->se_cmd
.tag
= le32_to_cpu(cmd
->bot_tag
);
1239 INIT_WORK(&cmd
->work
, bot_cmd_work
);
1240 queue_work(tpg
->workqueue
, &cmd
->work
);
1245 /* Start fabric.c code */
1247 static int usbg_check_true(struct se_portal_group
*se_tpg
)
1252 static int usbg_check_false(struct se_portal_group
*se_tpg
)
1257 static char *usbg_get_fabric_name(void)
1259 return "usb_gadget";
1262 static char *usbg_get_fabric_wwn(struct se_portal_group
*se_tpg
)
1264 struct usbg_tpg
*tpg
= container_of(se_tpg
,
1265 struct usbg_tpg
, se_tpg
);
1266 struct usbg_tport
*tport
= tpg
->tport
;
1268 return &tport
->tport_name
[0];
1271 static u16
usbg_get_tag(struct se_portal_group
*se_tpg
)
1273 struct usbg_tpg
*tpg
= container_of(se_tpg
,
1274 struct usbg_tpg
, se_tpg
);
1275 return tpg
->tport_tpgt
;
1278 static u32
usbg_tpg_get_inst_index(struct se_portal_group
*se_tpg
)
1283 static void usbg_release_cmd(struct se_cmd
*se_cmd
)
1285 struct usbg_cmd
*cmd
= container_of(se_cmd
, struct usbg_cmd
,
1287 struct se_session
*se_sess
= se_cmd
->se_sess
;
1289 kfree(cmd
->data_buf
);
1290 percpu_ida_free(&se_sess
->sess_tag_pool
, se_cmd
->map_tag
);
1293 static u32
usbg_sess_get_index(struct se_session
*se_sess
)
1299 * XXX Error recovery: return != 0 if we expect writes. Dunno when that could be
1301 static int usbg_write_pending_status(struct se_cmd
*se_cmd
)
1306 static void usbg_set_default_node_attrs(struct se_node_acl
*nacl
)
1310 static int usbg_get_cmd_state(struct se_cmd
*se_cmd
)
1315 static void usbg_queue_tm_rsp(struct se_cmd
*se_cmd
)
1319 static void usbg_aborted_task(struct se_cmd
*se_cmd
)
1323 static const char *usbg_check_wwn(const char *name
)
1328 n
= strstr(name
, "naa.");
1333 if (len
== 0 || len
> USBG_NAMELEN
- 1)
1338 static int usbg_init_nodeacl(struct se_node_acl
*se_nacl
, const char *name
)
1340 if (!usbg_check_wwn(name
))
1345 static struct se_portal_group
*usbg_make_tpg(
1347 struct config_group
*group
,
1350 struct usbg_tport
*tport
= container_of(wwn
, struct usbg_tport
,
1352 struct usbg_tpg
*tpg
;
1355 struct f_tcm_opts
*opts
;
1358 if (strstr(name
, "tpgt_") != name
)
1359 return ERR_PTR(-EINVAL
);
1360 if (kstrtoul(name
+ 5, 0, &tpgt
) || tpgt
> UINT_MAX
)
1361 return ERR_PTR(-EINVAL
);
1363 mutex_lock(&tpg_instances_lock
);
1364 for (i
= 0; i
< TPG_INSTANCES
; ++i
)
1365 if (tpg_instances
[i
].func_inst
&& !tpg_instances
[i
].tpg
)
1367 if (i
== TPG_INSTANCES
)
1370 opts
= container_of(tpg_instances
[i
].func_inst
, struct f_tcm_opts
,
1372 mutex_lock(&opts
->dep_lock
);
1376 if (opts
->has_dep
) {
1377 if (!try_module_get(opts
->dependent
))
1380 ret
= configfs_depend_item_unlocked(
1382 &opts
->func_inst
.group
.cg_item
);
1387 tpg
= kzalloc(sizeof(struct usbg_tpg
), GFP_KERNEL
);
1391 mutex_init(&tpg
->tpg_mutex
);
1392 atomic_set(&tpg
->tpg_port_count
, 0);
1393 tpg
->workqueue
= alloc_workqueue("tcm_usb_gadget", 0, 1);
1394 if (!tpg
->workqueue
)
1398 tpg
->tport_tpgt
= tpgt
;
1401 * SPC doesn't assign a protocol identifier for USB-SCSI, so we
1402 * pretend to be SAS..
1404 ret
= core_tpg_register(wwn
, &tpg
->se_tpg
, SCSI_PROTOCOL_SAS
);
1406 goto free_workqueue
;
1408 tpg_instances
[i
].tpg
= tpg
;
1409 tpg
->fi
= tpg_instances
[i
].func_inst
;
1410 mutex_unlock(&opts
->dep_lock
);
1411 mutex_unlock(&tpg_instances_lock
);
1412 return &tpg
->se_tpg
;
1415 destroy_workqueue(tpg
->workqueue
);
1420 module_put(opts
->dependent
);
1422 configfs_undepend_item_unlocked(&opts
->func_inst
.group
.cg_item
);
1424 mutex_unlock(&opts
->dep_lock
);
1426 mutex_unlock(&tpg_instances_lock
);
1428 return ERR_PTR(ret
);
1431 static int tcm_usbg_drop_nexus(struct usbg_tpg
*);
1433 static void usbg_drop_tpg(struct se_portal_group
*se_tpg
)
1435 struct usbg_tpg
*tpg
= container_of(se_tpg
,
1436 struct usbg_tpg
, se_tpg
);
1438 struct f_tcm_opts
*opts
;
1440 tcm_usbg_drop_nexus(tpg
);
1441 core_tpg_deregister(se_tpg
);
1442 destroy_workqueue(tpg
->workqueue
);
1444 mutex_lock(&tpg_instances_lock
);
1445 for (i
= 0; i
< TPG_INSTANCES
; ++i
)
1446 if (tpg_instances
[i
].tpg
== tpg
)
1448 if (i
< TPG_INSTANCES
)
1449 tpg_instances
[i
].tpg
= NULL
;
1450 opts
= container_of(tpg_instances
[i
].func_inst
,
1451 struct f_tcm_opts
, func_inst
);
1452 mutex_lock(&opts
->dep_lock
);
1454 module_put(opts
->dependent
);
1456 configfs_undepend_item_unlocked(&opts
->func_inst
.group
.cg_item
);
1457 mutex_unlock(&opts
->dep_lock
);
1458 mutex_unlock(&tpg_instances_lock
);
1463 static struct se_wwn
*usbg_make_tport(
1464 struct target_fabric_configfs
*tf
,
1465 struct config_group
*group
,
1468 struct usbg_tport
*tport
;
1469 const char *wnn_name
;
1472 wnn_name
= usbg_check_wwn(name
);
1474 return ERR_PTR(-EINVAL
);
1476 tport
= kzalloc(sizeof(struct usbg_tport
), GFP_KERNEL
);
1478 return ERR_PTR(-ENOMEM
);
1480 tport
->tport_wwpn
= wwpn
;
1481 snprintf(tport
->tport_name
, sizeof(tport
->tport_name
), "%s", wnn_name
);
1482 return &tport
->tport_wwn
;
1485 static void usbg_drop_tport(struct se_wwn
*wwn
)
1487 struct usbg_tport
*tport
= container_of(wwn
,
1488 struct usbg_tport
, tport_wwn
);
1493 * If somebody feels like dropping the version property, go ahead.
1495 static ssize_t
usbg_wwn_version_show(struct config_item
*item
, char *page
)
1497 return sprintf(page
, "usb-gadget fabric module\n");
1500 CONFIGFS_ATTR_RO(usbg_wwn_
, version
);
1502 static struct configfs_attribute
*usbg_wwn_attrs
[] = {
1503 &usbg_wwn_attr_version
,
1507 static ssize_t
tcm_usbg_tpg_enable_show(struct config_item
*item
, char *page
)
1509 struct se_portal_group
*se_tpg
= to_tpg(item
);
1510 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1512 return snprintf(page
, PAGE_SIZE
, "%u\n", tpg
->gadget_connect
);
1515 static int usbg_attach(struct usbg_tpg
*);
1516 static void usbg_detach(struct usbg_tpg
*);
1518 static ssize_t
tcm_usbg_tpg_enable_store(struct config_item
*item
,
1519 const char *page
, size_t count
)
1521 struct se_portal_group
*se_tpg
= to_tpg(item
);
1522 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1526 ret
= strtobool(page
, &op
);
1530 if ((op
&& tpg
->gadget_connect
) || (!op
&& !tpg
->gadget_connect
))
1534 ret
= usbg_attach(tpg
);
1540 tpg
->gadget_connect
= op
;
1545 static ssize_t
tcm_usbg_tpg_nexus_show(struct config_item
*item
, char *page
)
1547 struct se_portal_group
*se_tpg
= to_tpg(item
);
1548 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1549 struct tcm_usbg_nexus
*tv_nexus
;
1552 mutex_lock(&tpg
->tpg_mutex
);
1553 tv_nexus
= tpg
->tpg_nexus
;
1558 ret
= snprintf(page
, PAGE_SIZE
, "%s\n",
1559 tv_nexus
->tvn_se_sess
->se_node_acl
->initiatorname
);
1561 mutex_unlock(&tpg
->tpg_mutex
);
1565 static int usbg_alloc_sess_cb(struct se_portal_group
*se_tpg
,
1566 struct se_session
*se_sess
, void *p
)
1568 struct usbg_tpg
*tpg
= container_of(se_tpg
,
1569 struct usbg_tpg
, se_tpg
);
1575 static int tcm_usbg_make_nexus(struct usbg_tpg
*tpg
, char *name
)
1577 struct tcm_usbg_nexus
*tv_nexus
;
1580 mutex_lock(&tpg
->tpg_mutex
);
1581 if (tpg
->tpg_nexus
) {
1583 pr_debug("tpg->tpg_nexus already exists\n");
1587 tv_nexus
= kzalloc(sizeof(*tv_nexus
), GFP_KERNEL
);
1593 tv_nexus
->tvn_se_sess
= target_alloc_session(&tpg
->se_tpg
,
1594 USB_G_DEFAULT_SESSION_TAGS
,
1595 sizeof(struct usbg_cmd
),
1596 TARGET_PROT_NORMAL
, name
,
1597 tv_nexus
, usbg_alloc_sess_cb
);
1598 if (IS_ERR(tv_nexus
->tvn_se_sess
)) {
1599 #define MAKE_NEXUS_MSG "core_tpg_check_initiator_node_acl() failed for %s\n"
1600 pr_debug(MAKE_NEXUS_MSG
, name
);
1601 #undef MAKE_NEXUS_MSG
1602 ret
= PTR_ERR(tv_nexus
->tvn_se_sess
);
1607 mutex_unlock(&tpg
->tpg_mutex
);
1611 static int tcm_usbg_drop_nexus(struct usbg_tpg
*tpg
)
1613 struct se_session
*se_sess
;
1614 struct tcm_usbg_nexus
*tv_nexus
;
1617 mutex_lock(&tpg
->tpg_mutex
);
1618 tv_nexus
= tpg
->tpg_nexus
;
1622 se_sess
= tv_nexus
->tvn_se_sess
;
1626 if (atomic_read(&tpg
->tpg_port_count
)) {
1628 #define MSG "Unable to remove Host I_T Nexus with active TPG port count: %d\n"
1629 pr_err(MSG
, atomic_read(&tpg
->tpg_port_count
));
1634 pr_debug("Removing I_T Nexus to Initiator Port: %s\n",
1635 tv_nexus
->tvn_se_sess
->se_node_acl
->initiatorname
);
1637 * Release the SCSI I_T Nexus to the emulated vHost Target Port
1639 transport_deregister_session(tv_nexus
->tvn_se_sess
);
1640 tpg
->tpg_nexus
= NULL
;
1645 mutex_unlock(&tpg
->tpg_mutex
);
1649 static ssize_t
tcm_usbg_tpg_nexus_store(struct config_item
*item
,
1650 const char *page
, size_t count
)
1652 struct se_portal_group
*se_tpg
= to_tpg(item
);
1653 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1654 unsigned char i_port
[USBG_NAMELEN
], *ptr
;
1657 if (!strncmp(page
, "NULL", 4)) {
1658 ret
= tcm_usbg_drop_nexus(tpg
);
1659 return (!ret
) ? count
: ret
;
1661 if (strlen(page
) >= USBG_NAMELEN
) {
1663 #define NEXUS_STORE_MSG "Emulated NAA Sas Address: %s, exceeds max: %d\n"
1664 pr_err(NEXUS_STORE_MSG
, page
, USBG_NAMELEN
);
1665 #undef NEXUS_STORE_MSG
1668 snprintf(i_port
, USBG_NAMELEN
, "%s", page
);
1670 ptr
= strstr(i_port
, "naa.");
1672 pr_err("Missing 'naa.' prefix\n");
1676 if (i_port
[strlen(i_port
) - 1] == '\n')
1677 i_port
[strlen(i_port
) - 1] = '\0';
1679 ret
= tcm_usbg_make_nexus(tpg
, &i_port
[0]);
1685 CONFIGFS_ATTR(tcm_usbg_tpg_
, enable
);
1686 CONFIGFS_ATTR(tcm_usbg_tpg_
, nexus
);
1688 static struct configfs_attribute
*usbg_base_attrs
[] = {
1689 &tcm_usbg_tpg_attr_enable
,
1690 &tcm_usbg_tpg_attr_nexus
,
1694 static int usbg_port_link(struct se_portal_group
*se_tpg
, struct se_lun
*lun
)
1696 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1698 atomic_inc(&tpg
->tpg_port_count
);
1699 smp_mb__after_atomic();
1703 static void usbg_port_unlink(struct se_portal_group
*se_tpg
,
1704 struct se_lun
*se_lun
)
1706 struct usbg_tpg
*tpg
= container_of(se_tpg
, struct usbg_tpg
, se_tpg
);
1708 atomic_dec(&tpg
->tpg_port_count
);
1709 smp_mb__after_atomic();
1712 static int usbg_check_stop_free(struct se_cmd
*se_cmd
)
1714 return target_put_sess_cmd(se_cmd
);
1717 static const struct target_core_fabric_ops usbg_ops
= {
1718 .module
= THIS_MODULE
,
1719 .name
= "usb_gadget",
1720 .get_fabric_name
= usbg_get_fabric_name
,
1721 .tpg_get_wwn
= usbg_get_fabric_wwn
,
1722 .tpg_get_tag
= usbg_get_tag
,
1723 .tpg_check_demo_mode
= usbg_check_true
,
1724 .tpg_check_demo_mode_cache
= usbg_check_false
,
1725 .tpg_check_demo_mode_write_protect
= usbg_check_false
,
1726 .tpg_check_prod_mode_write_protect
= usbg_check_false
,
1727 .tpg_get_inst_index
= usbg_tpg_get_inst_index
,
1728 .release_cmd
= usbg_release_cmd
,
1729 .sess_get_index
= usbg_sess_get_index
,
1730 .sess_get_initiator_sid
= NULL
,
1731 .write_pending
= usbg_send_write_request
,
1732 .write_pending_status
= usbg_write_pending_status
,
1733 .set_default_node_attributes
= usbg_set_default_node_attrs
,
1734 .get_cmd_state
= usbg_get_cmd_state
,
1735 .queue_data_in
= usbg_send_read_response
,
1736 .queue_status
= usbg_send_status_response
,
1737 .queue_tm_rsp
= usbg_queue_tm_rsp
,
1738 .aborted_task
= usbg_aborted_task
,
1739 .check_stop_free
= usbg_check_stop_free
,
1741 .fabric_make_wwn
= usbg_make_tport
,
1742 .fabric_drop_wwn
= usbg_drop_tport
,
1743 .fabric_make_tpg
= usbg_make_tpg
,
1744 .fabric_drop_tpg
= usbg_drop_tpg
,
1745 .fabric_post_link
= usbg_port_link
,
1746 .fabric_pre_unlink
= usbg_port_unlink
,
1747 .fabric_init_nodeacl
= usbg_init_nodeacl
,
1749 .tfc_wwn_attrs
= usbg_wwn_attrs
,
1750 .tfc_tpg_base_attrs
= usbg_base_attrs
,
1753 /* Start gadget.c code */
1755 static struct usb_interface_descriptor bot_intf_desc
= {
1756 .bLength
= sizeof(bot_intf_desc
),
1757 .bDescriptorType
= USB_DT_INTERFACE
,
1759 .bAlternateSetting
= USB_G_ALT_INT_BBB
,
1760 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
1761 .bInterfaceSubClass
= USB_SC_SCSI
,
1762 .bInterfaceProtocol
= USB_PR_BULK
,
1765 static struct usb_interface_descriptor uasp_intf_desc
= {
1766 .bLength
= sizeof(uasp_intf_desc
),
1767 .bDescriptorType
= USB_DT_INTERFACE
,
1769 .bAlternateSetting
= USB_G_ALT_INT_UAS
,
1770 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
1771 .bInterfaceSubClass
= USB_SC_SCSI
,
1772 .bInterfaceProtocol
= USB_PR_UAS
,
1775 static struct usb_endpoint_descriptor uasp_bi_desc
= {
1776 .bLength
= USB_DT_ENDPOINT_SIZE
,
1777 .bDescriptorType
= USB_DT_ENDPOINT
,
1778 .bEndpointAddress
= USB_DIR_IN
,
1779 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1780 .wMaxPacketSize
= cpu_to_le16(512),
1783 static struct usb_endpoint_descriptor uasp_fs_bi_desc
= {
1784 .bLength
= USB_DT_ENDPOINT_SIZE
,
1785 .bDescriptorType
= USB_DT_ENDPOINT
,
1786 .bEndpointAddress
= USB_DIR_IN
,
1787 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1790 static struct usb_pipe_usage_descriptor uasp_bi_pipe_desc
= {
1791 .bLength
= sizeof(uasp_bi_pipe_desc
),
1792 .bDescriptorType
= USB_DT_PIPE_USAGE
,
1793 .bPipeID
= DATA_IN_PIPE_ID
,
1796 static struct usb_endpoint_descriptor uasp_ss_bi_desc
= {
1797 .bLength
= USB_DT_ENDPOINT_SIZE
,
1798 .bDescriptorType
= USB_DT_ENDPOINT
,
1799 .bEndpointAddress
= USB_DIR_IN
,
1800 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1801 .wMaxPacketSize
= cpu_to_le16(1024),
1804 static struct usb_ss_ep_comp_descriptor uasp_bi_ep_comp_desc
= {
1805 .bLength
= sizeof(uasp_bi_ep_comp_desc
),
1806 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1808 .bmAttributes
= UASP_SS_EP_COMP_LOG_STREAMS
,
1809 .wBytesPerInterval
= 0,
1812 static struct usb_ss_ep_comp_descriptor bot_bi_ep_comp_desc
= {
1813 .bLength
= sizeof(bot_bi_ep_comp_desc
),
1814 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1818 static struct usb_endpoint_descriptor uasp_bo_desc
= {
1819 .bLength
= USB_DT_ENDPOINT_SIZE
,
1820 .bDescriptorType
= USB_DT_ENDPOINT
,
1821 .bEndpointAddress
= USB_DIR_OUT
,
1822 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1823 .wMaxPacketSize
= cpu_to_le16(512),
1826 static struct usb_endpoint_descriptor uasp_fs_bo_desc
= {
1827 .bLength
= USB_DT_ENDPOINT_SIZE
,
1828 .bDescriptorType
= USB_DT_ENDPOINT
,
1829 .bEndpointAddress
= USB_DIR_OUT
,
1830 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1833 static struct usb_pipe_usage_descriptor uasp_bo_pipe_desc
= {
1834 .bLength
= sizeof(uasp_bo_pipe_desc
),
1835 .bDescriptorType
= USB_DT_PIPE_USAGE
,
1836 .bPipeID
= DATA_OUT_PIPE_ID
,
1839 static struct usb_endpoint_descriptor uasp_ss_bo_desc
= {
1840 .bLength
= USB_DT_ENDPOINT_SIZE
,
1841 .bDescriptorType
= USB_DT_ENDPOINT
,
1842 .bEndpointAddress
= USB_DIR_OUT
,
1843 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1844 .wMaxPacketSize
= cpu_to_le16(0x400),
1847 static struct usb_ss_ep_comp_descriptor uasp_bo_ep_comp_desc
= {
1848 .bLength
= sizeof(uasp_bo_ep_comp_desc
),
1849 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1850 .bmAttributes
= UASP_SS_EP_COMP_LOG_STREAMS
,
1853 static struct usb_ss_ep_comp_descriptor bot_bo_ep_comp_desc
= {
1854 .bLength
= sizeof(bot_bo_ep_comp_desc
),
1855 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1858 static struct usb_endpoint_descriptor uasp_status_desc
= {
1859 .bLength
= USB_DT_ENDPOINT_SIZE
,
1860 .bDescriptorType
= USB_DT_ENDPOINT
,
1861 .bEndpointAddress
= USB_DIR_IN
,
1862 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1863 .wMaxPacketSize
= cpu_to_le16(512),
1866 static struct usb_endpoint_descriptor uasp_fs_status_desc
= {
1867 .bLength
= USB_DT_ENDPOINT_SIZE
,
1868 .bDescriptorType
= USB_DT_ENDPOINT
,
1869 .bEndpointAddress
= USB_DIR_IN
,
1870 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1873 static struct usb_pipe_usage_descriptor uasp_status_pipe_desc
= {
1874 .bLength
= sizeof(uasp_status_pipe_desc
),
1875 .bDescriptorType
= USB_DT_PIPE_USAGE
,
1876 .bPipeID
= STATUS_PIPE_ID
,
1879 static struct usb_endpoint_descriptor uasp_ss_status_desc
= {
1880 .bLength
= USB_DT_ENDPOINT_SIZE
,
1881 .bDescriptorType
= USB_DT_ENDPOINT
,
1882 .bEndpointAddress
= USB_DIR_IN
,
1883 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1884 .wMaxPacketSize
= cpu_to_le16(1024),
1887 static struct usb_ss_ep_comp_descriptor uasp_status_in_ep_comp_desc
= {
1888 .bLength
= sizeof(uasp_status_in_ep_comp_desc
),
1889 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1890 .bmAttributes
= UASP_SS_EP_COMP_LOG_STREAMS
,
1893 static struct usb_endpoint_descriptor uasp_cmd_desc
= {
1894 .bLength
= USB_DT_ENDPOINT_SIZE
,
1895 .bDescriptorType
= USB_DT_ENDPOINT
,
1896 .bEndpointAddress
= USB_DIR_OUT
,
1897 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1898 .wMaxPacketSize
= cpu_to_le16(512),
1901 static struct usb_endpoint_descriptor uasp_fs_cmd_desc
= {
1902 .bLength
= USB_DT_ENDPOINT_SIZE
,
1903 .bDescriptorType
= USB_DT_ENDPOINT
,
1904 .bEndpointAddress
= USB_DIR_OUT
,
1905 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1908 static struct usb_pipe_usage_descriptor uasp_cmd_pipe_desc
= {
1909 .bLength
= sizeof(uasp_cmd_pipe_desc
),
1910 .bDescriptorType
= USB_DT_PIPE_USAGE
,
1911 .bPipeID
= CMD_PIPE_ID
,
1914 static struct usb_endpoint_descriptor uasp_ss_cmd_desc
= {
1915 .bLength
= USB_DT_ENDPOINT_SIZE
,
1916 .bDescriptorType
= USB_DT_ENDPOINT
,
1917 .bEndpointAddress
= USB_DIR_OUT
,
1918 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
1919 .wMaxPacketSize
= cpu_to_le16(1024),
1922 static struct usb_ss_ep_comp_descriptor uasp_cmd_comp_desc
= {
1923 .bLength
= sizeof(uasp_cmd_comp_desc
),
1924 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
1927 static struct usb_descriptor_header
*uasp_fs_function_desc
[] = {
1928 (struct usb_descriptor_header
*) &bot_intf_desc
,
1929 (struct usb_descriptor_header
*) &uasp_fs_bi_desc
,
1930 (struct usb_descriptor_header
*) &uasp_fs_bo_desc
,
1932 (struct usb_descriptor_header
*) &uasp_intf_desc
,
1933 (struct usb_descriptor_header
*) &uasp_fs_bi_desc
,
1934 (struct usb_descriptor_header
*) &uasp_bi_pipe_desc
,
1935 (struct usb_descriptor_header
*) &uasp_fs_bo_desc
,
1936 (struct usb_descriptor_header
*) &uasp_bo_pipe_desc
,
1937 (struct usb_descriptor_header
*) &uasp_fs_status_desc
,
1938 (struct usb_descriptor_header
*) &uasp_status_pipe_desc
,
1939 (struct usb_descriptor_header
*) &uasp_fs_cmd_desc
,
1940 (struct usb_descriptor_header
*) &uasp_cmd_pipe_desc
,
1944 static struct usb_descriptor_header
*uasp_hs_function_desc
[] = {
1945 (struct usb_descriptor_header
*) &bot_intf_desc
,
1946 (struct usb_descriptor_header
*) &uasp_bi_desc
,
1947 (struct usb_descriptor_header
*) &uasp_bo_desc
,
1949 (struct usb_descriptor_header
*) &uasp_intf_desc
,
1950 (struct usb_descriptor_header
*) &uasp_bi_desc
,
1951 (struct usb_descriptor_header
*) &uasp_bi_pipe_desc
,
1952 (struct usb_descriptor_header
*) &uasp_bo_desc
,
1953 (struct usb_descriptor_header
*) &uasp_bo_pipe_desc
,
1954 (struct usb_descriptor_header
*) &uasp_status_desc
,
1955 (struct usb_descriptor_header
*) &uasp_status_pipe_desc
,
1956 (struct usb_descriptor_header
*) &uasp_cmd_desc
,
1957 (struct usb_descriptor_header
*) &uasp_cmd_pipe_desc
,
1961 static struct usb_descriptor_header
*uasp_ss_function_desc
[] = {
1962 (struct usb_descriptor_header
*) &bot_intf_desc
,
1963 (struct usb_descriptor_header
*) &uasp_ss_bi_desc
,
1964 (struct usb_descriptor_header
*) &bot_bi_ep_comp_desc
,
1965 (struct usb_descriptor_header
*) &uasp_ss_bo_desc
,
1966 (struct usb_descriptor_header
*) &bot_bo_ep_comp_desc
,
1968 (struct usb_descriptor_header
*) &uasp_intf_desc
,
1969 (struct usb_descriptor_header
*) &uasp_ss_bi_desc
,
1970 (struct usb_descriptor_header
*) &uasp_bi_ep_comp_desc
,
1971 (struct usb_descriptor_header
*) &uasp_bi_pipe_desc
,
1972 (struct usb_descriptor_header
*) &uasp_ss_bo_desc
,
1973 (struct usb_descriptor_header
*) &uasp_bo_ep_comp_desc
,
1974 (struct usb_descriptor_header
*) &uasp_bo_pipe_desc
,
1975 (struct usb_descriptor_header
*) &uasp_ss_status_desc
,
1976 (struct usb_descriptor_header
*) &uasp_status_in_ep_comp_desc
,
1977 (struct usb_descriptor_header
*) &uasp_status_pipe_desc
,
1978 (struct usb_descriptor_header
*) &uasp_ss_cmd_desc
,
1979 (struct usb_descriptor_header
*) &uasp_cmd_comp_desc
,
1980 (struct usb_descriptor_header
*) &uasp_cmd_pipe_desc
,
1984 static struct usb_string tcm_us_strings
[] = {
1985 [USB_G_STR_INT_UAS
].s
= "USB Attached SCSI",
1986 [USB_G_STR_INT_BBB
].s
= "Bulk Only Transport",
1990 static struct usb_gadget_strings tcm_stringtab
= {
1992 .strings
= tcm_us_strings
,
1995 static struct usb_gadget_strings
*tcm_strings
[] = {
2000 static int tcm_bind(struct usb_configuration
*c
, struct usb_function
*f
)
2002 struct f_uas
*fu
= to_f_uas(f
);
2003 struct usb_string
*us
;
2004 struct usb_gadget
*gadget
= c
->cdev
->gadget
;
2006 struct f_tcm_opts
*opts
;
2010 opts
= container_of(f
->fi
, struct f_tcm_opts
, func_inst
);
2012 mutex_lock(&opts
->dep_lock
);
2013 if (!opts
->can_attach
) {
2014 mutex_unlock(&opts
->dep_lock
);
2017 mutex_unlock(&opts
->dep_lock
);
2018 us
= usb_gstrings_attach(c
->cdev
, tcm_strings
,
2019 ARRAY_SIZE(tcm_us_strings
));
2022 bot_intf_desc
.iInterface
= us
[USB_G_STR_INT_BBB
].id
;
2023 uasp_intf_desc
.iInterface
= us
[USB_G_STR_INT_UAS
].id
;
2025 iface
= usb_interface_id(c
, f
);
2029 bot_intf_desc
.bInterfaceNumber
= iface
;
2030 uasp_intf_desc
.bInterfaceNumber
= iface
;
2032 ep
= usb_ep_autoconfig_ss(gadget
, &uasp_ss_bi_desc
,
2033 &uasp_bi_ep_comp_desc
);
2039 ep
= usb_ep_autoconfig_ss(gadget
, &uasp_ss_bo_desc
,
2040 &uasp_bo_ep_comp_desc
);
2045 ep
= usb_ep_autoconfig_ss(gadget
, &uasp_ss_status_desc
,
2046 &uasp_status_in_ep_comp_desc
);
2051 ep
= usb_ep_autoconfig_ss(gadget
, &uasp_ss_cmd_desc
,
2052 &uasp_cmd_comp_desc
);
2057 /* Assume endpoint addresses are the same for both speeds */
2058 uasp_bi_desc
.bEndpointAddress
= uasp_ss_bi_desc
.bEndpointAddress
;
2059 uasp_bo_desc
.bEndpointAddress
= uasp_ss_bo_desc
.bEndpointAddress
;
2060 uasp_status_desc
.bEndpointAddress
=
2061 uasp_ss_status_desc
.bEndpointAddress
;
2062 uasp_cmd_desc
.bEndpointAddress
= uasp_ss_cmd_desc
.bEndpointAddress
;
2064 uasp_fs_bi_desc
.bEndpointAddress
= uasp_ss_bi_desc
.bEndpointAddress
;
2065 uasp_fs_bo_desc
.bEndpointAddress
= uasp_ss_bo_desc
.bEndpointAddress
;
2066 uasp_fs_status_desc
.bEndpointAddress
=
2067 uasp_ss_status_desc
.bEndpointAddress
;
2068 uasp_fs_cmd_desc
.bEndpointAddress
= uasp_ss_cmd_desc
.bEndpointAddress
;
2070 ret
= usb_assign_descriptors(f
, uasp_fs_function_desc
,
2071 uasp_hs_function_desc
, uasp_ss_function_desc
, NULL
);
2077 pr_err("Can't claim all required eps\n");
2082 struct guas_setup_wq
{
2083 struct work_struct work
;
2088 static void tcm_delayed_set_alt(struct work_struct
*wq
)
2090 struct guas_setup_wq
*work
= container_of(wq
, struct guas_setup_wq
,
2092 struct f_uas
*fu
= work
->fu
;
2093 int alt
= work
->alt
;
2097 if (fu
->flags
& USBG_IS_BOT
)
2098 bot_cleanup_old_alt(fu
);
2099 if (fu
->flags
& USBG_IS_UAS
)
2100 uasp_cleanup_old_alt(fu
);
2102 if (alt
== USB_G_ALT_INT_BBB
)
2104 else if (alt
== USB_G_ALT_INT_UAS
)
2106 usb_composite_setup_continue(fu
->function
.config
->cdev
);
2109 static int tcm_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
2111 struct f_uas
*fu
= to_f_uas(f
);
2113 if ((alt
== USB_G_ALT_INT_BBB
) || (alt
== USB_G_ALT_INT_UAS
)) {
2114 struct guas_setup_wq
*work
;
2116 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
2119 INIT_WORK(&work
->work
, tcm_delayed_set_alt
);
2122 schedule_work(&work
->work
);
2123 return USB_GADGET_DELAYED_STATUS
;
2128 static void tcm_disable(struct usb_function
*f
)
2130 struct f_uas
*fu
= to_f_uas(f
);
2132 if (fu
->flags
& USBG_IS_UAS
)
2133 uasp_cleanup_old_alt(fu
);
2134 else if (fu
->flags
& USBG_IS_BOT
)
2135 bot_cleanup_old_alt(fu
);
2139 static int tcm_setup(struct usb_function
*f
,
2140 const struct usb_ctrlrequest
*ctrl
)
2142 struct f_uas
*fu
= to_f_uas(f
);
2144 if (!(fu
->flags
& USBG_IS_BOT
))
2147 return usbg_bot_setup(f
, ctrl
);
2150 static inline struct f_tcm_opts
*to_f_tcm_opts(struct config_item
*item
)
2152 return container_of(to_config_group(item
), struct f_tcm_opts
,
2156 static void tcm_attr_release(struct config_item
*item
)
2158 struct f_tcm_opts
*opts
= to_f_tcm_opts(item
);
2160 usb_put_function_instance(&opts
->func_inst
);
2163 static struct configfs_item_operations tcm_item_ops
= {
2164 .release
= tcm_attr_release
,
2167 static struct config_item_type tcm_func_type
= {
2168 .ct_item_ops
= &tcm_item_ops
,
2169 .ct_owner
= THIS_MODULE
,
2172 static void tcm_free_inst(struct usb_function_instance
*f
)
2174 struct f_tcm_opts
*opts
;
2177 opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2179 mutex_lock(&tpg_instances_lock
);
2180 for (i
= 0; i
< TPG_INSTANCES
; ++i
)
2181 if (tpg_instances
[i
].func_inst
== f
)
2183 if (i
< TPG_INSTANCES
)
2184 tpg_instances
[i
].func_inst
= NULL
;
2185 mutex_unlock(&tpg_instances_lock
);
2190 static int tcm_register_callback(struct usb_function_instance
*f
)
2192 struct f_tcm_opts
*opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2194 mutex_lock(&opts
->dep_lock
);
2195 opts
->can_attach
= true;
2196 mutex_unlock(&opts
->dep_lock
);
2201 static void tcm_unregister_callback(struct usb_function_instance
*f
)
2203 struct f_tcm_opts
*opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2205 mutex_lock(&opts
->dep_lock
);
2206 unregister_gadget_item(opts
->
2207 func_inst
.group
.cg_item
.ci_parent
->ci_parent
);
2208 opts
->can_attach
= false;
2209 mutex_unlock(&opts
->dep_lock
);
2212 static int usbg_attach(struct usbg_tpg
*tpg
)
2214 struct usb_function_instance
*f
= tpg
->fi
;
2215 struct f_tcm_opts
*opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2217 if (opts
->tcm_register_callback
)
2218 return opts
->tcm_register_callback(f
);
2223 static void usbg_detach(struct usbg_tpg
*tpg
)
2225 struct usb_function_instance
*f
= tpg
->fi
;
2226 struct f_tcm_opts
*opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2228 if (opts
->tcm_unregister_callback
)
2229 opts
->tcm_unregister_callback(f
);
2232 static int tcm_set_name(struct usb_function_instance
*f
, const char *name
)
2234 struct f_tcm_opts
*opts
= container_of(f
, struct f_tcm_opts
, func_inst
);
2236 pr_debug("tcm: Activating %s\n", name
);
2238 mutex_lock(&opts
->dep_lock
);
2240 mutex_unlock(&opts
->dep_lock
);
2245 static struct usb_function_instance
*tcm_alloc_inst(void)
2247 struct f_tcm_opts
*opts
;
2251 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
2253 return ERR_PTR(-ENOMEM
);
2255 mutex_lock(&tpg_instances_lock
);
2256 for (i
= 0; i
< TPG_INSTANCES
; ++i
)
2257 if (!tpg_instances
[i
].func_inst
)
2260 if (i
== TPG_INSTANCES
) {
2261 mutex_unlock(&tpg_instances_lock
);
2263 return ERR_PTR(-EBUSY
);
2265 tpg_instances
[i
].func_inst
= &opts
->func_inst
;
2266 mutex_unlock(&tpg_instances_lock
);
2268 mutex_init(&opts
->dep_lock
);
2269 opts
->func_inst
.set_inst_name
= tcm_set_name
;
2270 opts
->func_inst
.free_func_inst
= tcm_free_inst
;
2271 opts
->tcm_register_callback
= tcm_register_callback
;
2272 opts
->tcm_unregister_callback
= tcm_unregister_callback
;
2274 config_group_init_type_name(&opts
->func_inst
.group
, "",
2277 return &opts
->func_inst
;
2280 static void tcm_free(struct usb_function
*f
)
2282 struct f_uas
*tcm
= to_f_uas(f
);
2287 static void tcm_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
2289 usb_free_all_descriptors(f
);
2292 static struct usb_function
*tcm_alloc(struct usb_function_instance
*fi
)
2297 mutex_lock(&tpg_instances_lock
);
2298 for (i
= 0; i
< TPG_INSTANCES
; ++i
)
2299 if (tpg_instances
[i
].func_inst
== fi
)
2301 if (i
== TPG_INSTANCES
) {
2302 mutex_unlock(&tpg_instances_lock
);
2303 return ERR_PTR(-ENODEV
);
2306 fu
= kzalloc(sizeof(*fu
), GFP_KERNEL
);
2308 mutex_unlock(&tpg_instances_lock
);
2309 return ERR_PTR(-ENOMEM
);
2312 fu
->function
.name
= "Target Function";
2313 fu
->function
.bind
= tcm_bind
;
2314 fu
->function
.unbind
= tcm_unbind
;
2315 fu
->function
.set_alt
= tcm_set_alt
;
2316 fu
->function
.setup
= tcm_setup
;
2317 fu
->function
.disable
= tcm_disable
;
2318 fu
->function
.free_func
= tcm_free
;
2319 fu
->tpg
= tpg_instances
[i
].tpg
;
2320 mutex_unlock(&tpg_instances_lock
);
2322 return &fu
->function
;
2325 DECLARE_USB_FUNCTION(tcm
, tcm_alloc_inst
, tcm_alloc
);
2327 static int tcm_init(void)
2331 ret
= usb_function_register(&tcmusb_func
);
2335 ret
= target_register_template(&usbg_ops
);
2337 usb_function_unregister(&tcmusb_func
);
2341 module_init(tcm_init
);
2343 static void tcm_exit(void)
2345 target_unregister_template(&usbg_ops
);
2346 usb_function_unregister(&tcmusb_func
);
2348 module_exit(tcm_exit
);
2350 MODULE_LICENSE("GPL");
2351 MODULE_AUTHOR("Sebastian Andrzej Siewior");