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/dma-mapping.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/usb/ch9.h>
22 #include <linux/usb/gadget.h>
28 struct usbhsg_request
{
29 struct usb_request req
;
33 #define EP_NAME_SIZE 8
37 struct usbhs_pipe
*pipe
;
39 char ep_name
[EP_NAME_SIZE
];
41 struct usbhsg_gpriv
*gpriv
;
42 struct usbhs_pkt_handle
*handler
;
46 struct usb_gadget gadget
;
48 struct list_head link
;
50 struct usbhsg_uep
*uep
;
53 struct usb_gadget_driver
*driver
;
56 #define USBHSG_STATUS_STARTED (1 << 0)
57 #define USBHSG_STATUS_REGISTERD (1 << 1)
58 #define USBHSG_STATUS_WEDGE (1 << 2)
61 struct usbhsg_recip_handle
{
63 int (*device
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
64 struct usb_ctrlrequest
*ctrl
);
65 int (*interface
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
66 struct usb_ctrlrequest
*ctrl
);
67 int (*endpoint
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
68 struct usb_ctrlrequest
*ctrl
);
74 #define usbhsg_priv_to_gpriv(priv) \
76 usbhs_mod_get(priv, USBHS_GADGET), \
77 struct usbhsg_gpriv, mod)
79 #define __usbhsg_for_each_uep(start, pos, g, i) \
80 for (i = start, pos = (g)->uep + i; \
82 i++, pos = (g)->uep + i)
84 #define usbhsg_for_each_uep(pos, gpriv, i) \
85 __usbhsg_for_each_uep(1, pos, gpriv, i)
87 #define usbhsg_for_each_uep_with_dcp(pos, gpriv, i) \
88 __usbhsg_for_each_uep(0, pos, gpriv, i)
90 #define usbhsg_gadget_to_gpriv(g)\
91 container_of(g, struct usbhsg_gpriv, gadget)
93 #define usbhsg_req_to_ureq(r)\
94 container_of(r, struct usbhsg_request, req)
96 #define usbhsg_ep_to_uep(e) container_of(e, struct usbhsg_uep, ep)
97 #define usbhsg_gpriv_to_dev(gp) usbhs_priv_to_dev((gp)->mod.priv)
98 #define usbhsg_gpriv_to_priv(gp) ((gp)->mod.priv)
99 #define usbhsg_gpriv_to_dcp(gp) ((gp)->uep)
100 #define usbhsg_gpriv_to_nth_uep(gp, i) ((gp)->uep + i)
101 #define usbhsg_uep_to_gpriv(u) ((u)->gpriv)
102 #define usbhsg_uep_to_pipe(u) ((u)->pipe)
103 #define usbhsg_pipe_to_uep(p) ((p)->mod_private)
104 #define usbhsg_is_dcp(u) ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
106 #define usbhsg_ureq_to_pkt(u) (&(u)->pkt)
107 #define usbhsg_pkt_to_ureq(i) \
108 container_of(i, struct usbhsg_request, pkt)
110 #define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
113 #define usbhsg_status_init(gp) do {(gp)->status = 0; } while (0)
114 #define usbhsg_status_set(gp, b) (gp->status |= b)
115 #define usbhsg_status_clr(gp, b) (gp->status &= ~b)
116 #define usbhsg_status_has(gp, b) (gp->status & b)
119 LIST_HEAD(the_controller_link
);
121 #define usbhsg_for_each_controller(gpriv)\
122 list_for_each_entry(gpriv, &the_controller_link, link)
123 #define usbhsg_controller_register(gpriv)\
124 list_add_tail(&(gpriv)->link, &the_controller_link)
125 #define usbhsg_controller_unregister(gpriv)\
126 list_del_init(&(gpriv)->link)
131 static void usbhsg_queue_push(struct usbhsg_uep
*uep
,
132 struct usbhsg_request
*ureq
)
134 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
135 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
136 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
137 struct usbhs_pkt
*pkt
= usbhsg_ureq_to_pkt(ureq
);
138 struct usb_request
*req
= &ureq
->req
;
141 req
->status
= -EINPROGRESS
;
142 usbhs_pkt_push(pipe
, pkt
, uep
->handler
,
143 req
->buf
, req
->length
, req
->zero
);
145 dev_dbg(dev
, "pipe %d : queue push (%d)\n",
146 usbhs_pipe_number(pipe
),
150 static void usbhsg_queue_pop(struct usbhsg_uep
*uep
,
151 struct usbhsg_request
*ureq
,
154 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
155 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
156 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
158 dev_dbg(dev
, "pipe %d : queue pop\n", usbhs_pipe_number(pipe
));
160 ureq
->req
.status
= status
;
161 ureq
->req
.complete(&uep
->ep
, &ureq
->req
);
164 static void usbhsg_queue_done(struct usbhs_pkt
*pkt
)
166 struct usbhs_pipe
*pipe
= pkt
->pipe
;
167 struct usbhsg_uep
*uep
= usbhsg_pipe_to_uep(pipe
);
168 struct usbhsg_request
*ureq
= usbhsg_pkt_to_ureq(pkt
);
170 ureq
->req
.actual
= pkt
->actual
;
172 usbhsg_queue_pop(uep
, ureq
, 0);
178 static int usbhsg_dma_map(struct device
*dev
,
179 struct usbhs_pkt
*pkt
,
180 enum dma_data_direction dir
)
182 struct usbhsg_request
*ureq
= usbhsg_pkt_to_ureq(pkt
);
183 struct usb_request
*req
= &ureq
->req
;
185 if (pkt
->dma
!= DMA_ADDR_INVALID
) {
186 dev_err(dev
, "dma is already mapped\n");
190 if (req
->dma
== DMA_ADDR_INVALID
) {
191 pkt
->dma
= dma_map_single(dev
, pkt
->buf
, pkt
->length
, dir
);
193 dma_sync_single_for_device(dev
, req
->dma
, req
->length
, dir
);
197 if (dma_mapping_error(dev
, pkt
->dma
)) {
198 dev_err(dev
, "dma mapping error %x\n", pkt
->dma
);
205 static int usbhsg_dma_unmap(struct device
*dev
,
206 struct usbhs_pkt
*pkt
,
207 enum dma_data_direction dir
)
209 struct usbhsg_request
*ureq
= usbhsg_pkt_to_ureq(pkt
);
210 struct usb_request
*req
= &ureq
->req
;
212 if (pkt
->dma
== DMA_ADDR_INVALID
) {
213 dev_err(dev
, "dma is not mapped\n");
217 if (req
->dma
== DMA_ADDR_INVALID
)
218 dma_unmap_single(dev
, pkt
->dma
, pkt
->length
, dir
);
220 dma_sync_single_for_cpu(dev
, req
->dma
, req
->length
, dir
);
222 pkt
->dma
= DMA_ADDR_INVALID
;
227 static int usbhsg_dma_map_ctrl(struct usbhs_pkt
*pkt
, int map
)
229 struct usbhs_pipe
*pipe
= pkt
->pipe
;
230 struct usbhsg_uep
*uep
= usbhsg_pipe_to_uep(pipe
);
231 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
232 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
233 enum dma_data_direction dir
;
235 dir
= usbhs_pipe_is_dir_in(pipe
) ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
;
238 return usbhsg_dma_map(dev
, pkt
, dir
);
240 return usbhsg_dma_unmap(dev
, pkt
, dir
);
244 * USB_TYPE_STANDARD / clear feature functions
246 static int usbhsg_recip_handler_std_control_done(struct usbhs_priv
*priv
,
247 struct usbhsg_uep
*uep
,
248 struct usb_ctrlrequest
*ctrl
)
250 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
251 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
252 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(dcp
);
254 usbhs_dcp_control_transfer_done(pipe
);
259 static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv
*priv
,
260 struct usbhsg_uep
*uep
,
261 struct usb_ctrlrequest
*ctrl
)
263 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
264 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
266 if (!usbhsg_status_has(gpriv
, USBHSG_STATUS_WEDGE
)) {
267 usbhs_pipe_disable(pipe
);
268 usbhs_pipe_clear_sequence(pipe
);
269 usbhs_pipe_enable(pipe
);
272 usbhsg_recip_handler_std_control_done(priv
, uep
, ctrl
);
277 struct usbhsg_recip_handle req_clear_feature
= {
278 .name
= "clear feature",
279 .device
= usbhsg_recip_handler_std_control_done
,
280 .interface
= usbhsg_recip_handler_std_control_done
,
281 .endpoint
= usbhsg_recip_handler_std_clear_endpoint
,
287 static int usbhsg_recip_run_handle(struct usbhs_priv
*priv
,
288 struct usbhsg_recip_handle
*handler
,
289 struct usb_ctrlrequest
*ctrl
)
291 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
292 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
293 struct usbhsg_uep
*uep
;
294 struct usbhs_pipe
*pipe
;
295 int recip
= ctrl
->bRequestType
& USB_RECIP_MASK
;
296 int nth
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
298 int (*func
)(struct usbhs_priv
*priv
, struct usbhsg_uep
*uep
,
299 struct usb_ctrlrequest
*ctrl
);
302 uep
= usbhsg_gpriv_to_nth_uep(gpriv
, nth
);
303 pipe
= usbhsg_uep_to_pipe(uep
);
305 dev_err(dev
, "wrong recip request\n");
307 goto usbhsg_recip_run_handle_end
;
311 case USB_RECIP_DEVICE
:
313 func
= handler
->device
;
315 case USB_RECIP_INTERFACE
:
317 func
= handler
->interface
;
319 case USB_RECIP_ENDPOINT
:
321 func
= handler
->endpoint
;
324 dev_warn(dev
, "unsupported RECIP(%d)\n", recip
);
332 dev_dbg(dev
, "%s (pipe %d :%s)\n", handler
->name
, nth
, msg
);
334 /******************** spin lock ********************/
335 usbhs_lock(priv
, flags
);
336 ret
= func(priv
, uep
, ctrl
);
337 usbhs_unlock(priv
, flags
);
338 /******************** spin unlock ******************/
341 usbhsg_recip_run_handle_end
:
342 usbhs_pkt_start(pipe
);
350 * it will be called from usbhs_interrupt
352 static int usbhsg_irq_dev_state(struct usbhs_priv
*priv
,
353 struct usbhs_irq_state
*irq_state
)
355 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
356 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
358 gpriv
->gadget
.speed
= usbhs_status_get_usb_speed(irq_state
);
360 dev_dbg(dev
, "state = %x : speed : %d\n",
361 usbhs_status_get_device_state(irq_state
),
362 gpriv
->gadget
.speed
);
367 static int usbhsg_irq_ctrl_stage(struct usbhs_priv
*priv
,
368 struct usbhs_irq_state
*irq_state
)
370 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
371 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
372 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(dcp
);
373 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
374 struct usb_ctrlrequest ctrl
;
375 struct usbhsg_recip_handle
*recip_handler
= NULL
;
376 int stage
= usbhs_status_get_ctrl_stage(irq_state
);
379 dev_dbg(dev
, "stage = %d\n", stage
);
385 * - "Interrupt Function"
386 * - "Control Transfer Stage Transition Interrupt"
387 * - Fig. "Control Transfer Stage Transitions"
391 case READ_DATA_STAGE
:
392 dcp
->handler
= &usbhs_fifo_pio_push_handler
;
394 case WRITE_DATA_STAGE
:
395 dcp
->handler
= &usbhs_fifo_pio_pop_handler
;
397 case NODATA_STATUS_STAGE
:
398 dcp
->handler
= &usbhs_ctrl_stage_end_handler
;
407 usbhs_usbreq_get_val(priv
, &ctrl
);
409 switch (ctrl
.bRequestType
& USB_TYPE_MASK
) {
410 case USB_TYPE_STANDARD
:
411 switch (ctrl
.bRequest
) {
412 case USB_REQ_CLEAR_FEATURE
:
413 recip_handler
= &req_clear_feature
;
419 * setup stage / run recip
422 ret
= usbhsg_recip_run_handle(priv
, recip_handler
, &ctrl
);
424 ret
= gpriv
->driver
->setup(&gpriv
->gadget
, &ctrl
);
427 usbhs_pipe_stall(pipe
);
437 static int usbhsg_pipe_disable(struct usbhsg_uep
*uep
)
439 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
440 struct usbhs_pkt
*pkt
;
442 usbhs_pipe_disable(pipe
);
445 pkt
= usbhs_pkt_pop(pipe
, NULL
);
453 static void usbhsg_uep_init(struct usbhsg_gpriv
*gpriv
)
456 struct usbhsg_uep
*uep
;
458 usbhsg_for_each_uep_with_dcp(uep
, gpriv
, i
)
467 static int usbhsg_ep_enable(struct usb_ep
*ep
,
468 const struct usb_endpoint_descriptor
*desc
)
470 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
471 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
472 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
473 struct usbhs_pipe
*pipe
;
477 * if it already have pipe,
481 usbhs_pipe_clear(uep
->pipe
);
482 usbhs_pipe_clear_sequence(uep
->pipe
);
486 pipe
= usbhs_pipe_malloc(priv
, desc
);
489 pipe
->mod_private
= uep
;
492 * usbhs_fifo_dma_push/pop_handler try to
493 * use dmaengine if possible.
494 * It will use pio handler if impossible.
496 if (usb_endpoint_dir_in(desc
))
497 uep
->handler
= &usbhs_fifo_dma_push_handler
;
499 uep
->handler
= &usbhs_fifo_dma_pop_handler
;
507 static int usbhsg_ep_disable(struct usb_ep
*ep
)
509 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
511 return usbhsg_pipe_disable(uep
);
514 static struct usb_request
*usbhsg_ep_alloc_request(struct usb_ep
*ep
,
517 struct usbhsg_request
*ureq
;
519 ureq
= kzalloc(sizeof *ureq
, gfp_flags
);
523 usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq
));
525 ureq
->req
.dma
= DMA_ADDR_INVALID
;
530 static void usbhsg_ep_free_request(struct usb_ep
*ep
,
531 struct usb_request
*req
)
533 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
535 WARN_ON(!list_empty(&ureq
->pkt
.node
));
539 static int usbhsg_ep_queue(struct usb_ep
*ep
, struct usb_request
*req
,
542 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
543 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
544 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
545 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
548 if (usbhsg_is_not_connected(gpriv
) ||
549 unlikely(!gpriv
->driver
) ||
553 usbhsg_queue_push(uep
, ureq
);
558 static int usbhsg_ep_dequeue(struct usb_ep
*ep
, struct usb_request
*req
)
560 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
561 struct usbhsg_request
*ureq
= usbhsg_req_to_ureq(req
);
562 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
564 usbhs_pkt_pop(pipe
, usbhsg_ureq_to_pkt(ureq
));
565 usbhsg_queue_pop(uep
, ureq
, -ECONNRESET
);
570 static int __usbhsg_ep_set_halt_wedge(struct usb_ep
*ep
, int halt
, int wedge
)
572 struct usbhsg_uep
*uep
= usbhsg_ep_to_uep(ep
);
573 struct usbhs_pipe
*pipe
= usbhsg_uep_to_pipe(uep
);
574 struct usbhsg_gpriv
*gpriv
= usbhsg_uep_to_gpriv(uep
);
575 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
576 struct device
*dev
= usbhsg_gpriv_to_dev(gpriv
);
579 usbhsg_pipe_disable(uep
);
581 dev_dbg(dev
, "set halt %d (pipe %d)\n",
582 halt
, usbhs_pipe_number(pipe
));
584 /******************** spin lock ********************/
585 usbhs_lock(priv
, flags
);
588 usbhs_pipe_stall(pipe
);
590 usbhs_pipe_disable(pipe
);
593 usbhsg_status_set(gpriv
, USBHSG_STATUS_WEDGE
);
595 usbhsg_status_clr(gpriv
, USBHSG_STATUS_WEDGE
);
597 usbhs_unlock(priv
, flags
);
598 /******************** spin unlock ******************/
603 static int usbhsg_ep_set_halt(struct usb_ep
*ep
, int value
)
605 return __usbhsg_ep_set_halt_wedge(ep
, value
, 0);
608 static int usbhsg_ep_set_wedge(struct usb_ep
*ep
)
610 return __usbhsg_ep_set_halt_wedge(ep
, 1, 1);
613 static struct usb_ep_ops usbhsg_ep_ops
= {
614 .enable
= usbhsg_ep_enable
,
615 .disable
= usbhsg_ep_disable
,
617 .alloc_request
= usbhsg_ep_alloc_request
,
618 .free_request
= usbhsg_ep_free_request
,
620 .queue
= usbhsg_ep_queue
,
621 .dequeue
= usbhsg_ep_dequeue
,
623 .set_halt
= usbhsg_ep_set_halt
,
624 .set_wedge
= usbhsg_ep_set_wedge
,
628 * usb module start/end
630 static int usbhsg_try_start(struct usbhs_priv
*priv
, u32 status
)
632 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
633 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
634 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
635 struct device
*dev
= usbhs_priv_to_dev(priv
);
639 /******************** spin lock ********************/
640 usbhs_lock(priv
, flags
);
642 usbhsg_status_set(gpriv
, status
);
643 if (!(usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
644 usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
)))
645 ret
= -1; /* not ready */
647 usbhs_unlock(priv
, flags
);
648 /******************** spin unlock ********************/
651 return 0; /* not ready is not error */
654 * enable interrupt and systems if ready
656 dev_dbg(dev
, "start gadget\n");
659 * pipe initialize and enable DCP
661 usbhs_pipe_init(priv
,
663 usbhsg_dma_map_ctrl
);
664 usbhs_fifo_init(priv
);
665 usbhsg_uep_init(gpriv
);
668 dcp
->pipe
= usbhs_dcp_malloc(priv
);
669 dcp
->pipe
->mod_private
= dcp
;
672 * system config enble
677 usbhs_sys_hispeed_ctrl(priv
, 1);
678 usbhs_sys_function_ctrl(priv
, 1);
679 usbhs_sys_usb_ctrl(priv
, 1);
682 * enable irq callback
684 mod
->irq_dev_state
= usbhsg_irq_dev_state
;
685 mod
->irq_ctrl_stage
= usbhsg_irq_ctrl_stage
;
686 usbhs_irq_callback_update(priv
, mod
);
691 static int usbhsg_try_stop(struct usbhs_priv
*priv
, u32 status
)
693 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
694 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
695 struct usbhsg_uep
*dcp
= usbhsg_gpriv_to_dcp(gpriv
);
696 struct device
*dev
= usbhs_priv_to_dev(priv
);
700 /******************** spin lock ********************/
701 usbhs_lock(priv
, flags
);
703 usbhsg_status_clr(gpriv
, status
);
704 if (!usbhsg_status_has(gpriv
, USBHSG_STATUS_STARTED
) &&
705 !usbhsg_status_has(gpriv
, USBHSG_STATUS_REGISTERD
))
706 ret
= -1; /* already done */
708 usbhs_unlock(priv
, flags
);
709 /******************** spin unlock ********************/
712 return 0; /* already done is not error */
715 * disable interrupt and systems if 1st try
717 usbhs_fifo_quit(priv
);
719 /* disable all irq */
720 mod
->irq_dev_state
= NULL
;
721 mod
->irq_ctrl_stage
= NULL
;
722 usbhs_irq_callback_update(priv
, mod
);
724 gpriv
->gadget
.speed
= USB_SPEED_UNKNOWN
;
727 usbhs_sys_hispeed_ctrl(priv
, 0);
728 usbhs_sys_function_ctrl(priv
, 0);
729 usbhs_sys_usb_ctrl(priv
, 0);
731 usbhsg_pipe_disable(dcp
);
733 dev_dbg(dev
, "stop gadget\n");
743 static int usbhsg_gadget_start(struct usb_gadget
*gadget
,
744 struct usb_gadget_driver
*driver
)
746 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
747 struct usbhs_priv
*priv
;
753 driver
->speed
!= USB_SPEED_HIGH
)
756 dev
= usbhsg_gpriv_to_dev(gpriv
);
757 priv
= usbhsg_gpriv_to_priv(gpriv
);
759 /* first hook up the driver ... */
760 gpriv
->driver
= driver
;
761 gpriv
->gadget
.dev
.driver
= &driver
->driver
;
763 ret
= device_add(&gpriv
->gadget
.dev
);
765 dev_err(dev
, "device_add error %d\n", ret
);
769 return usbhsg_try_start(priv
, USBHSG_STATUS_REGISTERD
);
772 gpriv
->driver
= NULL
;
773 gpriv
->gadget
.dev
.driver
= NULL
;
778 static int usbhsg_gadget_stop(struct usb_gadget
*gadget
,
779 struct usb_gadget_driver
*driver
)
781 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
782 struct usbhs_priv
*priv
;
789 dev
= usbhsg_gpriv_to_dev(gpriv
);
790 priv
= usbhsg_gpriv_to_priv(gpriv
);
792 usbhsg_try_stop(priv
, USBHSG_STATUS_REGISTERD
);
793 device_del(&gpriv
->gadget
.dev
);
794 gpriv
->driver
= NULL
;
802 static int usbhsg_get_frame(struct usb_gadget
*gadget
)
804 struct usbhsg_gpriv
*gpriv
= usbhsg_gadget_to_gpriv(gadget
);
805 struct usbhs_priv
*priv
= usbhsg_gpriv_to_priv(gpriv
);
807 return usbhs_frame_get_num(priv
);
810 static struct usb_gadget_ops usbhsg_gadget_ops
= {
811 .get_frame
= usbhsg_get_frame
,
812 .udc_start
= usbhsg_gadget_start
,
813 .udc_stop
= usbhsg_gadget_stop
,
816 static int usbhsg_start(struct usbhs_priv
*priv
)
818 return usbhsg_try_start(priv
, USBHSG_STATUS_STARTED
);
821 static int usbhsg_stop(struct usbhs_priv
*priv
)
823 return usbhsg_try_stop(priv
, USBHSG_STATUS_STARTED
);
826 int __devinit
usbhs_mod_gadget_probe(struct usbhs_priv
*priv
)
828 struct usbhsg_gpriv
*gpriv
;
829 struct usbhsg_uep
*uep
;
830 struct device
*dev
= usbhs_priv_to_dev(priv
);
831 int pipe_size
= usbhs_get_dparam(priv
, pipe_size
);
835 gpriv
= kzalloc(sizeof(struct usbhsg_gpriv
), GFP_KERNEL
);
837 dev_err(dev
, "Could not allocate gadget priv\n");
841 uep
= kzalloc(sizeof(struct usbhsg_uep
) * pipe_size
, GFP_KERNEL
);
843 dev_err(dev
, "Could not allocate ep\n");
845 goto usbhs_mod_gadget_probe_err_gpriv
;
851 * There is no guarantee that it is possible to access usb module here.
852 * Don't accesses to it.
853 * The accesse will be enable after "usbhsg_start"
859 usbhs_mod_register(priv
, &gpriv
->mod
, USBHS_GADGET
);
862 gpriv
->mod
.name
= "gadget";
863 gpriv
->mod
.start
= usbhsg_start
;
864 gpriv
->mod
.stop
= usbhsg_stop
;
866 gpriv
->uep_size
= pipe_size
;
867 usbhsg_status_init(gpriv
);
872 device_initialize(&gpriv
->gadget
.dev
);
873 dev_set_name(&gpriv
->gadget
.dev
, "gadget");
874 gpriv
->gadget
.dev
.parent
= dev
;
875 gpriv
->gadget
.name
= "renesas_usbhs_udc";
876 gpriv
->gadget
.ops
= &usbhsg_gadget_ops
;
877 gpriv
->gadget
.is_dualspeed
= 1;
879 INIT_LIST_HEAD(&gpriv
->gadget
.ep_list
);
884 usbhsg_for_each_uep_with_dcp(uep
, gpriv
, i
) {
886 snprintf(uep
->ep_name
, EP_NAME_SIZE
, "ep%d", i
);
888 uep
->ep
.name
= uep
->ep_name
;
889 uep
->ep
.ops
= &usbhsg_ep_ops
;
890 INIT_LIST_HEAD(&uep
->ep
.ep_list
);
893 if (usbhsg_is_dcp(uep
)) {
894 gpriv
->gadget
.ep0
= &uep
->ep
;
895 uep
->ep
.maxpacket
= 64;
897 /* init normal pipe */
899 uep
->ep
.maxpacket
= 512;
900 list_add_tail(&uep
->ep
.ep_list
, &gpriv
->gadget
.ep_list
);
904 usbhsg_controller_register(gpriv
);
906 ret
= usb_add_gadget_udc(dev
, &gpriv
->gadget
);
911 dev_info(dev
, "gadget probed\n");
917 usbhs_mod_gadget_probe_err_gpriv
:
923 void __devexit
usbhs_mod_gadget_remove(struct usbhs_priv
*priv
)
925 struct usbhsg_gpriv
*gpriv
= usbhsg_priv_to_gpriv(priv
);
927 usb_del_gadget_udc(&gpriv
->gadget
);
929 usbhsg_controller_unregister(gpriv
);