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