4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 #include <linux/delay.h>
18 #include <linux/dma-mapping.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/usb/ch9.h>
23 #include <linux/usb/gadget.h>
24 #include <linux/usb/otg.h>
30 struct usbhsg_request
{
31 struct usb_request req
;
35 #define EP_NAME_SIZE 8
39 struct usbhs_pipe
*pipe
;
41 char ep_name
[EP_NAME_SIZE
];
43 struct usbhsg_gpriv
*gpriv
;
47 struct usb_gadget gadget
;
50 struct usbhsg_uep
*uep
;
53 struct usb_gadget_driver
*driver
;
54 struct usb_phy
*transceiver
;
58 #define USBHSG_STATUS_STARTED (1 << 0)
59 #define USBHSG_STATUS_REGISTERD (1 << 1)
60 #define USBHSG_STATUS_WEDGE (1 << 2)
61 #define USBHSG_STATUS_SELF_POWERED (1 << 3)
62 #define USBHSG_STATUS_SOFT_CONNECT (1 << 4)
65 struct usbhsg_recip_handle
{
67 int (*device
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
68 struct usb_ctrlrequest
*ctrl
);
69 int (*interface
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
70 struct usb_ctrlrequest
*ctrl
);
71 int (*endpoint
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
72 struct usb_ctrlrequest
*ctrl
);
78 #define usbhsg_priv_to_gpriv(priv) \
80 usbhs_mod_get(priv, USBHS_GADGET), \
81 struct usbhsg_gpriv, mod)
83 #define __usbhsg_for_each_uep(start, pos, g, i) \
85 ((i) < (g)->uep_size) && ((pos) = (g)->uep + (i)); \
88 #define usbhsg_for_each_uep(pos, gpriv, i) \
89 __usbhsg_for_each_uep(1, pos, gpriv, i)
91 #define usbhsg_for_each_uep_with_dcp(pos, gpriv, i) \
92 __usbhsg_for_each_uep(0, pos, gpriv, i)
94 #define usbhsg_gadget_to_gpriv(g)\
95 container_of(g, struct usbhsg_gpriv, gadget)
97 #define usbhsg_req_to_ureq(r)\
98 container_of(r, struct usbhsg_request, req)
100 #define usbhsg_ep_to_uep(e) container_of(e, struct usbhsg_uep, ep)
101 #define usbhsg_gpriv_to_dev(gp) usbhs_priv_to_dev((gp)->mod.priv)
102 #define usbhsg_gpriv_to_priv(gp) ((gp)->mod.priv)
103 #define usbhsg_gpriv_to_dcp(gp) ((gp)->uep)
104 #define usbhsg_gpriv_to_nth_uep(gp, i) ((gp)->uep + i)
105 #define usbhsg_uep_to_gpriv(u) ((u)->gpriv)
106 #define usbhsg_uep_to_pipe(u) ((u)->pipe)
107 #define usbhsg_pipe_to_uep(p) ((p)->mod_private)
108 #define usbhsg_is_dcp(u) ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
110 #define usbhsg_ureq_to_pkt(u) (&(u)->pkt)
111 #define usbhsg_pkt_to_ureq(i) \
112 container_of(i, struct usbhsg_request, pkt)
114 #define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
117 #define usbhsg_status_init(gp) do {(gp)->status = 0; } while (0)
118 #define usbhsg_status_set(gp, b) (gp->status |= b)
119 #define usbhsg_status_clr(gp, b) (gp->status &= ~b)
120 #define usbhsg_status_has(gp, b) (gp->status & b)
125 static void __usbhsg_queue_pop(struct usbhsg_uep
*uep
,
126 struct usbhsg_request
*ureq
,
129 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
130 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
131 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
132 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
135 dev_dbg(dev
, "pipe %d : queue pop\n", usbhs_pipe_number(pipe
));
137 ureq
->req
.status
= status
;
138 spin_unlock(usbhs_priv_to_lock(priv
));
139 usb_gadget_giveback_request(&uep
->ep
, &ureq
->req
);
140 spin_lock(usbhs_priv_to_lock(priv
));
143 static void usbhsg_queue_pop(struct usbhsg_uep
*uep
,
144 struct usbhsg_request
*ureq
,
147 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
148 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
151 usbhs_lock(priv
, flags
);
152 __usbhsg_queue_pop(uep
, ureq
, status
);
153 usbhs_unlock(priv
, flags
);
156 static void usbhsg_queue_done(struct usbhs_priv
*priv
, struct usbhs_pkt
*pkt
)
158 struct usbhs_pipe
*pipe
= pkt
->pipe
;
159 struct usbhsg_uep
*uep
= usbhsg_pipe_to_uep(pipe
);
160 struct usbhsg_request
*ureq
= usbhsg_pkt_to_ureq(pkt
);
163 ureq
->req
.actual
= pkt
->actual
;
165 usbhs_lock(priv
, flags
);
167 __usbhsg_queue_pop(uep
, ureq
, 0);
168 usbhs_unlock(priv
, flags
);
171 static void usbhsg_queue_push(struct usbhsg_uep
*uep
,
172 struct usbhsg_request
*ureq
)
174 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
175 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
176 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
177 struct usbhs_pkt
*pkt
= usbhsg_ureq_to_pkt(ureq
);
178 struct usb_request
*req
= &ureq
->req
;
181 req
->status
= -EINPROGRESS
;
182 usbhs_pkt_push(pipe
, pkt
, usbhsg_queue_done
,
183 req
->buf
, req
->length
, req
->zero
, -1);
184 usbhs_pkt_start(pipe
);
186 dev_dbg(dev
, "pipe %d : queue push (%d)\n",
187 usbhs_pipe_number(pipe
),
194 static int usbhsg_dma_map_ctrl(struct device
*dma_dev
, struct usbhs_pkt
*pkt
,
197 struct usbhsg_request
*ureq
= usbhsg_pkt_to_ureq(pkt
);
198 struct usb_request
*req
= &ureq
->req
;
199 struct usbhs_pipe
*pipe
= pkt
->pipe
;
200 enum dma_data_direction dir
;
203 dir
= usbhs_pipe_is_dir_host(pipe
);
206 /* it can not use scatter/gather */
207 WARN_ON(req
->num_sgs
);
209 ret
= usb_gadget_map_request_by_dev(dma_dev
, req
, dir
);
215 usb_gadget_unmap_request_by_dev(dma_dev
, req
, dir
);
222 * USB_TYPE_STANDARD / clear feature functions
224 static int usbhsg_recip_handler_std_control_done(struct usbhs_priv
*priv
,
225 struct usbhsg_uep
*uep
,
226 struct usb_ctrlrequest
*ctrl
)
228 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
229 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
230 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(dcp
);
232 usbhs_dcp_control_transfer_done(pipe
);
237 static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv
*priv
,
238 struct usbhsg_uep
*uep
,
239 struct usb_ctrlrequest
*ctrl
)
241 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
242 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
244 if (!usbhsg_status_has(gpriv
, USBHSG_STATUS_WEDGE
)) {
245 usbhs_pipe_disable(pipe
);
246 usbhs_pipe_sequence_data0(pipe
);
247 usbhs_pipe_enable(pipe
);
250 usbhsg_recip_handler_std_control_done(priv
, uep
, ctrl
);
252 usbhs_pkt_start(pipe
);
257 static struct usbhsg_recip_handle req_clear_feature
= {
258 .name
= "clear feature",
259 .device
= usbhsg_recip_handler_std_control_done
,
260 .interface
= usbhsg_recip_handler_std_control_done
,
261 .endpoint
= usbhsg_recip_handler_std_clear_endpoint
,
265 * USB_TYPE_STANDARD / set feature functions
267 static int usbhsg_recip_handler_std_set_device(struct usbhs_priv
*priv
,
268 struct usbhsg_uep
*uep
,
269 struct usb_ctrlrequest
*ctrl
)
271 switch (le16_to_cpu(ctrl
->wValue
)) {
272 case USB_DEVICE_TEST_MODE
:
273 usbhsg_recip_handler_std_control_done(priv
, uep
, ctrl
);
275 usbhs_sys_set_test_mode(priv
, le16_to_cpu(ctrl
->wIndex
>> 8));
278 usbhsg_recip_handler_std_control_done(priv
, uep
, ctrl
);
285 static int usbhsg_recip_handler_std_set_endpoint(struct usbhs_priv
*priv
,
286 struct usbhsg_uep
*uep
,
287 struct usb_ctrlrequest
*ctrl
)
289 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
291 usbhs_pipe_stall(pipe
);
293 usbhsg_recip_handler_std_control_done(priv
, uep
, ctrl
);
298 static struct usbhsg_recip_handle req_set_feature
= {
299 .name
= "set feature",
300 .device
= usbhsg_recip_handler_std_set_device
,
301 .interface
= usbhsg_recip_handler_std_control_done
,
302 .endpoint
= usbhsg_recip_handler_std_set_endpoint
,
306 * USB_TYPE_STANDARD / get status functions
308 static void __usbhsg_recip_send_complete(struct usb_ep
*ep
,
309 struct usb_request
*req
)
311 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
313 /* free allocated recip-buffer/usb_request */
314 kfree(ureq
->pkt
.buf
);
315 usb_ep_free_request(ep
, req
);
318 static void __usbhsg_recip_send_status(struct usbhsg_gpriv
*gpriv
,
319 unsigned short status
)
321 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
322 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(dcp
);
323 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
324 struct usb_request
*req
;
327 /* alloc new usb_request for recip */
328 req
= usb_ep_alloc_request(&dcp
->ep
, GFP_ATOMIC
);
330 dev_err(dev
, "recip request allocation fail\n");
334 /* alloc recip data buffer */
335 buf
= kmalloc(sizeof(*buf
), GFP_ATOMIC
);
337 usb_ep_free_request(&dcp
->ep
, req
);
338 dev_err(dev
, "recip data allocation fail\n");
342 /* recip data is status */
343 *buf
= cpu_to_le16(status
);
345 /* allocated usb_request/buffer will be freed */
346 req
->complete
= __usbhsg_recip_send_complete
;
348 req
->length
= sizeof(*buf
);
352 pipe
->handler
= &usbhs_fifo_pio_push_handler
;
353 usbhsg_queue_push(dcp
, usbhsg_req_to_ureq(req
));
356 static int usbhsg_recip_handler_std_get_device(struct usbhs_priv
*priv
,
357 struct usbhsg_uep
*uep
,
358 struct usb_ctrlrequest
*ctrl
)
360 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
361 unsigned short status
= 0;
363 if (usbhsg_status_has(gpriv
, USBHSG_STATUS_SELF_POWERED
))
364 status
= 1 << USB_DEVICE_SELF_POWERED
;
366 __usbhsg_recip_send_status(gpriv
, status
);
371 static int usbhsg_recip_handler_std_get_interface(struct usbhs_priv
*priv
,
372 struct usbhsg_uep
*uep
,
373 struct usb_ctrlrequest
*ctrl
)
375 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
376 unsigned short status
= 0;
378 __usbhsg_recip_send_status(gpriv
, status
);
383 static int usbhsg_recip_handler_std_get_endpoint(struct usbhs_priv
*priv
,
384 struct usbhsg_uep
*uep
,
385 struct usb_ctrlrequest
*ctrl
)
387 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
388 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
389 unsigned short status
= 0;
391 if (usbhs_pipe_is_stall(pipe
))
392 status
= 1 << USB_ENDPOINT_HALT
;
394 __usbhsg_recip_send_status(gpriv
, status
);
399 static struct usbhsg_recip_handle req_get_status
= {
400 .name
= "get status",
401 .device
= usbhsg_recip_handler_std_get_device
,
402 .interface
= usbhsg_recip_handler_std_get_interface
,
403 .endpoint
= usbhsg_recip_handler_std_get_endpoint
,
409 static int usbhsg_recip_run_handle(struct usbhs_priv
*priv
,
410 struct usbhsg_recip_handle
*handler
,
411 struct usb_ctrlrequest
*ctrl
)
413 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
414 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
415 struct usbhsg_uep
*uep
;
416 struct usbhs_pipe
*pipe
;
417 int recip
= ctrl
->bRequestType
& USB_RECIP_MASK
;
418 int nth
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
420 int (*func
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
421 struct usb_ctrlrequest
*ctrl
);
424 uep
= usbhsg_gpriv_to_nth_uep(gpriv
, nth
);
425 pipe
= usbhsg_uep_to_pipe(uep
);
427 dev_err(dev
, "wrong recip request\n");
432 case USB_RECIP_DEVICE
:
434 func
= handler
->device
;
436 case USB_RECIP_INTERFACE
:
438 func
= handler
->interface
;
440 case USB_RECIP_ENDPOINT
:
442 func
= handler
->endpoint
;
445 dev_warn(dev
, "unsupported RECIP(%d)\n", recip
);
451 dev_dbg(dev
, "%s (pipe %d :%s)\n", handler
->name
, nth
, msg
);
452 ret
= func(priv
, uep
, ctrl
);
461 * it will be called from usbhs_interrupt
463 static int usbhsg_irq_dev_state(struct usbhs_priv
*priv
,
464 struct usbhs_irq_state
*irq_state
)
466 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
467 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
469 gpriv
->gadget
.speed
= usbhs_bus_get_speed(priv
);
471 dev_dbg(dev
, "state = %x : speed : %d\n",
472 usbhs_status_get_device_state(irq_state
),
473 gpriv
->gadget
.speed
);
478 static int usbhsg_irq_ctrl_stage(struct usbhs_priv
*priv
,
479 struct usbhs_irq_state
*irq_state
)
481 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
482 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
483 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(dcp
);
484 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
485 struct usb_ctrlrequest ctrl
;
486 struct usbhsg_recip_handle
*recip_handler
= NULL
;
487 int stage
= usbhs_status_get_ctrl_stage(irq_state
);
490 dev_dbg(dev
, "stage = %d\n", stage
);
496 * - "Interrupt Function"
497 * - "Control Transfer Stage Transition Interrupt"
498 * - Fig. "Control Transfer Stage Transitions"
502 case READ_DATA_STAGE
:
503 pipe
->handler
= &usbhs_fifo_pio_push_handler
;
505 case WRITE_DATA_STAGE
:
506 pipe
->handler
= &usbhs_fifo_pio_pop_handler
;
508 case NODATA_STATUS_STAGE
:
509 pipe
->handler
= &usbhs_ctrl_stage_end_handler
;
511 case READ_STATUS_STAGE
:
512 case WRITE_STATUS_STAGE
:
513 usbhs_dcp_control_transfer_done(pipe
);
521 usbhs_usbreq_get_val(priv
, &ctrl
);
523 switch (ctrl
.bRequestType
& USB_TYPE_MASK
) {
524 case USB_TYPE_STANDARD
:
525 switch (ctrl
.bRequest
) {
526 case USB_REQ_CLEAR_FEATURE
:
527 recip_handler
= &req_clear_feature
;
529 case USB_REQ_SET_FEATURE
:
530 recip_handler
= &req_set_feature
;
532 case USB_REQ_GET_STATUS
:
533 recip_handler
= &req_get_status
;
539 * setup stage / run recip
542 ret
= usbhsg_recip_run_handle(priv
, recip_handler
, &ctrl
);
544 ret
= gpriv
->driver
->setup(&gpriv
->gadget
, &ctrl
);
547 usbhs_pipe_stall(pipe
);
557 static int usbhsg_pipe_disable(struct usbhsg_uep
*uep
)
559 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
560 struct usbhs_pkt
*pkt
;
563 pkt
= usbhs_pkt_pop(pipe
, NULL
);
567 usbhsg_queue_pop(uep
, usbhsg_pkt_to_ureq(pkt
), -ESHUTDOWN
);
570 usbhs_pipe_disable(pipe
);
580 static int usbhsg_ep_enable(struct usb_ep
*ep
,
581 const struct usb_endpoint_descriptor
*desc
)
583 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
584 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
585 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
586 struct usbhs_pipe
*pipe
;
590 usbhs_lock(priv
, flags
);
593 * if it already have pipe,
597 usbhs_pipe_clear(uep
->pipe
);
598 usbhs_pipe_sequence_data0(uep
->pipe
);
600 goto usbhsg_ep_enable_end
;
603 pipe
= usbhs_pipe_malloc(priv
,
604 usb_endpoint_type(desc
),
605 usb_endpoint_dir_in(desc
));
608 pipe
->mod_private
= uep
;
610 /* set epnum / maxp */
611 usbhs_pipe_config_update(pipe
, 0,
612 usb_endpoint_num(desc
),
613 usb_endpoint_maxp(desc
));
616 * usbhs_fifo_dma_push/pop_handler try to
617 * use dmaengine if possible.
618 * It will use pio handler if impossible.
620 if (usb_endpoint_dir_in(desc
)) {
621 pipe
->handler
= &usbhs_fifo_dma_push_handler
;
623 pipe
->handler
= &usbhs_fifo_dma_pop_handler
;
624 usbhs_xxxsts_clear(priv
, BRDYSTS
,
625 usbhs_pipe_number(pipe
));
631 usbhsg_ep_enable_end
:
632 usbhs_unlock(priv
, flags
);
637 static int usbhsg_ep_disable(struct usb_ep
*ep
)
639 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
640 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
645 usbhsg_pipe_disable(uep
);
646 usbhs_pipe_free(pipe
);
648 uep
->pipe
->mod_private
= NULL
;
654 static struct usb_request
*usbhsg_ep_alloc_request(struct usb_ep
*ep
,
657 struct usbhsg_request
*ureq
;
659 ureq
= kzalloc(sizeof *ureq
, gfp_flags
);
663 usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq
));
668 static void usbhsg_ep_free_request(struct usb_ep
*ep
,
669 struct usb_request
*req
)
671 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
673 WARN_ON(!list_empty(&ureq
->pkt
.node
));
677 static int usbhsg_ep_queue(struct usb_ep
*ep
, struct usb_request
*req
,
680 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
681 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
682 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
683 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
686 if (usbhsg_is_not_connected(gpriv
) ||
687 unlikely(!gpriv
->driver
) ||
691 usbhsg_queue_push(uep
, ureq
);
696 static int usbhsg_ep_dequeue(struct usb_ep
*ep
, struct usb_request
*req
)
698 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
699 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
700 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
703 usbhs_pkt_pop(pipe
, usbhsg_ureq_to_pkt(ureq
));
706 * To dequeue a request, this driver should call the usbhsg_queue_pop()
707 * even if the pipe is NULL.
709 usbhsg_queue_pop(uep
, ureq
, -ECONNRESET
);
714 static int __usbhsg_ep_set_halt_wedge(struct usb_ep
*ep
, int halt
, int wedge
)
716 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
717 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
718 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
719 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
720 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
723 usbhsg_pipe_disable(uep
);
725 dev_dbg(dev
, "set halt %d (pipe %d)\n",
726 halt
, usbhs_pipe_number(pipe
));
728 /******************** spin lock ********************/
729 usbhs_lock(priv
, flags
);
732 usbhs_pipe_stall(pipe
);
734 usbhs_pipe_disable(pipe
);
737 usbhsg_status_set(gpriv
, USBHSG_STATUS_WEDGE
);
739 usbhsg_status_clr(gpriv
, USBHSG_STATUS_WEDGE
);
741 usbhs_unlock(priv
, flags
);
742 /******************** spin unlock ******************/
747 static int usbhsg_ep_set_halt(struct usb_ep
*ep
, int value
)
749 return __usbhsg_ep_set_halt_wedge(ep
, value
, 0);
752 static int usbhsg_ep_set_wedge(struct usb_ep
*ep
)
754 return __usbhsg_ep_set_halt_wedge(ep
, 1, 1);
757 static struct usb_ep_ops usbhsg_ep_ops
= {
758 .enable
= usbhsg_ep_enable
,
759 .disable
= usbhsg_ep_disable
,
761 .alloc_request
= usbhsg_ep_alloc_request
,
762 .free_request
= usbhsg_ep_free_request
,
764 .queue
= usbhsg_ep_queue
,
765 .dequeue
= usbhsg_ep_dequeue
,
767 .set_halt
= usbhsg_ep_set_halt
,
768 .set_wedge
= usbhsg_ep_set_wedge
,
774 static int usbhsg_can_pullup(struct usbhs_priv
*priv
)
776 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
778 return gpriv
->driver
&&
779 usbhsg_status_has(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
782 static void usbhsg_update_pullup(struct usbhs_priv
*priv
)
784 if (usbhsg_can_pullup(priv
))
785 usbhs_sys_function_pullup(priv
, 1);
787 usbhs_sys_function_pullup(priv
, 0);
791 * usb module start/end
793 static int usbhsg_try_start(struct usbhs_priv
*priv
, u32 status
)
795 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
796 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
797 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
798 struct device
*dev
= usbhs_priv_to_dev(priv
);
802 /******************** spin lock ********************/
803 usbhs_lock(priv
, flags
);
805 usbhsg_status_set(gpriv
, status
);
806 if (!(usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
807 usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
)))
808 ret
= -1; /* not ready */
810 usbhs_unlock(priv
, flags
);
811 /******************** spin unlock ********************/
814 return 0; /* not ready is not error */
817 * enable interrupt and systems if ready
819 dev_dbg(dev
, "start gadget\n");
822 * pipe initialize and enable DCP
824 usbhs_fifo_init(priv
);
825 usbhs_pipe_init(priv
,
826 usbhsg_dma_map_ctrl
);
828 /* dcp init instead of usbhsg_ep_enable() */
829 dcp
->pipe
= usbhs_dcp_malloc(priv
);
830 dcp
->pipe
->mod_private
= dcp
;
831 usbhs_pipe_config_update(dcp
->pipe
, 0, 0, 64);
834 * system config enble
839 usbhs_sys_function_ctrl(priv
, 1);
840 usbhsg_update_pullup(priv
);
843 * enable irq callback
845 mod
->irq_dev_state
= usbhsg_irq_dev_state
;
846 mod
->irq_ctrl_stage
= usbhsg_irq_ctrl_stage
;
847 usbhs_irq_callback_update(priv
, mod
);
852 static int usbhsg_try_stop(struct usbhs_priv
*priv
, u32 status
)
854 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
855 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
856 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
857 struct device
*dev
= usbhs_priv_to_dev(priv
);
861 /******************** spin lock ********************/
862 usbhs_lock(priv
, flags
);
864 usbhsg_status_clr(gpriv
, status
);
865 if (!usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
866 !usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
))
867 ret
= -1; /* already done */
869 usbhs_unlock(priv
, flags
);
870 /******************** spin unlock ********************/
873 return 0; /* already done is not error */
876 * disable interrupt and systems if 1st try
878 usbhs_fifo_quit(priv
);
880 /* disable all irq */
881 mod
->irq_dev_state
= NULL
;
882 mod
->irq_ctrl_stage
= NULL
;
883 usbhs_irq_callback_update(priv
, mod
);
885 gpriv
->gadget
.speed
= USB_SPEED_UNKNOWN
;
888 usbhs_sys_set_test_mode(priv
, 0);
889 usbhs_sys_function_ctrl(priv
, 0);
891 usbhsg_ep_disable(&dcp
->ep
);
893 dev_dbg(dev
, "stop gadget\n");
899 * VBUS provided by the PHY
901 static int usbhsm_phy_get_vbus(struct platform_device
*pdev
)
903 struct usbhs_priv
*priv
= usbhs_pdev_to_priv(pdev
);
904 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
906 return gpriv
->vbus_active
;
909 static void usbhs_mod_phy_mode(struct usbhs_priv
*priv
)
911 struct usbhs_mod_info
*info
= &priv
->mod_info
;
913 info
->irq_vbus
= NULL
;
914 priv
->pfunc
.get_vbus
= usbhsm_phy_get_vbus
;
916 usbhs_irq_callback_update(priv
, NULL
);
924 static int usbhsg_gadget_start(struct usb_gadget
*gadget
,
925 struct usb_gadget_driver
*driver
)
927 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
928 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
929 struct device
*dev
= usbhs_priv_to_dev(priv
);
934 driver
->max_speed
< USB_SPEED_FULL
)
937 /* connect to bus through transceiver */
938 if (!IS_ERR_OR_NULL(gpriv
->transceiver
)) {
939 ret
= otg_set_peripheral(gpriv
->transceiver
->otg
,
942 dev_err(dev
, "%s: can't bind to transceiver\n",
947 /* get vbus using phy versions */
948 usbhs_mod_phy_mode(priv
);
951 /* first hook up the driver ... */
952 gpriv
->driver
= driver
;
954 return usbhsg_try_start(priv
, USBHSG_STATUS_REGISTERD
);
957 static int usbhsg_gadget_stop(struct usb_gadget
*gadget
)
959 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
960 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
962 usbhsg_try_stop(priv
, USBHSG_STATUS_REGISTERD
);
964 if (!IS_ERR_OR_NULL(gpriv
->transceiver
))
965 otg_set_peripheral(gpriv
->transceiver
->otg
, NULL
);
967 gpriv
->driver
= NULL
;
975 static int usbhsg_get_frame(struct usb_gadget
*gadget
)
977 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
978 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
980 return usbhs_frame_get_num(priv
);
983 static int usbhsg_pullup(struct usb_gadget
*gadget
, int is_on
)
985 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
986 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
989 usbhs_lock(priv
, flags
);
991 usbhsg_status_set(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
993 usbhsg_status_clr(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
994 usbhsg_update_pullup(priv
);
995 usbhs_unlock(priv
, flags
);
1000 static int usbhsg_set_selfpowered(struct usb_gadget
*gadget
, int is_self
)
1002 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
1005 usbhsg_status_set(gpriv
, USBHSG_STATUS_SELF_POWERED
);
1007 usbhsg_status_clr(gpriv
, USBHSG_STATUS_SELF_POWERED
);
1009 gadget
->is_selfpowered
= (is_self
!= 0);
1014 static int usbhsg_vbus_session(struct usb_gadget
*gadget
, int is_active
)
1016 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
1017 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
1018 struct platform_device
*pdev
= usbhs_priv_to_pdev(priv
);
1020 gpriv
->vbus_active
= !!is_active
;
1022 renesas_usbhs_call_notify_hotplug(pdev
);
1027 static const struct usb_gadget_ops usbhsg_gadget_ops
= {
1028 .get_frame
= usbhsg_get_frame
,
1029 .set_selfpowered
= usbhsg_set_selfpowered
,
1030 .udc_start
= usbhsg_gadget_start
,
1031 .udc_stop
= usbhsg_gadget_stop
,
1032 .pullup
= usbhsg_pullup
,
1033 .vbus_session
= usbhsg_vbus_session
,
1036 static int usbhsg_start(struct usbhs_priv
*priv
)
1038 return usbhsg_try_start(priv
, USBHSG_STATUS_STARTED
);
1041 static int usbhsg_stop(struct usbhs_priv
*priv
)
1043 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
1045 /* cable disconnect */
1046 if (gpriv
->driver
&&
1047 gpriv
->driver
->disconnect
)
1048 gpriv
->driver
->disconnect(&gpriv
->gadget
);
1050 return usbhsg_try_stop(priv
, USBHSG_STATUS_STARTED
);
1053 int usbhs_mod_gadget_probe(struct usbhs_priv
*priv
)
1055 struct usbhsg_gpriv
*gpriv
;
1056 struct usbhsg_uep
*uep
;
1057 struct device
*dev
= usbhs_priv_to_dev(priv
);
1058 struct renesas_usbhs_driver_pipe_config
*pipe_configs
=
1059 usbhs_get_dparam(priv
, pipe_configs
);
1060 int pipe_size
= usbhs_get_dparam(priv
, pipe_size
);
1064 gpriv
= kzalloc(sizeof(struct usbhsg_gpriv
), GFP_KERNEL
);
1066 dev_err(dev
, "Could not allocate gadget priv\n");
1070 uep
= kzalloc(sizeof(struct usbhsg_uep
) * pipe_size
, GFP_KERNEL
);
1072 dev_err(dev
, "Could not allocate ep\n");
1074 goto usbhs_mod_gadget_probe_err_gpriv
;
1077 gpriv
->transceiver
= usb_get_phy(USB_PHY_TYPE_UNDEFINED
);
1078 dev_info(dev
, "%stransceiver found\n",
1079 !IS_ERR(gpriv
->transceiver
) ? "" : "no ");
1084 * There is no guarantee that it is possible to access usb module here.
1085 * Don't accesses to it.
1086 * The accesse will be enable after "usbhsg_start"
1092 usbhs_mod_register(priv
, &gpriv
->mod
, USBHS_GADGET
);
1095 gpriv
->mod
.name
= "gadget";
1096 gpriv
->mod
.start
= usbhsg_start
;
1097 gpriv
->mod
.stop
= usbhsg_stop
;
1099 gpriv
->uep_size
= pipe_size
;
1100 usbhsg_status_init(gpriv
);
1105 gpriv
->gadget
.dev
.parent
= dev
;
1106 gpriv
->gadget
.name
= "renesas_usbhs_udc";
1107 gpriv
->gadget
.ops
= &usbhsg_gadget_ops
;
1108 gpriv
->gadget
.max_speed
= USB_SPEED_HIGH
;
1110 INIT_LIST_HEAD(&gpriv
->gadget
.ep_list
);
1115 usbhsg_for_each_uep_with_dcp(uep
, gpriv
, i
) {
1118 snprintf(uep
->ep_name
, EP_NAME_SIZE
, "ep%d", i
);
1120 uep
->ep
.name
= uep
->ep_name
;
1121 uep
->ep
.ops
= &usbhsg_ep_ops
;
1122 INIT_LIST_HEAD(&uep
->ep
.ep_list
);
1125 if (usbhsg_is_dcp(uep
)) {
1126 gpriv
->gadget
.ep0
= &uep
->ep
;
1127 usb_ep_set_maxpacket_limit(&uep
->ep
, 64);
1128 uep
->ep
.caps
.type_control
= true;
1130 /* init normal pipe */
1131 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_ISOC
)
1132 uep
->ep
.caps
.type_iso
= true;
1133 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_BULK
)
1134 uep
->ep
.caps
.type_bulk
= true;
1135 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_INT
)
1136 uep
->ep
.caps
.type_int
= true;
1137 usb_ep_set_maxpacket_limit(&uep
->ep
,
1138 pipe_configs
[i
].bufsize
);
1139 list_add_tail(&uep
->ep
.ep_list
, &gpriv
->gadget
.ep_list
);
1141 uep
->ep
.caps
.dir_in
= true;
1142 uep
->ep
.caps
.dir_out
= true;
1145 ret
= usb_add_gadget_udc(dev
, &gpriv
->gadget
);
1150 dev_info(dev
, "gadget probed\n");
1157 usbhs_mod_gadget_probe_err_gpriv
:
1163 void usbhs_mod_gadget_remove(struct usbhs_priv
*priv
)
1165 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
1167 usb_del_gadget_udc(&gpriv
->gadget
);