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
;
628 usbhsg_ep_enable_end
:
629 usbhs_unlock(priv
, flags
);
634 static int usbhsg_ep_disable(struct usb_ep
*ep
)
636 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
637 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
642 usbhsg_pipe_disable(uep
);
643 usbhs_pipe_free(pipe
);
645 uep
->pipe
->mod_private
= NULL
;
651 static struct usb_request
*usbhsg_ep_alloc_request(struct usb_ep
*ep
,
654 struct usbhsg_request
*ureq
;
656 ureq
= kzalloc(sizeof *ureq
, gfp_flags
);
660 usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq
));
665 static void usbhsg_ep_free_request(struct usb_ep
*ep
,
666 struct usb_request
*req
)
668 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
670 WARN_ON(!list_empty(&ureq
->pkt
.node
));
674 static int usbhsg_ep_queue(struct usb_ep
*ep
, struct usb_request
*req
,
677 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
678 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
679 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
680 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
683 if (usbhsg_is_not_connected(gpriv
) ||
684 unlikely(!gpriv
->driver
) ||
688 usbhsg_queue_push(uep
, ureq
);
693 static int usbhsg_ep_dequeue(struct usb_ep
*ep
, struct usb_request
*req
)
695 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
696 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
697 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
700 usbhs_pkt_pop(pipe
, usbhsg_ureq_to_pkt(ureq
));
703 * To dequeue a request, this driver should call the usbhsg_queue_pop()
704 * even if the pipe is NULL.
706 usbhsg_queue_pop(uep
, ureq
, -ECONNRESET
);
711 static int __usbhsg_ep_set_halt_wedge(struct usb_ep
*ep
, int halt
, int wedge
)
713 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
714 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
715 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
716 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
717 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
720 usbhsg_pipe_disable(uep
);
722 dev_dbg(dev
, "set halt %d (pipe %d)\n",
723 halt
, usbhs_pipe_number(pipe
));
725 /******************** spin lock ********************/
726 usbhs_lock(priv
, flags
);
729 usbhs_pipe_stall(pipe
);
731 usbhs_pipe_disable(pipe
);
734 usbhsg_status_set(gpriv
, USBHSG_STATUS_WEDGE
);
736 usbhsg_status_clr(gpriv
, USBHSG_STATUS_WEDGE
);
738 usbhs_unlock(priv
, flags
);
739 /******************** spin unlock ******************/
744 static int usbhsg_ep_set_halt(struct usb_ep
*ep
, int value
)
746 return __usbhsg_ep_set_halt_wedge(ep
, value
, 0);
749 static int usbhsg_ep_set_wedge(struct usb_ep
*ep
)
751 return __usbhsg_ep_set_halt_wedge(ep
, 1, 1);
754 static struct usb_ep_ops usbhsg_ep_ops
= {
755 .enable
= usbhsg_ep_enable
,
756 .disable
= usbhsg_ep_disable
,
758 .alloc_request
= usbhsg_ep_alloc_request
,
759 .free_request
= usbhsg_ep_free_request
,
761 .queue
= usbhsg_ep_queue
,
762 .dequeue
= usbhsg_ep_dequeue
,
764 .set_halt
= usbhsg_ep_set_halt
,
765 .set_wedge
= usbhsg_ep_set_wedge
,
771 static int usbhsg_can_pullup(struct usbhs_priv
*priv
)
773 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
775 return gpriv
->driver
&&
776 usbhsg_status_has(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
779 static void usbhsg_update_pullup(struct usbhs_priv
*priv
)
781 if (usbhsg_can_pullup(priv
))
782 usbhs_sys_function_pullup(priv
, 1);
784 usbhs_sys_function_pullup(priv
, 0);
788 * usb module start/end
790 static int usbhsg_try_start(struct usbhs_priv
*priv
, u32 status
)
792 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
793 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
794 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
795 struct device
*dev
= usbhs_priv_to_dev(priv
);
799 /******************** spin lock ********************/
800 usbhs_lock(priv
, flags
);
802 usbhsg_status_set(gpriv
, status
);
803 if (!(usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
804 usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
)))
805 ret
= -1; /* not ready */
807 usbhs_unlock(priv
, flags
);
808 /******************** spin unlock ********************/
811 return 0; /* not ready is not error */
814 * enable interrupt and systems if ready
816 dev_dbg(dev
, "start gadget\n");
819 * pipe initialize and enable DCP
821 usbhs_fifo_init(priv
);
822 usbhs_pipe_init(priv
,
823 usbhsg_dma_map_ctrl
);
825 /* dcp init instead of usbhsg_ep_enable() */
826 dcp
->pipe
= usbhs_dcp_malloc(priv
);
827 dcp
->pipe
->mod_private
= dcp
;
828 usbhs_pipe_config_update(dcp
->pipe
, 0, 0, 64);
831 * system config enble
836 usbhs_sys_function_ctrl(priv
, 1);
837 usbhsg_update_pullup(priv
);
840 * enable irq callback
842 mod
->irq_dev_state
= usbhsg_irq_dev_state
;
843 mod
->irq_ctrl_stage
= usbhsg_irq_ctrl_stage
;
844 usbhs_irq_callback_update(priv
, mod
);
849 static int usbhsg_try_stop(struct usbhs_priv
*priv
, u32 status
)
851 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
852 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
853 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
854 struct device
*dev
= usbhs_priv_to_dev(priv
);
858 /******************** spin lock ********************/
859 usbhs_lock(priv
, flags
);
861 usbhsg_status_clr(gpriv
, status
);
862 if (!usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
863 !usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
))
864 ret
= -1; /* already done */
866 usbhs_unlock(priv
, flags
);
867 /******************** spin unlock ********************/
870 return 0; /* already done is not error */
873 * disable interrupt and systems if 1st try
875 usbhs_fifo_quit(priv
);
877 /* disable all irq */
878 mod
->irq_dev_state
= NULL
;
879 mod
->irq_ctrl_stage
= NULL
;
880 usbhs_irq_callback_update(priv
, mod
);
882 gpriv
->gadget
.speed
= USB_SPEED_UNKNOWN
;
885 usbhs_sys_set_test_mode(priv
, 0);
886 usbhs_sys_function_ctrl(priv
, 0);
888 usbhsg_ep_disable(&dcp
->ep
);
890 dev_dbg(dev
, "stop gadget\n");
896 * VBUS provided by the PHY
898 static int usbhsm_phy_get_vbus(struct platform_device
*pdev
)
900 struct usbhs_priv
*priv
= usbhs_pdev_to_priv(pdev
);
901 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
903 return gpriv
->vbus_active
;
906 static void usbhs_mod_phy_mode(struct usbhs_priv
*priv
)
908 struct usbhs_mod_info
*info
= &priv
->mod_info
;
910 info
->irq_vbus
= NULL
;
911 priv
->pfunc
.get_vbus
= usbhsm_phy_get_vbus
;
913 usbhs_irq_callback_update(priv
, NULL
);
921 static int usbhsg_gadget_start(struct usb_gadget
*gadget
,
922 struct usb_gadget_driver
*driver
)
924 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
925 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
926 struct device
*dev
= usbhs_priv_to_dev(priv
);
931 driver
->max_speed
< USB_SPEED_FULL
)
934 /* connect to bus through transceiver */
935 if (!IS_ERR_OR_NULL(gpriv
->transceiver
)) {
936 ret
= otg_set_peripheral(gpriv
->transceiver
->otg
,
939 dev_err(dev
, "%s: can't bind to transceiver\n",
944 /* get vbus using phy versions */
945 usbhs_mod_phy_mode(priv
);
948 /* first hook up the driver ... */
949 gpriv
->driver
= driver
;
951 return usbhsg_try_start(priv
, USBHSG_STATUS_REGISTERD
);
954 static int usbhsg_gadget_stop(struct usb_gadget
*gadget
)
956 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
957 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
959 usbhsg_try_stop(priv
, USBHSG_STATUS_REGISTERD
);
961 if (!IS_ERR_OR_NULL(gpriv
->transceiver
))
962 otg_set_peripheral(gpriv
->transceiver
->otg
, NULL
);
964 gpriv
->driver
= NULL
;
972 static int usbhsg_get_frame(struct usb_gadget
*gadget
)
974 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
975 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
977 return usbhs_frame_get_num(priv
);
980 static int usbhsg_pullup(struct usb_gadget
*gadget
, int is_on
)
982 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
983 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
986 usbhs_lock(priv
, flags
);
988 usbhsg_status_set(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
990 usbhsg_status_clr(gpriv
, USBHSG_STATUS_SOFT_CONNECT
);
991 usbhsg_update_pullup(priv
);
992 usbhs_unlock(priv
, flags
);
997 static int usbhsg_set_selfpowered(struct usb_gadget
*gadget
, int is_self
)
999 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
1002 usbhsg_status_set(gpriv
, USBHSG_STATUS_SELF_POWERED
);
1004 usbhsg_status_clr(gpriv
, USBHSG_STATUS_SELF_POWERED
);
1006 gadget
->is_selfpowered
= (is_self
!= 0);
1011 static int usbhsg_vbus_session(struct usb_gadget
*gadget
, int is_active
)
1013 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
1014 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
1015 struct platform_device
*pdev
= usbhs_priv_to_pdev(priv
);
1017 gpriv
->vbus_active
= !!is_active
;
1019 renesas_usbhs_call_notify_hotplug(pdev
);
1024 static const struct usb_gadget_ops usbhsg_gadget_ops
= {
1025 .get_frame
= usbhsg_get_frame
,
1026 .set_selfpowered
= usbhsg_set_selfpowered
,
1027 .udc_start
= usbhsg_gadget_start
,
1028 .udc_stop
= usbhsg_gadget_stop
,
1029 .pullup
= usbhsg_pullup
,
1030 .vbus_session
= usbhsg_vbus_session
,
1033 static int usbhsg_start(struct usbhs_priv
*priv
)
1035 return usbhsg_try_start(priv
, USBHSG_STATUS_STARTED
);
1038 static int usbhsg_stop(struct usbhs_priv
*priv
)
1040 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
1042 /* cable disconnect */
1043 if (gpriv
->driver
&&
1044 gpriv
->driver
->disconnect
)
1045 gpriv
->driver
->disconnect(&gpriv
->gadget
);
1047 return usbhsg_try_stop(priv
, USBHSG_STATUS_STARTED
);
1050 int usbhs_mod_gadget_probe(struct usbhs_priv
*priv
)
1052 struct usbhsg_gpriv
*gpriv
;
1053 struct usbhsg_uep
*uep
;
1054 struct device
*dev
= usbhs_priv_to_dev(priv
);
1055 struct renesas_usbhs_driver_pipe_config
*pipe_configs
=
1056 usbhs_get_dparam(priv
, pipe_configs
);
1057 int pipe_size
= usbhs_get_dparam(priv
, pipe_size
);
1061 gpriv
= kzalloc(sizeof(struct usbhsg_gpriv
), GFP_KERNEL
);
1063 dev_err(dev
, "Could not allocate gadget priv\n");
1067 uep
= kzalloc(sizeof(struct usbhsg_uep
) * pipe_size
, GFP_KERNEL
);
1069 dev_err(dev
, "Could not allocate ep\n");
1071 goto usbhs_mod_gadget_probe_err_gpriv
;
1074 gpriv
->transceiver
= usb_get_phy(USB_PHY_TYPE_UNDEFINED
);
1075 dev_info(dev
, "%stransceiver found\n",
1076 gpriv
->transceiver
? "" : "no ");
1081 * There is no guarantee that it is possible to access usb module here.
1082 * Don't accesses to it.
1083 * The accesse will be enable after "usbhsg_start"
1089 usbhs_mod_register(priv
, &gpriv
->mod
, USBHS_GADGET
);
1092 gpriv
->mod
.name
= "gadget";
1093 gpriv
->mod
.start
= usbhsg_start
;
1094 gpriv
->mod
.stop
= usbhsg_stop
;
1096 gpriv
->uep_size
= pipe_size
;
1097 usbhsg_status_init(gpriv
);
1102 gpriv
->gadget
.dev
.parent
= dev
;
1103 gpriv
->gadget
.name
= "renesas_usbhs_udc";
1104 gpriv
->gadget
.ops
= &usbhsg_gadget_ops
;
1105 gpriv
->gadget
.max_speed
= USB_SPEED_HIGH
;
1107 INIT_LIST_HEAD(&gpriv
->gadget
.ep_list
);
1112 usbhsg_for_each_uep_with_dcp(uep
, gpriv
, i
) {
1115 snprintf(uep
->ep_name
, EP_NAME_SIZE
, "ep%d", i
);
1117 uep
->ep
.name
= uep
->ep_name
;
1118 uep
->ep
.ops
= &usbhsg_ep_ops
;
1119 INIT_LIST_HEAD(&uep
->ep
.ep_list
);
1122 if (usbhsg_is_dcp(uep
)) {
1123 gpriv
->gadget
.ep0
= &uep
->ep
;
1124 usb_ep_set_maxpacket_limit(&uep
->ep
, 64);
1125 uep
->ep
.caps
.type_control
= true;
1127 /* init normal pipe */
1128 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_ISOC
)
1129 uep
->ep
.caps
.type_iso
= true;
1130 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_BULK
)
1131 uep
->ep
.caps
.type_bulk
= true;
1132 if (pipe_configs
[i
].type
== USB_ENDPOINT_XFER_INT
)
1133 uep
->ep
.caps
.type_int
= true;
1134 usb_ep_set_maxpacket_limit(&uep
->ep
,
1135 pipe_configs
[i
].bufsize
);
1136 list_add_tail(&uep
->ep
.ep_list
, &gpriv
->gadget
.ep_list
);
1138 uep
->ep
.caps
.dir_in
= true;
1139 uep
->ep
.caps
.dir_out
= true;
1142 ret
= usb_add_gadget_udc(dev
, &gpriv
->gadget
);
1147 dev_info(dev
, "gadget probed\n");
1154 usbhs_mod_gadget_probe_err_gpriv
:
1160 void usbhs_mod_gadget_remove(struct usbhs_priv
*priv
)
1162 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
1164 usb_del_gadget_udc(&gpriv
->gadget
);