1 // SPDX-License-Identifier: GPL-1.0+
2 /*
3  * Renesas USB driver
4  *
5  * Copyright (C) 2011 Renesas Solutions Corp.
6  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7  */
8 #include <linux/delay.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/io.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/usb/ch9.h>
14 #include <linux/usb/gadget.h>
15 #include <linux/usb/otg.h>
16 #include "common.h"
17 
18 /*
19  *		struct
20  */
21 struct usbhsg_request {
22 	struct usb_request	req;
23 	struct usbhs_pkt	pkt;
24 };
25 
26 #define EP_NAME_SIZE 8
27 struct usbhsg_gpriv;
28 struct usbhsg_uep {
29 	struct usb_ep		 ep;
30 	struct usbhs_pipe	*pipe;
31 	spinlock_t		lock;	/* protect the pipe */
32 
33 	char ep_name[EP_NAME_SIZE];
34 
35 	struct usbhsg_gpriv *gpriv;
36 };
37 
38 struct usbhsg_gpriv {
39 	struct usb_gadget	 gadget;
40 	struct usbhs_mod	 mod;
41 
42 	struct usbhsg_uep	*uep;
43 	int			 uep_size;
44 
45 	struct usb_gadget_driver	*driver;
46 	struct usb_phy		*transceiver;
47 	bool			 vbus_active;
48 
49 	u32	status;
50 #define USBHSG_STATUS_STARTED		(1 << 0)
51 #define USBHSG_STATUS_REGISTERD		(1 << 1)
52 #define USBHSG_STATUS_WEDGE		(1 << 2)
53 #define USBHSG_STATUS_SELF_POWERED	(1 << 3)
54 #define USBHSG_STATUS_SOFT_CONNECT	(1 << 4)
55 };
56 
57 struct usbhsg_recip_handle {
58 	char *name;
59 	int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
60 		      struct usb_ctrlrequest *ctrl);
61 	int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
62 			 struct usb_ctrlrequest *ctrl);
63 	int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
64 			struct usb_ctrlrequest *ctrl);
65 };
66 
67 /*
68  *		macro
69  */
70 #define usbhsg_priv_to_gpriv(priv)			\
71 	container_of(					\
72 		usbhs_mod_get(priv, USBHS_GADGET),	\
73 		struct usbhsg_gpriv, mod)
74 
75 #define __usbhsg_for_each_uep(start, pos, g, i)	\
76 	for ((i) = start;					\
77 	     ((i) < (g)->uep_size) && ((pos) = (g)->uep + (i));	\
78 	     (i)++)
79 
80 #define usbhsg_for_each_uep(pos, gpriv, i)	\
81 	__usbhsg_for_each_uep(1, pos, gpriv, i)
82 
83 #define usbhsg_for_each_uep_with_dcp(pos, gpriv, i)	\
84 	__usbhsg_for_each_uep(0, pos, gpriv, i)
85 
86 #define usbhsg_gadget_to_gpriv(g)\
87 	container_of(g, struct usbhsg_gpriv, gadget)
88 
89 #define usbhsg_req_to_ureq(r)\
90 	container_of(r, struct usbhsg_request, req)
91 
92 #define usbhsg_ep_to_uep(e)		container_of(e, struct usbhsg_uep, ep)
93 #define usbhsg_gpriv_to_dev(gp)		usbhs_priv_to_dev((gp)->mod.priv)
94 #define usbhsg_gpriv_to_priv(gp)	((gp)->mod.priv)
95 #define usbhsg_gpriv_to_dcp(gp)		((gp)->uep)
96 #define usbhsg_gpriv_to_nth_uep(gp, i)	((gp)->uep + i)
97 #define usbhsg_uep_to_gpriv(u)		((u)->gpriv)
98 #define usbhsg_uep_to_pipe(u)		((u)->pipe)
99 #define usbhsg_pipe_to_uep(p)		((p)->mod_private)
100 #define usbhsg_is_dcp(u)		((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
101 
102 #define usbhsg_ureq_to_pkt(u)		(&(u)->pkt)
103 #define usbhsg_pkt_to_ureq(i)	\
104 	container_of(i, struct usbhsg_request, pkt)
105 
106 #define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
107 
108 /* status */
109 #define usbhsg_status_init(gp)   do {(gp)->status = 0; } while (0)
110 #define usbhsg_status_set(gp, b) (gp->status |=  b)
111 #define usbhsg_status_clr(gp, b) (gp->status &= ~b)
112 #define usbhsg_status_has(gp, b) (gp->status &   b)
113 
114 /*
115  *		queue push/pop
116  */
117 static void __usbhsg_queue_pop(struct usbhsg_uep *uep,
118 			       struct usbhsg_request *ureq,
119 			       int status)
120 {
121 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
122 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
123 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
124 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
125 
126 	if (pipe)
127 		dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
128 
129 	ureq->req.status = status;
130 	spin_unlock(usbhs_priv_to_lock(priv));
131 	usb_gadget_giveback_request(&uep->ep, &ureq->req);
132 	spin_lock(usbhs_priv_to_lock(priv));
133 }
134 
135 static void usbhsg_queue_pop(struct usbhsg_uep *uep,
136 			     struct usbhsg_request *ureq,
137 			     int status)
138 {
139 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
140 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
141 	unsigned long flags;
142 
143 	usbhs_lock(priv, flags);
144 	__usbhsg_queue_pop(uep, ureq, status);
145 	usbhs_unlock(priv, flags);
146 }
147 
148 static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
149 {
150 	struct usbhs_pipe *pipe = pkt->pipe;
151 	struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
152 	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
153 	unsigned long flags;
154 
155 	ureq->req.actual = pkt->actual;
156 
157 	usbhs_lock(priv, flags);
158 	if (uep)
159 		__usbhsg_queue_pop(uep, ureq, 0);
160 	usbhs_unlock(priv, flags);
161 }
162 
163 static void usbhsg_queue_push(struct usbhsg_uep *uep,
164 			      struct usbhsg_request *ureq)
165 {
166 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
167 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
168 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
169 	struct usbhs_pkt *pkt = usbhsg_ureq_to_pkt(ureq);
170 	struct usb_request *req = &ureq->req;
171 
172 	req->actual = 0;
173 	req->status = -EINPROGRESS;
174 	usbhs_pkt_push(pipe, pkt, usbhsg_queue_done,
175 		       req->buf, req->length, req->zero, -1);
176 	usbhs_pkt_start(pipe);
177 
178 	dev_dbg(dev, "pipe %d : queue push (%d)\n",
179 		usbhs_pipe_number(pipe),
180 		req->length);
181 }
182 
183 /*
184  *		dma map/unmap
185  */
186 static int usbhsg_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt,
187 			       int map)
188 {
189 	struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
190 	struct usb_request *req = &ureq->req;
191 	struct usbhs_pipe *pipe = pkt->pipe;
192 	enum dma_data_direction dir;
193 	int ret = 0;
194 
195 	dir = usbhs_pipe_is_dir_host(pipe);
196 
197 	if (map) {
198 		/* it can not use scatter/gather */
199 		WARN_ON(req->num_sgs);
200 
201 		ret = usb_gadget_map_request_by_dev(dma_dev, req, dir);
202 		if (ret < 0)
203 			return ret;
204 
205 		pkt->dma = req->dma;
206 	} else {
207 		usb_gadget_unmap_request_by_dev(dma_dev, req, dir);
208 	}
209 
210 	return ret;
211 }
212 
213 /*
214  *		USB_TYPE_STANDARD / clear feature functions
215  */
216 static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv,
217 						 struct usbhsg_uep *uep,
218 						 struct usb_ctrlrequest *ctrl)
219 {
220 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
221 	struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
222 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
223 
224 	usbhs_dcp_control_transfer_done(pipe);
225 
226 	return 0;
227 }
228 
229 static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv,
230 						   struct usbhsg_uep *uep,
231 						   struct usb_ctrlrequest *ctrl)
232 {
233 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
234 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
235 
236 	if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) {
237 		usbhs_pipe_disable(pipe);
238 		usbhs_pipe_sequence_data0(pipe);
239 		usbhs_pipe_enable(pipe);
240 	}
241 
242 	usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
243 
244 	usbhs_pkt_start(pipe);
245 
246 	return 0;
247 }
248 
249 static struct usbhsg_recip_handle req_clear_feature = {
250 	.name		= "clear feature",
251 	.device		= usbhsg_recip_handler_std_control_done,
252 	.interface	= usbhsg_recip_handler_std_control_done,
253 	.endpoint	= usbhsg_recip_handler_std_clear_endpoint,
254 };
255 
256 /*
257  *		USB_TYPE_STANDARD / set feature functions
258  */
259 static int usbhsg_recip_handler_std_set_device(struct usbhs_priv *priv,
260 						 struct usbhsg_uep *uep,
261 						 struct usb_ctrlrequest *ctrl)
262 {
263 	switch (le16_to_cpu(ctrl->wValue)) {
264 	case USB_DEVICE_TEST_MODE:
265 		usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
266 		udelay(100);
267 		usbhs_sys_set_test_mode(priv, le16_to_cpu(ctrl->wIndex >> 8));
268 		break;
269 	default:
270 		usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
271 		break;
272 	}
273 
274 	return 0;
275 }
276 
277 static int usbhsg_recip_handler_std_set_endpoint(struct usbhs_priv *priv,
278 						 struct usbhsg_uep *uep,
279 						 struct usb_ctrlrequest *ctrl)
280 {
281 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
282 
283 	usbhs_pipe_stall(pipe);
284 
285 	usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
286 
287 	return 0;
288 }
289 
290 static struct usbhsg_recip_handle req_set_feature = {
291 	.name		= "set feature",
292 	.device		= usbhsg_recip_handler_std_set_device,
293 	.interface	= usbhsg_recip_handler_std_control_done,
294 	.endpoint	= usbhsg_recip_handler_std_set_endpoint,
295 };
296 
297 /*
298  *		USB_TYPE_STANDARD / get status functions
299  */
300 static void __usbhsg_recip_send_complete(struct usb_ep *ep,
301 					 struct usb_request *req)
302 {
303 	struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
304 
305 	/* free allocated recip-buffer/usb_request */
306 	kfree(ureq->pkt.buf);
307 	usb_ep_free_request(ep, req);
308 }
309 
310 static void __usbhsg_recip_send_status(struct usbhsg_gpriv *gpriv,
311 				       unsigned short status)
312 {
313 	struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
314 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
315 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
316 	struct usb_request *req;
317 	unsigned short *buf;
318 
319 	/* alloc new usb_request for recip */
320 	req = usb_ep_alloc_request(&dcp->ep, GFP_ATOMIC);
321 	if (!req) {
322 		dev_err(dev, "recip request allocation fail\n");
323 		return;
324 	}
325 
326 	/* alloc recip data buffer */
327 	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
328 	if (!buf) {
329 		usb_ep_free_request(&dcp->ep, req);
330 		return;
331 	}
332 
333 	/* recip data is status */
334 	*buf = cpu_to_le16(status);
335 
336 	/* allocated usb_request/buffer will be freed */
337 	req->complete	= __usbhsg_recip_send_complete;
338 	req->buf	= buf;
339 	req->length	= sizeof(*buf);
340 	req->zero	= 0;
341 
342 	/* push packet */
343 	pipe->handler = &usbhs_fifo_pio_push_handler;
344 	usbhsg_queue_push(dcp, usbhsg_req_to_ureq(req));
345 }
346 
347 static int usbhsg_recip_handler_std_get_device(struct usbhs_priv *priv,
348 					       struct usbhsg_uep *uep,
349 					       struct usb_ctrlrequest *ctrl)
350 {
351 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
352 	unsigned short status = 0;
353 
354 	if (usbhsg_status_has(gpriv, USBHSG_STATUS_SELF_POWERED))
355 		status = 1 << USB_DEVICE_SELF_POWERED;
356 
357 	__usbhsg_recip_send_status(gpriv, status);
358 
359 	return 0;
360 }
361 
362 static int usbhsg_recip_handler_std_get_interface(struct usbhs_priv *priv,
363 						  struct usbhsg_uep *uep,
364 						  struct usb_ctrlrequest *ctrl)
365 {
366 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
367 	unsigned short status = 0;
368 
369 	__usbhsg_recip_send_status(gpriv, status);
370 
371 	return 0;
372 }
373 
374 static int usbhsg_recip_handler_std_get_endpoint(struct usbhs_priv *priv,
375 						 struct usbhsg_uep *uep,
376 						 struct usb_ctrlrequest *ctrl)
377 {
378 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
379 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
380 	unsigned short status = 0;
381 
382 	if (usbhs_pipe_is_stall(pipe))
383 		status = 1 << USB_ENDPOINT_HALT;
384 
385 	__usbhsg_recip_send_status(gpriv, status);
386 
387 	return 0;
388 }
389 
390 static struct usbhsg_recip_handle req_get_status = {
391 	.name		= "get status",
392 	.device		= usbhsg_recip_handler_std_get_device,
393 	.interface	= usbhsg_recip_handler_std_get_interface,
394 	.endpoint	= usbhsg_recip_handler_std_get_endpoint,
395 };
396 
397 /*
398  *		USB_TYPE handler
399  */
400 static int usbhsg_recip_run_handle(struct usbhs_priv *priv,
401 				   struct usbhsg_recip_handle *handler,
402 				   struct usb_ctrlrequest *ctrl)
403 {
404 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
405 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
406 	struct usbhsg_uep *uep;
407 	struct usbhs_pipe *pipe;
408 	int recip = ctrl->bRequestType & USB_RECIP_MASK;
409 	int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
410 	int ret = 0;
411 	int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
412 		    struct usb_ctrlrequest *ctrl);
413 	char *msg;
414 
415 	uep = usbhsg_gpriv_to_nth_uep(gpriv, nth);
416 	pipe = usbhsg_uep_to_pipe(uep);
417 	if (!pipe) {
418 		dev_err(dev, "wrong recip request\n");
419 		return -EINVAL;
420 	}
421 
422 	switch (recip) {
423 	case USB_RECIP_DEVICE:
424 		msg	= "DEVICE";
425 		func	= handler->device;
426 		break;
427 	case USB_RECIP_INTERFACE:
428 		msg	= "INTERFACE";
429 		func	= handler->interface;
430 		break;
431 	case USB_RECIP_ENDPOINT:
432 		msg	= "ENDPOINT";
433 		func	= handler->endpoint;
434 		break;
435 	default:
436 		dev_warn(dev, "unsupported RECIP(%d)\n", recip);
437 		func = NULL;
438 		ret = -EINVAL;
439 	}
440 
441 	if (func) {
442 		dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg);
443 		ret = func(priv, uep, ctrl);
444 	}
445 
446 	return ret;
447 }
448 
449 /*
450  *		irq functions
451  *
452  * it will be called from usbhs_interrupt
453  */
454 static int usbhsg_irq_dev_state(struct usbhs_priv *priv,
455 				struct usbhs_irq_state *irq_state)
456 {
457 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
458 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
459 
460 	gpriv->gadget.speed = usbhs_bus_get_speed(priv);
461 
462 	dev_dbg(dev, "state = %x : speed : %d\n",
463 		usbhs_status_get_device_state(irq_state),
464 		gpriv->gadget.speed);
465 
466 	return 0;
467 }
468 
469 static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv,
470 				 struct usbhs_irq_state *irq_state)
471 {
472 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
473 	struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
474 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
475 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
476 	struct usb_ctrlrequest ctrl;
477 	struct usbhsg_recip_handle *recip_handler = NULL;
478 	int stage = usbhs_status_get_ctrl_stage(irq_state);
479 	int ret = 0;
480 
481 	dev_dbg(dev, "stage = %d\n", stage);
482 
483 	/*
484 	 * see Manual
485 	 *
486 	 *  "Operation"
487 	 *  - "Interrupt Function"
488 	 *    - "Control Transfer Stage Transition Interrupt"
489 	 *      - Fig. "Control Transfer Stage Transitions"
490 	 */
491 
492 	switch (stage) {
493 	case READ_DATA_STAGE:
494 		pipe->handler = &usbhs_fifo_pio_push_handler;
495 		break;
496 	case WRITE_DATA_STAGE:
497 		pipe->handler = &usbhs_fifo_pio_pop_handler;
498 		break;
499 	case NODATA_STATUS_STAGE:
500 		pipe->handler = &usbhs_ctrl_stage_end_handler;
501 		break;
502 	case READ_STATUS_STAGE:
503 	case WRITE_STATUS_STAGE:
504 		usbhs_dcp_control_transfer_done(pipe);
505 	default:
506 		return ret;
507 	}
508 
509 	/*
510 	 * get usb request
511 	 */
512 	usbhs_usbreq_get_val(priv, &ctrl);
513 
514 	switch (ctrl.bRequestType & USB_TYPE_MASK) {
515 	case USB_TYPE_STANDARD:
516 		switch (ctrl.bRequest) {
517 		case USB_REQ_CLEAR_FEATURE:
518 			recip_handler = &req_clear_feature;
519 			break;
520 		case USB_REQ_SET_FEATURE:
521 			recip_handler = &req_set_feature;
522 			break;
523 		case USB_REQ_GET_STATUS:
524 			recip_handler = &req_get_status;
525 			break;
526 		}
527 	}
528 
529 	/*
530 	 * setup stage / run recip
531 	 */
532 	if (recip_handler)
533 		ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl);
534 	else
535 		ret = gpriv->driver->setup(&gpriv->gadget, &ctrl);
536 
537 	if (ret < 0)
538 		usbhs_pipe_stall(pipe);
539 
540 	return ret;
541 }
542 
543 /*
544  *
545  *		usb_dcp_ops
546  *
547  */
548 static int usbhsg_pipe_disable(struct usbhsg_uep *uep)
549 {
550 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
551 	struct usbhs_pkt *pkt;
552 
553 	while (1) {
554 		pkt = usbhs_pkt_pop(pipe, NULL);
555 		if (!pkt)
556 			break;
557 
558 		usbhsg_queue_pop(uep, usbhsg_pkt_to_ureq(pkt), -ESHUTDOWN);
559 	}
560 
561 	usbhs_pipe_disable(pipe);
562 
563 	return 0;
564 }
565 
566 /*
567  *
568  *		usb_ep_ops
569  *
570  */
571 static int usbhsg_ep_enable(struct usb_ep *ep,
572 			 const struct usb_endpoint_descriptor *desc)
573 {
574 	struct usbhsg_uep *uep   = usbhsg_ep_to_uep(ep);
575 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
576 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
577 	struct usbhs_pipe *pipe;
578 	int ret = -EIO;
579 	unsigned long flags;
580 
581 	usbhs_lock(priv, flags);
582 
583 	/*
584 	 * if it already have pipe,
585 	 * nothing to do
586 	 */
587 	if (uep->pipe) {
588 		usbhs_pipe_clear(uep->pipe);
589 		usbhs_pipe_sequence_data0(uep->pipe);
590 		ret = 0;
591 		goto usbhsg_ep_enable_end;
592 	}
593 
594 	pipe = usbhs_pipe_malloc(priv,
595 				 usb_endpoint_type(desc),
596 				 usb_endpoint_dir_in(desc));
597 	if (pipe) {
598 		uep->pipe		= pipe;
599 		pipe->mod_private	= uep;
600 
601 		/* set epnum / maxp */
602 		usbhs_pipe_config_update(pipe, 0,
603 					 usb_endpoint_num(desc),
604 					 usb_endpoint_maxp(desc));
605 
606 		/*
607 		 * usbhs_fifo_dma_push/pop_handler try to
608 		 * use dmaengine if possible.
609 		 * It will use pio handler if impossible.
610 		 */
611 		if (usb_endpoint_dir_in(desc)) {
612 			pipe->handler = &usbhs_fifo_dma_push_handler;
613 		} else {
614 			pipe->handler = &usbhs_fifo_dma_pop_handler;
615 			usbhs_xxxsts_clear(priv, BRDYSTS,
616 					   usbhs_pipe_number(pipe));
617 		}
618 
619 		ret = 0;
620 	}
621 
622 usbhsg_ep_enable_end:
623 	usbhs_unlock(priv, flags);
624 
625 	return ret;
626 }
627 
628 static int usbhsg_ep_disable(struct usb_ep *ep)
629 {
630 	struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
631 	struct usbhs_pipe *pipe;
632 	unsigned long flags;
633 
634 	spin_lock_irqsave(&uep->lock, flags);
635 	pipe = usbhsg_uep_to_pipe(uep);
636 	if (!pipe)
637 		goto out;
638 
639 	usbhsg_pipe_disable(uep);
640 	usbhs_pipe_free(pipe);
641 
642 	uep->pipe->mod_private	= NULL;
643 	uep->pipe		= NULL;
644 
645 out:
646 	spin_unlock_irqrestore(&uep->lock, flags);
647 
648 	return 0;
649 }
650 
651 static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep,
652 						   gfp_t gfp_flags)
653 {
654 	struct usbhsg_request *ureq;
655 
656 	ureq = kzalloc(sizeof *ureq, gfp_flags);
657 	if (!ureq)
658 		return NULL;
659 
660 	usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq));
661 
662 	return &ureq->req;
663 }
664 
665 static void usbhsg_ep_free_request(struct usb_ep *ep,
666 				   struct usb_request *req)
667 {
668 	struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
669 
670 	WARN_ON(!list_empty(&ureq->pkt.node));
671 	kfree(ureq);
672 }
673 
674 static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req,
675 			  gfp_t gfp_flags)
676 {
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);
681 
682 	/* param check */
683 	if (usbhsg_is_not_connected(gpriv)	||
684 	    unlikely(!gpriv->driver)		||
685 	    unlikely(!pipe))
686 		return -ESHUTDOWN;
687 
688 	usbhsg_queue_push(uep, ureq);
689 
690 	return 0;
691 }
692 
693 static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
694 {
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;
698 	unsigned long flags;
699 
700 	spin_lock_irqsave(&uep->lock, flags);
701 	pipe = usbhsg_uep_to_pipe(uep);
702 	if (pipe)
703 		usbhs_pkt_pop(pipe, usbhsg_ureq_to_pkt(ureq));
704 
705 	/*
706 	 * To dequeue a request, this driver should call the usbhsg_queue_pop()
707 	 * even if the pipe is NULL.
708 	 */
709 	usbhsg_queue_pop(uep, ureq, -ECONNRESET);
710 	spin_unlock_irqrestore(&uep->lock, flags);
711 
712 	return 0;
713 }
714 
715 static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge)
716 {
717 	struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
718 	struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
719 	struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
720 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
721 	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
722 	unsigned long flags;
723 
724 	usbhsg_pipe_disable(uep);
725 
726 	dev_dbg(dev, "set halt %d (pipe %d)\n",
727 		halt, usbhs_pipe_number(pipe));
728 
729 	/********************  spin lock ********************/
730 	usbhs_lock(priv, flags);
731 
732 	if (halt)
733 		usbhs_pipe_stall(pipe);
734 	else
735 		usbhs_pipe_disable(pipe);
736 
737 	if (halt && wedge)
738 		usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE);
739 	else
740 		usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
741 
742 	usbhs_unlock(priv, flags);
743 	/********************  spin unlock ******************/
744 
745 	return 0;
746 }
747 
748 static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)
749 {
750 	return __usbhsg_ep_set_halt_wedge(ep, value, 0);
751 }
752 
753 static int usbhsg_ep_set_wedge(struct usb_ep *ep)
754 {
755 	return __usbhsg_ep_set_halt_wedge(ep, 1, 1);
756 }
757 
758 static const struct usb_ep_ops usbhsg_ep_ops = {
759 	.enable		= usbhsg_ep_enable,
760 	.disable	= usbhsg_ep_disable,
761 
762 	.alloc_request	= usbhsg_ep_alloc_request,
763 	.free_request	= usbhsg_ep_free_request,
764 
765 	.queue		= usbhsg_ep_queue,
766 	.dequeue	= usbhsg_ep_dequeue,
767 
768 	.set_halt	= usbhsg_ep_set_halt,
769 	.set_wedge	= usbhsg_ep_set_wedge,
770 };
771 
772 /*
773  *		pullup control
774  */
775 static int usbhsg_can_pullup(struct usbhs_priv *priv)
776 {
777 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
778 
779 	return gpriv->driver &&
780 	       usbhsg_status_has(gpriv, USBHSG_STATUS_SOFT_CONNECT);
781 }
782 
783 static void usbhsg_update_pullup(struct usbhs_priv *priv)
784 {
785 	if (usbhsg_can_pullup(priv))
786 		usbhs_sys_function_pullup(priv, 1);
787 	else
788 		usbhs_sys_function_pullup(priv, 0);
789 }
790 
791 /*
792  *		usb module start/end
793  */
794 static int usbhsg_try_start(struct usbhs_priv *priv, u32 status)
795 {
796 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
797 	struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
798 	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
799 	struct device *dev = usbhs_priv_to_dev(priv);
800 	unsigned long flags;
801 	int ret = 0;
802 
803 	/********************  spin lock ********************/
804 	usbhs_lock(priv, flags);
805 
806 	usbhsg_status_set(gpriv, status);
807 	if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
808 	      usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)))
809 		ret = -1; /* not ready */
810 
811 	usbhs_unlock(priv, flags);
812 	/********************  spin unlock ********************/
813 
814 	if (ret < 0)
815 		return 0; /* not ready is not error */
816 
817 	/*
818 	 * enable interrupt and systems if ready
819 	 */
820 	dev_dbg(dev, "start gadget\n");
821 
822 	/*
823 	 * pipe initialize and enable DCP
824 	 */
825 	usbhs_fifo_init(priv);
826 	usbhs_pipe_init(priv,
827 			usbhsg_dma_map_ctrl);
828 
829 	/* dcp init instead of usbhsg_ep_enable() */
830 	dcp->pipe		= usbhs_dcp_malloc(priv);
831 	dcp->pipe->mod_private	= dcp;
832 	usbhs_pipe_config_update(dcp->pipe, 0, 0, 64);
833 
834 	/*
835 	 * system config enble
836 	 * - HI speed
837 	 * - function
838 	 * - usb module
839 	 */
840 	usbhs_sys_function_ctrl(priv, 1);
841 	usbhsg_update_pullup(priv);
842 
843 	/*
844 	 * enable irq callback
845 	 */
846 	mod->irq_dev_state	= usbhsg_irq_dev_state;
847 	mod->irq_ctrl_stage	= usbhsg_irq_ctrl_stage;
848 	usbhs_irq_callback_update(priv, mod);
849 
850 	return 0;
851 }
852 
853 static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
854 {
855 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
856 	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
857 	struct usbhsg_uep *uep;
858 	struct device *dev = usbhs_priv_to_dev(priv);
859 	unsigned long flags;
860 	int ret = 0, i;
861 
862 	/********************  spin lock ********************/
863 	usbhs_lock(priv, flags);
864 
865 	usbhsg_status_clr(gpriv, status);
866 	if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
867 	    !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))
868 		ret = -1; /* already done */
869 
870 	usbhs_unlock(priv, flags);
871 	/********************  spin unlock ********************/
872 
873 	if (ret < 0)
874 		return 0; /* already done is not error */
875 
876 	/*
877 	 * disable interrupt and systems if 1st try
878 	 */
879 	usbhs_fifo_quit(priv);
880 
881 	/* disable all irq */
882 	mod->irq_dev_state	= NULL;
883 	mod->irq_ctrl_stage	= NULL;
884 	usbhs_irq_callback_update(priv, mod);
885 
886 	gpriv->gadget.speed = USB_SPEED_UNKNOWN;
887 
888 	/* disable sys */
889 	usbhs_sys_set_test_mode(priv, 0);
890 	usbhs_sys_function_ctrl(priv, 0);
891 
892 	/* disable all eps */
893 	usbhsg_for_each_uep_with_dcp(uep, gpriv, i)
894 		usbhsg_ep_disable(&uep->ep);
895 
896 	dev_dbg(dev, "stop gadget\n");
897 
898 	return 0;
899 }
900 
901 /*
902  * VBUS provided by the PHY
903  */
904 static int usbhsm_phy_get_vbus(struct platform_device *pdev)
905 {
906 	struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
907 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
908 
909 	return  gpriv->vbus_active;
910 }
911 
912 static void usbhs_mod_phy_mode(struct usbhs_priv *priv)
913 {
914 	struct usbhs_mod_info *info = &priv->mod_info;
915 
916 	info->irq_vbus		= NULL;
917 	priv->pfunc.get_vbus	= usbhsm_phy_get_vbus;
918 
919 	usbhs_irq_callback_update(priv, NULL);
920 }
921 
922 /*
923  *
924  *		linux usb function
925  *
926  */
927 static int usbhsg_gadget_start(struct usb_gadget *gadget,
928 		struct usb_gadget_driver *driver)
929 {
930 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
931 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
932 	struct device *dev = usbhs_priv_to_dev(priv);
933 	int ret;
934 
935 	if (!driver		||
936 	    !driver->setup	||
937 	    driver->max_speed < USB_SPEED_FULL)
938 		return -EINVAL;
939 
940 	/* connect to bus through transceiver */
941 	if (!IS_ERR_OR_NULL(gpriv->transceiver)) {
942 		ret = otg_set_peripheral(gpriv->transceiver->otg,
943 					&gpriv->gadget);
944 		if (ret) {
945 			dev_err(dev, "%s: can't bind to transceiver\n",
946 				gpriv->gadget.name);
947 			return ret;
948 		}
949 
950 		/* get vbus using phy versions */
951 		usbhs_mod_phy_mode(priv);
952 	}
953 
954 	/* first hook up the driver ... */
955 	gpriv->driver = driver;
956 
957 	return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD);
958 }
959 
960 static int usbhsg_gadget_stop(struct usb_gadget *gadget)
961 {
962 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
963 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
964 
965 	usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD);
966 
967 	if (!IS_ERR_OR_NULL(gpriv->transceiver))
968 		otg_set_peripheral(gpriv->transceiver->otg, NULL);
969 
970 	gpriv->driver = NULL;
971 
972 	return 0;
973 }
974 
975 /*
976  *		usb gadget ops
977  */
978 static int usbhsg_get_frame(struct usb_gadget *gadget)
979 {
980 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
981 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
982 
983 	return usbhs_frame_get_num(priv);
984 }
985 
986 static int usbhsg_pullup(struct usb_gadget *gadget, int is_on)
987 {
988 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
989 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
990 	unsigned long flags;
991 
992 	usbhs_lock(priv, flags);
993 	if (is_on)
994 		usbhsg_status_set(gpriv, USBHSG_STATUS_SOFT_CONNECT);
995 	else
996 		usbhsg_status_clr(gpriv, USBHSG_STATUS_SOFT_CONNECT);
997 	usbhsg_update_pullup(priv);
998 	usbhs_unlock(priv, flags);
999 
1000 	return 0;
1001 }
1002 
1003 static int usbhsg_set_selfpowered(struct usb_gadget *gadget, int is_self)
1004 {
1005 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1006 
1007 	if (is_self)
1008 		usbhsg_status_set(gpriv, USBHSG_STATUS_SELF_POWERED);
1009 	else
1010 		usbhsg_status_clr(gpriv, USBHSG_STATUS_SELF_POWERED);
1011 
1012 	gadget->is_selfpowered = (is_self != 0);
1013 
1014 	return 0;
1015 }
1016 
1017 static int usbhsg_vbus_session(struct usb_gadget *gadget, int is_active)
1018 {
1019 	struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
1020 	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
1021 	struct platform_device *pdev = usbhs_priv_to_pdev(priv);
1022 
1023 	gpriv->vbus_active = !!is_active;
1024 
1025 	renesas_usbhs_call_notify_hotplug(pdev);
1026 
1027 	return 0;
1028 }
1029 
1030 static const struct usb_gadget_ops usbhsg_gadget_ops = {
1031 	.get_frame		= usbhsg_get_frame,
1032 	.set_selfpowered	= usbhsg_set_selfpowered,
1033 	.udc_start		= usbhsg_gadget_start,
1034 	.udc_stop		= usbhsg_gadget_stop,
1035 	.pullup			= usbhsg_pullup,
1036 	.vbus_session		= usbhsg_vbus_session,
1037 };
1038 
1039 static int usbhsg_start(struct usbhs_priv *priv)
1040 {
1041 	return usbhsg_try_start(priv, USBHSG_STATUS_STARTED);
1042 }
1043 
1044 static int usbhsg_stop(struct usbhs_priv *priv)
1045 {
1046 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1047 
1048 	/* cable disconnect */
1049 	if (gpriv->driver &&
1050 	    gpriv->driver->disconnect)
1051 		gpriv->driver->disconnect(&gpriv->gadget);
1052 
1053 	return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED);
1054 }
1055 
1056 int usbhs_mod_gadget_probe(struct usbhs_priv *priv)
1057 {
1058 	struct usbhsg_gpriv *gpriv;
1059 	struct usbhsg_uep *uep;
1060 	struct device *dev = usbhs_priv_to_dev(priv);
1061 	struct renesas_usbhs_driver_pipe_config *pipe_configs =
1062 					usbhs_get_dparam(priv, pipe_configs);
1063 	int pipe_size = usbhs_get_dparam(priv, pipe_size);
1064 	int i;
1065 	int ret;
1066 
1067 	gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL);
1068 	if (!gpriv)
1069 		return -ENOMEM;
1070 
1071 	uep = kcalloc(pipe_size, sizeof(struct usbhsg_uep), GFP_KERNEL);
1072 	if (!uep) {
1073 		ret = -ENOMEM;
1074 		goto usbhs_mod_gadget_probe_err_gpriv;
1075 	}
1076 
1077 	gpriv->transceiver = usb_get_phy(USB_PHY_TYPE_UNDEFINED);
1078 	dev_info(dev, "%stransceiver found\n",
1079 		 !IS_ERR(gpriv->transceiver) ? "" : "no ");
1080 
1081 	/*
1082 	 * CAUTION
1083 	 *
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"
1087 	 */
1088 
1089 	/*
1090 	 * register itself
1091 	 */
1092 	usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET);
1093 
1094 	/* init gpriv */
1095 	gpriv->mod.name		= "gadget";
1096 	gpriv->mod.start	= usbhsg_start;
1097 	gpriv->mod.stop		= usbhsg_stop;
1098 	gpriv->uep		= uep;
1099 	gpriv->uep_size		= pipe_size;
1100 	usbhsg_status_init(gpriv);
1101 
1102 	/*
1103 	 * init gadget
1104 	 */
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;
1109 	gpriv->gadget.quirk_avoids_skb_reserve = usbhs_get_dparam(priv,
1110 								has_usb_dmac);
1111 
1112 	INIT_LIST_HEAD(&gpriv->gadget.ep_list);
1113 
1114 	/*
1115 	 * init usb_ep
1116 	 */
1117 	usbhsg_for_each_uep_with_dcp(uep, gpriv, i) {
1118 		uep->gpriv	= gpriv;
1119 		uep->pipe	= NULL;
1120 		snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i);
1121 
1122 		uep->ep.name		= uep->ep_name;
1123 		uep->ep.ops		= &usbhsg_ep_ops;
1124 		INIT_LIST_HEAD(&uep->ep.ep_list);
1125 		spin_lock_init(&uep->lock);
1126 
1127 		/* init DCP */
1128 		if (usbhsg_is_dcp(uep)) {
1129 			gpriv->gadget.ep0 = &uep->ep;
1130 			usb_ep_set_maxpacket_limit(&uep->ep, 64);
1131 			uep->ep.caps.type_control = true;
1132 		} else {
1133 			/* init normal pipe */
1134 			if (pipe_configs[i].type == USB_ENDPOINT_XFER_ISOC)
1135 				uep->ep.caps.type_iso = true;
1136 			if (pipe_configs[i].type == USB_ENDPOINT_XFER_BULK)
1137 				uep->ep.caps.type_bulk = true;
1138 			if (pipe_configs[i].type == USB_ENDPOINT_XFER_INT)
1139 				uep->ep.caps.type_int = true;
1140 			usb_ep_set_maxpacket_limit(&uep->ep,
1141 						   pipe_configs[i].bufsize);
1142 			list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list);
1143 		}
1144 		uep->ep.caps.dir_in = true;
1145 		uep->ep.caps.dir_out = true;
1146 	}
1147 
1148 	ret = usb_add_gadget_udc(dev, &gpriv->gadget);
1149 	if (ret)
1150 		goto err_add_udc;
1151 
1152 
1153 	dev_info(dev, "gadget probed\n");
1154 
1155 	return 0;
1156 
1157 err_add_udc:
1158 	kfree(gpriv->uep);
1159 
1160 usbhs_mod_gadget_probe_err_gpriv:
1161 	kfree(gpriv);
1162 
1163 	return ret;
1164 }
1165 
1166 void usbhs_mod_gadget_remove(struct usbhs_priv *priv)
1167 {
1168 	struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
1169 
1170 	usb_del_gadget_udc(&gpriv->gadget);
1171 
1172 	kfree(gpriv->uep);
1173 	kfree(gpriv);
1174 }
1175