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/io.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/slab.h>
22 #include <linux/usb.h>
23 #include <linux/usb/hcd.h>
24 #include "common.h"
25 
26 /*
27  *** HARDWARE LIMITATION ***
28  *
29  * 1) renesas_usbhs has a limited number of controllable devices.
30  *    it can control only 9 devices in generally.
31  *	see DEVADDn / DCPMAXP / PIPEMAXP.
32  *
33  * 2) renesas_usbhs pipe number is limited.
34  *    the pipe will be re-used for each devices.
35  *    so, software should control DATA0/1 sequence of each devices.
36  */
37 
38 
39 /*
40  *		image of mod_host
41  *
42  * +--------+
43  * | udev 0 | --> it is used when set address
44  * +--------+
45  *
46  * +--------+					pipes are reused for each uep.
47  * | udev 1 |-+- [uep 0 (dcp) ] --+		pipe will be switched when
48  * +--------+ |			  |		other device requested
49  *	      +- [uep 1 (bulk)]	--|---+		   +--------------+
50  *	      |			  +--------------> | pipe0 (dcp)  |
51  *	      +- [uep 2 (bulk)]	-@    |		   +--------------+
52  *				      |		   | pipe1 (isoc) |
53  * +--------+			      |		   +--------------+
54  * | udev 2 |-+- [uep 0 (dcp) ]	-@    +----------> | pipe2 (bulk) |
55  * +--------+ |					   +--------------+
56  *	      +- [uep 1 (int) ]	----+	  +------> | pipe3 (bulk) |
57  *				    |	  |	   +--------------+
58  * +--------+			    +-----|------> | pipe4 (int)  |
59  * | udev 3 |-+- [uep 0 (dcp) ]	-@	  |	   +--------------+
60  * +--------+ |				  |	   | ....	  |
61  *	      +- [uep 1 (bulk)]	-@	  |	   | ....	  |
62  *	      |				  |
63  *	      +- [uep 2 (bulk)]-----------+
64  *
65  * @ :	uep requested free pipe, but all have been used.
66  *	now it is waiting for free pipe
67  */
68 
69 
70 /*
71  *		struct
72  */
73 struct usbhsh_request {
74 	struct urb		*urb;
75 	struct usbhs_pkt	pkt;
76 };
77 
78 struct usbhsh_device {
79 	struct usb_device	*usbv;
80 	struct list_head	ep_list_head; /* list of usbhsh_ep */
81 };
82 
83 struct usbhsh_ep {
84 	struct usbhs_pipe	*pipe;   /* attached pipe */
85 	struct usbhsh_device	*udev;   /* attached udev */
86 	struct usb_host_endpoint *ep;
87 	struct list_head	ep_list; /* list to usbhsh_device */
88 	unsigned int		counter; /* pipe attach counter */
89 };
90 
91 #define USBHSH_DEVICE_MAX	10 /* see DEVADDn / DCPMAXP / PIPEMAXP */
92 #define USBHSH_PORT_MAX		 7 /* see DEVADDn :: HUBPORT */
93 struct usbhsh_hpriv {
94 	struct usbhs_mod	mod;
95 	struct usbhs_pipe	*dcp;
96 
97 	struct usbhsh_device	udev[USBHSH_DEVICE_MAX];
98 
99 	u32	port_stat;	/* USB_PORT_STAT_xxx */
100 
101 	struct completion	setup_ack_done;
102 };
103 
104 
105 static const char usbhsh_hcd_name[] = "renesas_usbhs host";
106 
107 /*
108  *		macro
109  */
110 #define usbhsh_priv_to_hpriv(priv) \
111 	container_of(usbhs_mod_get(priv, USBHS_HOST), struct usbhsh_hpriv, mod)
112 
113 #define __usbhsh_for_each_udev(start, pos, h, i)	\
114 	for ((i) = start;						\
115 	     ((i) < USBHSH_DEVICE_MAX) && ((pos) = (h)->udev + (i));	\
116 	     (i)++)
117 
118 #define usbhsh_for_each_udev(pos, hpriv, i)	\
119 	__usbhsh_for_each_udev(1, pos, hpriv, i)
120 
121 #define usbhsh_for_each_udev_with_dev0(pos, hpriv, i)	\
122 	__usbhsh_for_each_udev(0, pos, hpriv, i)
123 
124 #define usbhsh_hcd_to_hpriv(h)	(struct usbhsh_hpriv *)((h)->hcd_priv)
125 #define usbhsh_hcd_to_dev(h)	((h)->self.controller)
126 
127 #define usbhsh_hpriv_to_priv(h)	((h)->mod.priv)
128 #define usbhsh_hpriv_to_dcp(h)	((h)->dcp)
129 #define usbhsh_hpriv_to_hcd(h)	\
130 	container_of((void *)h, struct usb_hcd, hcd_priv)
131 
132 #define usbhsh_ep_to_uep(u)	((u)->hcpriv)
133 #define usbhsh_uep_to_pipe(u)	((u)->pipe)
134 #define usbhsh_uep_to_udev(u)	((u)->udev)
135 #define usbhsh_uep_to_ep(u)	((u)->ep)
136 
137 #define usbhsh_urb_to_ureq(u)	((u)->hcpriv)
138 #define usbhsh_urb_to_usbv(u)	((u)->dev)
139 
140 #define usbhsh_usbv_to_udev(d)	dev_get_drvdata(&(d)->dev)
141 
142 #define usbhsh_udev_to_usbv(h)	((h)->usbv)
143 #define usbhsh_udev_is_used(h)	usbhsh_udev_to_usbv(h)
144 
145 #define usbhsh_pipe_to_uep(p)	((p)->mod_private)
146 
147 #define usbhsh_device_parent(d)		(usbhsh_usbv_to_udev((d)->usbv->parent))
148 #define usbhsh_device_hubport(d)	((d)->usbv->portnum)
149 #define usbhsh_device_number(h, d)	((int)((d) - (h)->udev))
150 #define usbhsh_device_nth(h, d)		((h)->udev + d)
151 #define usbhsh_device0(h)		usbhsh_device_nth(h, 0)
152 
153 #define usbhsh_port_stat_init(h)	((h)->port_stat = 0)
154 #define usbhsh_port_stat_set(h, s)	((h)->port_stat |= (s))
155 #define usbhsh_port_stat_clear(h, s)	((h)->port_stat &= ~(s))
156 #define usbhsh_port_stat_get(h)		((h)->port_stat)
157 
158 #define usbhsh_pkt_to_ureq(p)	\
159 	container_of((void *)p, struct usbhsh_request, pkt)
160 
161 /*
162  *		req alloc/free
163  */
164 static struct usbhsh_request *usbhsh_ureq_alloc(struct usbhsh_hpriv *hpriv,
165 					       struct urb *urb,
166 					       gfp_t mem_flags)
167 {
168 	struct usbhsh_request *ureq;
169 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
170 	struct device *dev = usbhs_priv_to_dev(priv);
171 
172 	ureq = kzalloc(sizeof(struct usbhsh_request), mem_flags);
173 	if (!ureq) {
174 		dev_err(dev, "ureq alloc fail\n");
175 		return NULL;
176 	}
177 
178 	usbhs_pkt_init(&ureq->pkt);
179 	ureq->urb = urb;
180 	usbhsh_urb_to_ureq(urb) = ureq;
181 
182 	return ureq;
183 }
184 
185 static void usbhsh_ureq_free(struct usbhsh_hpriv *hpriv,
186 			    struct usbhsh_request *ureq)
187 {
188 	usbhsh_urb_to_ureq(ureq->urb) = NULL;
189 	ureq->urb = NULL;
190 
191 	kfree(ureq);
192 }
193 
194 /*
195  *		status
196  */
197 static int usbhsh_is_running(struct usbhsh_hpriv *hpriv)
198 {
199 	/*
200 	 * we can decide some device is attached or not
201 	 * by checking mod.irq_attch
202 	 * see
203 	 *	usbhsh_irq_attch()
204 	 *	usbhsh_irq_dtch()
205 	 */
206 	return (hpriv->mod.irq_attch == NULL);
207 }
208 
209 /*
210  *		pipe control
211  */
212 static void usbhsh_endpoint_sequence_save(struct usbhsh_hpriv *hpriv,
213 					  struct urb *urb,
214 					  struct usbhs_pkt *pkt)
215 {
216 	int len = urb->actual_length;
217 	int maxp = usb_endpoint_maxp(&urb->ep->desc);
218 	int t = 0;
219 
220 	/* DCP is out of sequence control */
221 	if (usb_pipecontrol(urb->pipe))
222 		return;
223 
224 	/*
225 	 * renesas_usbhs pipe has a limitation in a number.
226 	 * So, driver should re-use the limited pipe for each device/endpoint.
227 	 * DATA0/1 sequence should be saved for it.
228 	 * see [image of mod_host]
229 	 *     [HARDWARE LIMITATION]
230 	 */
231 
232 	/*
233 	 * next sequence depends on actual_length
234 	 *
235 	 * ex) actual_length = 1147, maxp = 512
236 	 * data0 : 512
237 	 * data1 : 512
238 	 * data0 : 123
239 	 * data1 is the next sequence
240 	 */
241 	t = len / maxp;
242 	if (len % maxp)
243 		t++;
244 	if (pkt->zero)
245 		t++;
246 	t %= 2;
247 
248 	if (t)
249 		usb_dotoggle(urb->dev,
250 			     usb_pipeendpoint(urb->pipe),
251 			     usb_pipeout(urb->pipe));
252 }
253 
254 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
255 					       struct urb *urb);
256 
257 static int usbhsh_pipe_attach(struct usbhsh_hpriv *hpriv,
258 			      struct urb *urb)
259 {
260 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
261 	struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
262 	struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
263 	struct usbhs_pipe *pipe;
264 	struct usb_endpoint_descriptor *desc = &urb->ep->desc;
265 	struct device *dev = usbhs_priv_to_dev(priv);
266 	unsigned long flags;
267 	int dir_in_req = !!usb_pipein(urb->pipe);
268 	int is_dcp = usb_endpoint_xfer_control(desc);
269 	int i, dir_in;
270 	int ret = -EBUSY;
271 
272 	/********************  spin lock ********************/
273 	usbhs_lock(priv, flags);
274 
275 	/*
276 	 * if uep has been attached to pipe,
277 	 * reuse it
278 	 */
279 	if (usbhsh_uep_to_pipe(uep)) {
280 		ret = 0;
281 		goto usbhsh_pipe_attach_done;
282 	}
283 
284 	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
285 
286 		/* check pipe type */
287 		if (!usbhs_pipe_type_is(pipe, usb_endpoint_type(desc)))
288 			continue;
289 
290 		/* check pipe direction if normal pipe */
291 		if (!is_dcp) {
292 			dir_in = !!usbhs_pipe_is_dir_in(pipe);
293 			if (0 != (dir_in - dir_in_req))
294 				continue;
295 		}
296 
297 		/* check pipe is free */
298 		if (usbhsh_pipe_to_uep(pipe))
299 			continue;
300 
301 		/*
302 		 * attach pipe to uep
303 		 *
304 		 * usbhs_pipe_config_update() should be called after
305 		 * usbhs_set_device_config()
306 		 * see
307 		 *  DCPMAXP/PIPEMAXP
308 		 */
309 		usbhsh_uep_to_pipe(uep)		= pipe;
310 		usbhsh_pipe_to_uep(pipe)	= uep;
311 
312 		usbhs_pipe_config_update(pipe,
313 					 usbhsh_device_number(hpriv, udev),
314 					 usb_endpoint_num(desc),
315 					 usb_endpoint_maxp(desc));
316 
317 		dev_dbg(dev, "%s [%d-%d(%s:%s)]\n", __func__,
318 			usbhsh_device_number(hpriv, udev),
319 			usb_endpoint_num(desc),
320 			usbhs_pipe_name(pipe),
321 			dir_in_req ? "in" : "out");
322 
323 		ret = 0;
324 		break;
325 	}
326 
327 usbhsh_pipe_attach_done:
328 	if (0 == ret)
329 		uep->counter++;
330 
331 	usbhs_unlock(priv, flags);
332 	/********************  spin unlock ******************/
333 
334 	return ret;
335 }
336 
337 static void usbhsh_pipe_detach(struct usbhsh_hpriv *hpriv,
338 			       struct usbhsh_ep *uep)
339 {
340 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
341 	struct usbhs_pipe *pipe;
342 	struct device *dev = usbhs_priv_to_dev(priv);
343 	unsigned long flags;
344 
345 	if (unlikely(!uep)) {
346 		dev_err(dev, "no uep\n");
347 		return;
348 	}
349 
350 	/********************  spin lock ********************/
351 	usbhs_lock(priv, flags);
352 
353 	pipe = usbhsh_uep_to_pipe(uep);
354 
355 	if (unlikely(!pipe)) {
356 		dev_err(dev, "uep doens't have pipe\n");
357 	} else if (1 == uep->counter--) { /* last user */
358 		struct usb_host_endpoint *ep = usbhsh_uep_to_ep(uep);
359 		struct usbhsh_device *udev = usbhsh_uep_to_udev(uep);
360 
361 		/* detach pipe from uep */
362 		usbhsh_uep_to_pipe(uep)		= NULL;
363 		usbhsh_pipe_to_uep(pipe)	= NULL;
364 
365 		dev_dbg(dev, "%s [%d-%d(%s)]\n", __func__,
366 			usbhsh_device_number(hpriv, udev),
367 			usb_endpoint_num(&ep->desc),
368 			usbhs_pipe_name(pipe));
369 	}
370 
371 	usbhs_unlock(priv, flags);
372 	/********************  spin unlock ******************/
373 }
374 
375 /*
376  *		endpoint control
377  */
378 static int usbhsh_endpoint_attach(struct usbhsh_hpriv *hpriv,
379 				  struct urb *urb,
380 				  gfp_t mem_flags)
381 {
382 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
383 	struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
384 	struct usb_host_endpoint *ep = urb->ep;
385 	struct usbhsh_ep *uep;
386 	struct device *dev = usbhs_priv_to_dev(priv);
387 	struct usb_endpoint_descriptor *desc = &ep->desc;
388 	unsigned long flags;
389 
390 	uep = kzalloc(sizeof(struct usbhsh_ep), mem_flags);
391 	if (!uep) {
392 		dev_err(dev, "usbhsh_ep alloc fail\n");
393 		return -ENOMEM;
394 	}
395 
396 	/********************  spin lock ********************/
397 	usbhs_lock(priv, flags);
398 
399 	/*
400 	 * init endpoint
401 	 */
402 	uep->counter = 0;
403 	INIT_LIST_HEAD(&uep->ep_list);
404 	list_add_tail(&uep->ep_list, &udev->ep_list_head);
405 
406 	usbhsh_uep_to_udev(uep)	= udev;
407 	usbhsh_uep_to_ep(uep)	= ep;
408 	usbhsh_ep_to_uep(ep)	= uep;
409 
410 	usbhs_unlock(priv, flags);
411 	/********************  spin unlock ******************/
412 
413 	dev_dbg(dev, "%s [%d-%d]\n", __func__,
414 		usbhsh_device_number(hpriv, udev),
415 		usb_endpoint_num(desc));
416 
417 	return 0;
418 }
419 
420 static void usbhsh_endpoint_detach(struct usbhsh_hpriv *hpriv,
421 				   struct usb_host_endpoint *ep)
422 {
423 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
424 	struct device *dev = usbhs_priv_to_dev(priv);
425 	struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
426 	unsigned long flags;
427 
428 	if (!uep)
429 		return;
430 
431 	dev_dbg(dev, "%s [%d-%d]\n", __func__,
432 		usbhsh_device_number(hpriv, usbhsh_uep_to_udev(uep)),
433 		usb_endpoint_num(&ep->desc));
434 
435 	if (usbhsh_uep_to_pipe(uep))
436 		usbhsh_pipe_detach(hpriv, uep);
437 
438 	/********************  spin lock ********************/
439 	usbhs_lock(priv, flags);
440 
441 	/* remove this endpoint from udev */
442 	list_del_init(&uep->ep_list);
443 
444 	usbhsh_uep_to_udev(uep)	= NULL;
445 	usbhsh_uep_to_ep(uep)	= NULL;
446 	usbhsh_ep_to_uep(ep)	= NULL;
447 
448 	usbhs_unlock(priv, flags);
449 	/********************  spin unlock ******************/
450 
451 	kfree(uep);
452 }
453 
454 static void usbhsh_endpoint_detach_all(struct usbhsh_hpriv *hpriv,
455 				       struct usbhsh_device *udev)
456 {
457 	struct usbhsh_ep *uep, *next;
458 
459 	list_for_each_entry_safe(uep, next, &udev->ep_list_head, ep_list)
460 		usbhsh_endpoint_detach(hpriv, usbhsh_uep_to_ep(uep));
461 }
462 
463 /*
464  *		device control
465  */
466 static int usbhsh_connected_to_rhdev(struct usb_hcd *hcd,
467 				     struct usbhsh_device *udev)
468 {
469 	struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
470 
471 	return hcd->self.root_hub == usbv->parent;
472 }
473 
474 static int usbhsh_device_has_endpoint(struct usbhsh_device *udev)
475 {
476 	return !list_empty(&udev->ep_list_head);
477 }
478 
479 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
480 					       struct urb *urb)
481 {
482 	struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
483 	struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
484 
485 	/* usbhsh_device_attach() is still not called */
486 	if (!udev)
487 		return NULL;
488 
489 	/* if it is device0, return it */
490 	if (0 == usb_pipedevice(urb->pipe))
491 		return usbhsh_device0(hpriv);
492 
493 	/* return attached device */
494 	return udev;
495 }
496 
497 static struct usbhsh_device *usbhsh_device_attach(struct usbhsh_hpriv *hpriv,
498 						 struct urb *urb)
499 {
500 	struct usbhsh_device *udev = NULL;
501 	struct usbhsh_device *udev0 = usbhsh_device0(hpriv);
502 	struct usbhsh_device *pos;
503 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
504 	struct device *dev = usbhsh_hcd_to_dev(hcd);
505 	struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
506 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
507 	unsigned long flags;
508 	u16 upphub, hubport;
509 	int i;
510 
511 	/*
512 	 * This function should be called only while urb is pointing to device0.
513 	 * It will attach unused usbhsh_device to urb (usbv),
514 	 * and initialize device0.
515 	 * You can use usbhsh_device_get() to get "current" udev,
516 	 * and usbhsh_usbv_to_udev() is for "attached" udev.
517 	 */
518 	if (0 != usb_pipedevice(urb->pipe)) {
519 		dev_err(dev, "%s fail: urb isn't pointing device0\n", __func__);
520 		return NULL;
521 	}
522 
523 	/********************  spin lock ********************/
524 	usbhs_lock(priv, flags);
525 
526 	/*
527 	 * find unused device
528 	 */
529 	usbhsh_for_each_udev(pos, hpriv, i) {
530 		if (usbhsh_udev_is_used(pos))
531 			continue;
532 		udev = pos;
533 		break;
534 	}
535 
536 	if (udev) {
537 		/*
538 		 * usbhsh_usbv_to_udev()
539 		 * usbhsh_udev_to_usbv()
540 		 * will be enable
541 		 */
542 		dev_set_drvdata(&usbv->dev, udev);
543 		udev->usbv = usbv;
544 	}
545 
546 	usbhs_unlock(priv, flags);
547 	/********************  spin unlock ******************/
548 
549 	if (!udev) {
550 		dev_err(dev, "no free usbhsh_device\n");
551 		return NULL;
552 	}
553 
554 	if (usbhsh_device_has_endpoint(udev)) {
555 		dev_warn(dev, "udev have old endpoint\n");
556 		usbhsh_endpoint_detach_all(hpriv, udev);
557 	}
558 
559 	if (usbhsh_device_has_endpoint(udev0)) {
560 		dev_warn(dev, "udev0 have old endpoint\n");
561 		usbhsh_endpoint_detach_all(hpriv, udev0);
562 	}
563 
564 	/* uep will be attached */
565 	INIT_LIST_HEAD(&udev0->ep_list_head);
566 	INIT_LIST_HEAD(&udev->ep_list_head);
567 
568 	/*
569 	 * set device0 config
570 	 */
571 	usbhs_set_device_config(priv,
572 				0, 0, 0, usbv->speed);
573 
574 	/*
575 	 * set new device config
576 	 */
577 	upphub	= 0;
578 	hubport	= 0;
579 	if (!usbhsh_connected_to_rhdev(hcd, udev)) {
580 		/* if udev is not connected to rhdev, it means parent is Hub */
581 		struct usbhsh_device *parent = usbhsh_device_parent(udev);
582 
583 		upphub	= usbhsh_device_number(hpriv, parent);
584 		hubport	= usbhsh_device_hubport(udev);
585 
586 		dev_dbg(dev, "%s connecte to Hub [%d:%d](%p)\n", __func__,
587 			upphub, hubport, parent);
588 	}
589 
590 	usbhs_set_device_config(priv,
591 			       usbhsh_device_number(hpriv, udev),
592 			       upphub, hubport, usbv->speed);
593 
594 	dev_dbg(dev, "%s [%d](%p)\n", __func__,
595 		usbhsh_device_number(hpriv, udev), udev);
596 
597 	return udev;
598 }
599 
600 static void usbhsh_device_detach(struct usbhsh_hpriv *hpriv,
601 			       struct usbhsh_device *udev)
602 {
603 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
604 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
605 	struct device *dev = usbhsh_hcd_to_dev(hcd);
606 	struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
607 	unsigned long flags;
608 
609 	dev_dbg(dev, "%s [%d](%p)\n", __func__,
610 		usbhsh_device_number(hpriv, udev), udev);
611 
612 	if (usbhsh_device_has_endpoint(udev)) {
613 		dev_warn(dev, "udev still have endpoint\n");
614 		usbhsh_endpoint_detach_all(hpriv, udev);
615 	}
616 
617 	/*
618 	 * There is nothing to do if it is device0.
619 	 * see
620 	 *  usbhsh_device_attach()
621 	 *  usbhsh_device_get()
622 	 */
623 	if (0 == usbhsh_device_number(hpriv, udev))
624 		return;
625 
626 	/********************  spin lock ********************/
627 	usbhs_lock(priv, flags);
628 
629 	/*
630 	 * usbhsh_usbv_to_udev()
631 	 * usbhsh_udev_to_usbv()
632 	 * will be disable
633 	 */
634 	dev_set_drvdata(&usbv->dev, NULL);
635 	udev->usbv = NULL;
636 
637 	usbhs_unlock(priv, flags);
638 	/********************  spin unlock ******************/
639 }
640 
641 /*
642  *		queue push/pop
643  */
644 static void usbhsh_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
645 {
646 	struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
647 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
648 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
649 	struct urb *urb = ureq->urb;
650 	struct device *dev = usbhs_priv_to_dev(priv);
651 	int status = 0;
652 
653 	dev_dbg(dev, "%s\n", __func__);
654 
655 	if (!urb) {
656 		dev_warn(dev, "pkt doesn't have urb\n");
657 		return;
658 	}
659 
660 	if (!usbhsh_is_running(hpriv))
661 		status = -ESHUTDOWN;
662 
663 	urb->actual_length = pkt->actual;
664 
665 	usbhsh_endpoint_sequence_save(hpriv, urb, pkt);
666 	usbhsh_ureq_free(hpriv, ureq);
667 
668 	usbhsh_pipe_detach(hpriv, usbhsh_ep_to_uep(urb->ep));
669 
670 	usb_hcd_unlink_urb_from_ep(hcd, urb);
671 	usb_hcd_giveback_urb(hcd, urb, status);
672 }
673 
674 static int usbhsh_queue_push(struct usb_hcd *hcd,
675 			     struct urb *urb,
676 			     gfp_t mem_flags)
677 {
678 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
679 	struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
680 	struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
681 	struct device *dev = usbhsh_hcd_to_dev(hcd);
682 	struct usbhsh_request *ureq;
683 	void *buf;
684 	int len, sequence;
685 
686 	if (usb_pipeisoc(urb->pipe)) {
687 		dev_err(dev, "pipe iso is not supported now\n");
688 		return -EIO;
689 	}
690 
691 	/* this ureq will be freed on usbhsh_queue_done() */
692 	ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
693 	if (unlikely(!ureq)) {
694 		dev_err(dev, "ureq alloc fail\n");
695 		return -ENOMEM;
696 	}
697 
698 	if (usb_pipein(urb->pipe))
699 		pipe->handler = &usbhs_fifo_dma_pop_handler;
700 	else
701 		pipe->handler = &usbhs_fifo_dma_push_handler;
702 
703 	buf = (void *)(urb->transfer_buffer + urb->actual_length);
704 	len = urb->transfer_buffer_length - urb->actual_length;
705 
706 	sequence = usb_gettoggle(urb->dev,
707 				 usb_pipeendpoint(urb->pipe),
708 				 usb_pipeout(urb->pipe));
709 
710 	dev_dbg(dev, "%s\n", __func__);
711 	usbhs_pkt_push(pipe, &ureq->pkt, usbhsh_queue_done,
712 		       buf, len, (urb->transfer_flags & URB_ZERO_PACKET),
713 		       sequence);
714 
715 	usbhs_pkt_start(pipe);
716 
717 	return 0;
718 }
719 
720 static void usbhsh_queue_force_pop(struct usbhs_priv *priv,
721 				   struct usbhs_pipe *pipe)
722 {
723 	struct usbhs_pkt *pkt;
724 
725 	while (1) {
726 		pkt = usbhs_pkt_pop(pipe, NULL);
727 		if (!pkt)
728 			break;
729 
730 		/*
731 		 * if all packet are gone, usbhsh_endpoint_disable()
732 		 * will be called.
733 		 * then, attached device/endpoint/pipe will be detached
734 		 */
735 		usbhsh_queue_done(priv, pkt);
736 	}
737 }
738 
739 static void usbhsh_queue_force_pop_all(struct usbhs_priv *priv)
740 {
741 	struct usbhs_pipe *pos;
742 	int i;
743 
744 	usbhs_for_each_pipe_with_dcp(pos, priv, i)
745 		usbhsh_queue_force_pop(priv, pos);
746 }
747 
748 /*
749  *		DCP setup stage
750  */
751 static int usbhsh_is_request_address(struct urb *urb)
752 {
753 	struct usb_ctrlrequest *req;
754 
755 	req = (struct usb_ctrlrequest *)urb->setup_packet;
756 
757 	if ((DeviceOutRequest    == req->bRequestType << 8) &&
758 	    (USB_REQ_SET_ADDRESS == req->bRequest))
759 		return 1;
760 	else
761 		return 0;
762 }
763 
764 static void usbhsh_setup_stage_packet_push(struct usbhsh_hpriv *hpriv,
765 					   struct urb *urb,
766 					   struct usbhs_pipe *pipe)
767 {
768 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
769 	struct usb_ctrlrequest req;
770 	struct device *dev = usbhs_priv_to_dev(priv);
771 
772 	/*
773 	 * wait setup packet ACK
774 	 * see
775 	 *	usbhsh_irq_setup_ack()
776 	 *	usbhsh_irq_setup_err()
777 	 */
778 	init_completion(&hpriv->setup_ack_done);
779 
780 	/* copy original request */
781 	memcpy(&req, urb->setup_packet, sizeof(struct usb_ctrlrequest));
782 
783 	/*
784 	 * renesas_usbhs can not use original usb address.
785 	 * see HARDWARE LIMITATION.
786 	 * modify usb address here to use attached device.
787 	 * see usbhsh_device_attach()
788 	 */
789 	if (usbhsh_is_request_address(urb)) {
790 		struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
791 		struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
792 
793 		/* udev is a attached device */
794 		req.wValue = usbhsh_device_number(hpriv, udev);
795 		dev_dbg(dev, "create new address - %d\n", req.wValue);
796 	}
797 
798 	/* set request */
799 	usbhs_usbreq_set_val(priv, &req);
800 
801 	/*
802 	 * wait setup packet ACK
803 	 */
804 	wait_for_completion(&hpriv->setup_ack_done);
805 
806 	dev_dbg(dev, "%s done\n", __func__);
807 }
808 
809 /*
810  *		DCP data stage
811  */
812 static void usbhsh_data_stage_packet_done(struct usbhs_priv *priv,
813 					  struct usbhs_pkt *pkt)
814 {
815 	struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
816 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
817 
818 	/* this ureq was connected to urb when usbhsh_urb_enqueue()  */
819 
820 	usbhsh_ureq_free(hpriv, ureq);
821 }
822 
823 static int usbhsh_data_stage_packet_push(struct usbhsh_hpriv *hpriv,
824 					 struct urb *urb,
825 					 struct usbhs_pipe *pipe,
826 					 gfp_t mem_flags)
827 
828 {
829 	struct usbhsh_request *ureq;
830 
831 	/* this ureq will be freed on usbhsh_data_stage_packet_done() */
832 	ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
833 	if (unlikely(!ureq))
834 		return -ENOMEM;
835 
836 	if (usb_pipein(urb->pipe))
837 		pipe->handler = &usbhs_dcp_data_stage_in_handler;
838 	else
839 		pipe->handler = &usbhs_dcp_data_stage_out_handler;
840 
841 	usbhs_pkt_push(pipe, &ureq->pkt,
842 		       usbhsh_data_stage_packet_done,
843 		       urb->transfer_buffer,
844 		       urb->transfer_buffer_length,
845 		       (urb->transfer_flags & URB_ZERO_PACKET),
846 		       -1);
847 
848 	return 0;
849 }
850 
851 /*
852  *		DCP status stage
853  */
854 static int usbhsh_status_stage_packet_push(struct usbhsh_hpriv *hpriv,
855 					    struct urb *urb,
856 					    struct usbhs_pipe *pipe,
857 					    gfp_t mem_flags)
858 {
859 	struct usbhsh_request *ureq;
860 
861 	/* This ureq will be freed on usbhsh_queue_done() */
862 	ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
863 	if (unlikely(!ureq))
864 		return -ENOMEM;
865 
866 	if (usb_pipein(urb->pipe))
867 		pipe->handler = &usbhs_dcp_status_stage_in_handler;
868 	else
869 		pipe->handler = &usbhs_dcp_status_stage_out_handler;
870 
871 	usbhs_pkt_push(pipe, &ureq->pkt,
872 		       usbhsh_queue_done,
873 		       NULL,
874 		       urb->transfer_buffer_length,
875 		       0, -1);
876 
877 	return 0;
878 }
879 
880 static int usbhsh_dcp_queue_push(struct usb_hcd *hcd,
881 				 struct urb *urb,
882 				 gfp_t mflags)
883 {
884 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
885 	struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
886 	struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
887 	struct device *dev = usbhsh_hcd_to_dev(hcd);
888 	int ret;
889 
890 	dev_dbg(dev, "%s\n", __func__);
891 
892 	/*
893 	 * setup stage
894 	 *
895 	 * usbhsh_send_setup_stage_packet() wait SACK/SIGN
896 	 */
897 	usbhsh_setup_stage_packet_push(hpriv, urb, pipe);
898 
899 	/*
900 	 * data stage
901 	 *
902 	 * It is pushed only when urb has buffer.
903 	 */
904 	if (urb->transfer_buffer_length) {
905 		ret = usbhsh_data_stage_packet_push(hpriv, urb, pipe, mflags);
906 		if (ret < 0) {
907 			dev_err(dev, "data stage failed\n");
908 			return ret;
909 		}
910 	}
911 
912 	/*
913 	 * status stage
914 	 */
915 	ret = usbhsh_status_stage_packet_push(hpriv, urb, pipe, mflags);
916 	if (ret < 0) {
917 		dev_err(dev, "status stage failed\n");
918 		return ret;
919 	}
920 
921 	/*
922 	 * start pushed packets
923 	 */
924 	usbhs_pkt_start(pipe);
925 
926 	return 0;
927 }
928 
929 /*
930  *		dma map functions
931  */
932 static int usbhsh_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
933 {
934 	if (map) {
935 		struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
936 		struct urb *urb = ureq->urb;
937 
938 		/* it can not use scatter/gather */
939 		if (urb->num_sgs)
940 			return -EINVAL;
941 
942 		pkt->dma = urb->transfer_dma;
943 		if (!pkt->dma)
944 			return -EINVAL;
945 	}
946 
947 	return 0;
948 }
949 
950 /*
951  *		for hc_driver
952  */
953 static int usbhsh_host_start(struct usb_hcd *hcd)
954 {
955 	return 0;
956 }
957 
958 static void usbhsh_host_stop(struct usb_hcd *hcd)
959 {
960 }
961 
962 static int usbhsh_urb_enqueue(struct usb_hcd *hcd,
963 			      struct urb *urb,
964 			      gfp_t mem_flags)
965 {
966 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
967 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
968 	struct device *dev = usbhs_priv_to_dev(priv);
969 	struct usb_host_endpoint *ep = urb->ep;
970 	struct usbhsh_device *new_udev = NULL;
971 	int is_dir_in = usb_pipein(urb->pipe);
972 	int ret;
973 
974 	dev_dbg(dev, "%s (%s)\n", __func__, is_dir_in ? "in" : "out");
975 
976 	if (!usbhsh_is_running(hpriv)) {
977 		ret = -EIO;
978 		dev_err(dev, "host is not running\n");
979 		goto usbhsh_urb_enqueue_error_not_linked;
980 	}
981 
982 	ret = usb_hcd_link_urb_to_ep(hcd, urb);
983 	if (ret) {
984 		dev_err(dev, "urb link failed\n");
985 		goto usbhsh_urb_enqueue_error_not_linked;
986 	}
987 
988 	/*
989 	 * attach udev if needed
990 	 * see [image of mod_host]
991 	 */
992 	if (!usbhsh_device_get(hpriv, urb)) {
993 		new_udev = usbhsh_device_attach(hpriv, urb);
994 		if (!new_udev) {
995 			ret = -EIO;
996 			dev_err(dev, "device attach failed\n");
997 			goto usbhsh_urb_enqueue_error_not_linked;
998 		}
999 	}
1000 
1001 	/*
1002 	 * attach endpoint if needed
1003 	 * see [image of mod_host]
1004 	 */
1005 	if (!usbhsh_ep_to_uep(ep)) {
1006 		ret = usbhsh_endpoint_attach(hpriv, urb, mem_flags);
1007 		if (ret < 0) {
1008 			dev_err(dev, "endpoint attach failed\n");
1009 			goto usbhsh_urb_enqueue_error_free_device;
1010 		}
1011 	}
1012 
1013 	/*
1014 	 * attach pipe to endpoint
1015 	 * see [image of mod_host]
1016 	 */
1017 	ret = usbhsh_pipe_attach(hpriv, urb);
1018 	if (ret < 0) {
1019 		dev_err(dev, "pipe attach failed\n");
1020 		goto usbhsh_urb_enqueue_error_free_endpoint;
1021 	}
1022 
1023 	/*
1024 	 * push packet
1025 	 */
1026 	if (usb_pipecontrol(urb->pipe))
1027 		ret = usbhsh_dcp_queue_push(hcd, urb, mem_flags);
1028 	else
1029 		ret = usbhsh_queue_push(hcd, urb, mem_flags);
1030 
1031 	return ret;
1032 
1033 usbhsh_urb_enqueue_error_free_endpoint:
1034 	usbhsh_endpoint_detach(hpriv, ep);
1035 usbhsh_urb_enqueue_error_free_device:
1036 	if (new_udev)
1037 		usbhsh_device_detach(hpriv, new_udev);
1038 usbhsh_urb_enqueue_error_not_linked:
1039 
1040 	dev_dbg(dev, "%s error\n", __func__);
1041 
1042 	return ret;
1043 }
1044 
1045 static int usbhsh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1046 {
1047 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1048 	struct usbhsh_request *ureq = usbhsh_urb_to_ureq(urb);
1049 
1050 	if (ureq) {
1051 		struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1052 		struct usbhs_pkt *pkt = &ureq->pkt;
1053 
1054 		usbhs_pkt_pop(pkt->pipe, pkt);
1055 		usbhsh_queue_done(priv, pkt);
1056 	}
1057 
1058 	return 0;
1059 }
1060 
1061 static void usbhsh_endpoint_disable(struct usb_hcd *hcd,
1062 				    struct usb_host_endpoint *ep)
1063 {
1064 	struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
1065 	struct usbhsh_device *udev;
1066 	struct usbhsh_hpriv *hpriv;
1067 
1068 	/*
1069 	 * this function might be called manytimes by same hcd/ep
1070 	 * in-endpoint == out-endpoint if ep == dcp.
1071 	 */
1072 	if (!uep)
1073 		return;
1074 
1075 	udev	= usbhsh_uep_to_udev(uep);
1076 	hpriv	= usbhsh_hcd_to_hpriv(hcd);
1077 
1078 	usbhsh_endpoint_detach(hpriv, ep);
1079 
1080 	/*
1081 	 * if there is no endpoint,
1082 	 * free device
1083 	 */
1084 	if (!usbhsh_device_has_endpoint(udev))
1085 		usbhsh_device_detach(hpriv, udev);
1086 }
1087 
1088 static int usbhsh_hub_status_data(struct usb_hcd *hcd, char *buf)
1089 {
1090 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1091 	int roothub_id = 1; /* only 1 root hub */
1092 
1093 	/*
1094 	 * does port stat was changed ?
1095 	 * check USB_PORT_STAT_C_xxx << 16
1096 	 */
1097 	if (usbhsh_port_stat_get(hpriv) & 0xFFFF0000)
1098 		*buf = (1 << roothub_id);
1099 	else
1100 		*buf = 0;
1101 
1102 	return !!(*buf);
1103 }
1104 
1105 static int __usbhsh_hub_hub_feature(struct usbhsh_hpriv *hpriv,
1106 				    u16 typeReq, u16 wValue,
1107 				    u16 wIndex, char *buf, u16 wLength)
1108 {
1109 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1110 	struct device *dev = usbhs_priv_to_dev(priv);
1111 
1112 	switch (wValue) {
1113 	case C_HUB_OVER_CURRENT:
1114 	case C_HUB_LOCAL_POWER:
1115 		dev_dbg(dev, "%s :: C_HUB_xx\n", __func__);
1116 		return 0;
1117 	}
1118 
1119 	return -EPIPE;
1120 }
1121 
1122 static int __usbhsh_hub_port_feature(struct usbhsh_hpriv *hpriv,
1123 				     u16 typeReq, u16 wValue,
1124 				     u16 wIndex, char *buf, u16 wLength)
1125 {
1126 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1127 	struct device *dev = usbhs_priv_to_dev(priv);
1128 	int enable = (typeReq == SetPortFeature);
1129 	int speed, i, timeout = 128;
1130 	int roothub_id = 1; /* only 1 root hub */
1131 
1132 	/* common error */
1133 	if (wIndex > roothub_id || wLength != 0)
1134 		return -EPIPE;
1135 
1136 	/* check wValue */
1137 	switch (wValue) {
1138 	case USB_PORT_FEAT_POWER:
1139 		usbhs_vbus_ctrl(priv, enable);
1140 		dev_dbg(dev, "%s :: USB_PORT_FEAT_POWER\n", __func__);
1141 		break;
1142 
1143 	case USB_PORT_FEAT_ENABLE:
1144 	case USB_PORT_FEAT_SUSPEND:
1145 	case USB_PORT_FEAT_C_ENABLE:
1146 	case USB_PORT_FEAT_C_SUSPEND:
1147 	case USB_PORT_FEAT_C_CONNECTION:
1148 	case USB_PORT_FEAT_C_OVER_CURRENT:
1149 	case USB_PORT_FEAT_C_RESET:
1150 		dev_dbg(dev, "%s :: USB_PORT_FEAT_xxx\n", __func__);
1151 		break;
1152 
1153 	case USB_PORT_FEAT_RESET:
1154 		if (!enable)
1155 			break;
1156 
1157 		usbhsh_port_stat_clear(hpriv,
1158 				       USB_PORT_STAT_HIGH_SPEED |
1159 				       USB_PORT_STAT_LOW_SPEED);
1160 
1161 		usbhsh_queue_force_pop_all(priv);
1162 
1163 		usbhs_bus_send_reset(priv);
1164 		msleep(20);
1165 		usbhs_bus_send_sof_enable(priv);
1166 
1167 		for (i = 0; i < timeout ; i++) {
1168 			switch (usbhs_bus_get_speed(priv)) {
1169 			case USB_SPEED_LOW:
1170 				speed = USB_PORT_STAT_LOW_SPEED;
1171 				goto got_usb_bus_speed;
1172 			case USB_SPEED_HIGH:
1173 				speed = USB_PORT_STAT_HIGH_SPEED;
1174 				goto got_usb_bus_speed;
1175 			case USB_SPEED_FULL:
1176 				speed = 0;
1177 				goto got_usb_bus_speed;
1178 			}
1179 
1180 			msleep(20);
1181 		}
1182 		return -EPIPE;
1183 
1184 got_usb_bus_speed:
1185 		usbhsh_port_stat_set(hpriv, speed);
1186 		usbhsh_port_stat_set(hpriv, USB_PORT_STAT_ENABLE);
1187 
1188 		dev_dbg(dev, "%s :: USB_PORT_FEAT_RESET (speed = %d)\n",
1189 			__func__, speed);
1190 
1191 		/* status change is not needed */
1192 		return 0;
1193 
1194 	default:
1195 		return -EPIPE;
1196 	}
1197 
1198 	/* set/clear status */
1199 	if (enable)
1200 		usbhsh_port_stat_set(hpriv, (1 << wValue));
1201 	else
1202 		usbhsh_port_stat_clear(hpriv, (1 << wValue));
1203 
1204 	return 0;
1205 }
1206 
1207 static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv,
1208 				   u16 typeReq, u16 wValue,
1209 				   u16 wIndex, char *buf, u16 wLength)
1210 {
1211 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1212 	struct usb_hub_descriptor *desc = (struct usb_hub_descriptor *)buf;
1213 	struct device *dev = usbhs_priv_to_dev(priv);
1214 	int roothub_id = 1; /* only 1 root hub */
1215 
1216 	switch (typeReq) {
1217 	case GetHubStatus:
1218 		dev_dbg(dev, "%s :: GetHubStatus\n", __func__);
1219 
1220 		*buf = 0x00;
1221 		break;
1222 
1223 	case GetPortStatus:
1224 		if (wIndex != roothub_id)
1225 			return -EPIPE;
1226 
1227 		dev_dbg(dev, "%s :: GetPortStatus\n", __func__);
1228 		*(__le32 *)buf = cpu_to_le32(usbhsh_port_stat_get(hpriv));
1229 		break;
1230 
1231 	case GetHubDescriptor:
1232 		desc->bDescriptorType		= USB_DT_HUB;
1233 		desc->bHubContrCurrent		= 0;
1234 		desc->bNbrPorts			= roothub_id;
1235 		desc->bDescLength		= 9;
1236 		desc->bPwrOn2PwrGood		= 0;
1237 		desc->wHubCharacteristics	=
1238 			cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM);
1239 		desc->u.hs.DeviceRemovable[0]	= (roothub_id << 1);
1240 		desc->u.hs.DeviceRemovable[1]	= ~0;
1241 		dev_dbg(dev, "%s :: GetHubDescriptor\n", __func__);
1242 		break;
1243 	}
1244 
1245 	return 0;
1246 }
1247 
1248 static int usbhsh_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
1249 			      u16 wIndex, char *buf, u16 wLength)
1250 {
1251 	struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1252 	struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1253 	struct device *dev = usbhs_priv_to_dev(priv);
1254 	int ret = -EPIPE;
1255 
1256 	switch (typeReq) {
1257 
1258 	/* Hub Feature */
1259 	case ClearHubFeature:
1260 	case SetHubFeature:
1261 		ret = __usbhsh_hub_hub_feature(hpriv, typeReq,
1262 					       wValue, wIndex, buf, wLength);
1263 		break;
1264 
1265 	/* Port Feature */
1266 	case SetPortFeature:
1267 	case ClearPortFeature:
1268 		ret = __usbhsh_hub_port_feature(hpriv, typeReq,
1269 						wValue, wIndex, buf, wLength);
1270 		break;
1271 
1272 	/* Get status */
1273 	case GetHubStatus:
1274 	case GetPortStatus:
1275 	case GetHubDescriptor:
1276 		ret = __usbhsh_hub_get_status(hpriv, typeReq,
1277 					      wValue, wIndex, buf, wLength);
1278 		break;
1279 	}
1280 
1281 	dev_dbg(dev, "typeReq = %x, ret = %d, port_stat = %x\n",
1282 		typeReq, ret, usbhsh_port_stat_get(hpriv));
1283 
1284 	return ret;
1285 }
1286 
1287 static int usbhsh_bus_nop(struct usb_hcd *hcd)
1288 {
1289 	/* nothing to do */
1290 	return 0;
1291 }
1292 
1293 static struct hc_driver usbhsh_driver = {
1294 	.description =		usbhsh_hcd_name,
1295 	.hcd_priv_size =	sizeof(struct usbhsh_hpriv),
1296 
1297 	/*
1298 	 * generic hardware linkage
1299 	 */
1300 	.flags =		HCD_USB2,
1301 
1302 	.start =		usbhsh_host_start,
1303 	.stop =			usbhsh_host_stop,
1304 
1305 	/*
1306 	 * managing i/o requests and associated device resources
1307 	 */
1308 	.urb_enqueue =		usbhsh_urb_enqueue,
1309 	.urb_dequeue =		usbhsh_urb_dequeue,
1310 	.endpoint_disable =	usbhsh_endpoint_disable,
1311 
1312 	/*
1313 	 * root hub
1314 	 */
1315 	.hub_status_data =	usbhsh_hub_status_data,
1316 	.hub_control =		usbhsh_hub_control,
1317 	.bus_suspend =		usbhsh_bus_nop,
1318 	.bus_resume =		usbhsh_bus_nop,
1319 };
1320 
1321 /*
1322  *		interrupt functions
1323  */
1324 static int usbhsh_irq_attch(struct usbhs_priv *priv,
1325 			    struct usbhs_irq_state *irq_state)
1326 {
1327 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1328 	struct device *dev = usbhs_priv_to_dev(priv);
1329 
1330 	dev_dbg(dev, "device attached\n");
1331 
1332 	usbhsh_port_stat_set(hpriv, USB_PORT_STAT_CONNECTION);
1333 	usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1334 
1335 	/*
1336 	 * attch interrupt might happen infinitely on some device
1337 	 * (on self power USB hub ?)
1338 	 * disable it here.
1339 	 *
1340 	 * usbhsh_is_running() becomes effective
1341 	 * according to this process.
1342 	 * see
1343 	 *	usbhsh_is_running()
1344 	 *	usbhsh_urb_enqueue()
1345 	 */
1346 	hpriv->mod.irq_attch = NULL;
1347 	usbhs_irq_callback_update(priv, &hpriv->mod);
1348 
1349 	return 0;
1350 }
1351 
1352 static int usbhsh_irq_dtch(struct usbhs_priv *priv,
1353 			   struct usbhs_irq_state *irq_state)
1354 {
1355 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1356 	struct device *dev = usbhs_priv_to_dev(priv);
1357 
1358 	dev_dbg(dev, "device detached\n");
1359 
1360 	usbhsh_port_stat_clear(hpriv, USB_PORT_STAT_CONNECTION);
1361 	usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1362 
1363 	/*
1364 	 * enable attch interrupt again
1365 	 *
1366 	 * usbhsh_is_running() becomes invalid
1367 	 * according to this process.
1368 	 * see
1369 	 *	usbhsh_is_running()
1370 	 *	usbhsh_urb_enqueue()
1371 	 */
1372 	hpriv->mod.irq_attch = usbhsh_irq_attch;
1373 	usbhs_irq_callback_update(priv, &hpriv->mod);
1374 
1375 	/*
1376 	 * usbhsh_queue_force_pop_all() should be called
1377 	 * after usbhsh_is_running() becomes invalid.
1378 	 */
1379 	usbhsh_queue_force_pop_all(priv);
1380 
1381 	return 0;
1382 }
1383 
1384 static int usbhsh_irq_setup_ack(struct usbhs_priv *priv,
1385 				struct usbhs_irq_state *irq_state)
1386 {
1387 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1388 	struct device *dev = usbhs_priv_to_dev(priv);
1389 
1390 	dev_dbg(dev, "setup packet OK\n");
1391 
1392 	complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */
1393 
1394 	return 0;
1395 }
1396 
1397 static int usbhsh_irq_setup_err(struct usbhs_priv *priv,
1398 				struct usbhs_irq_state *irq_state)
1399 {
1400 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1401 	struct device *dev = usbhs_priv_to_dev(priv);
1402 
1403 	dev_dbg(dev, "setup packet Err\n");
1404 
1405 	complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */
1406 
1407 	return 0;
1408 }
1409 
1410 /*
1411  *		module start/stop
1412  */
1413 static void usbhsh_pipe_init_for_host(struct usbhs_priv *priv)
1414 {
1415 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1416 	struct usbhs_pipe *pipe;
1417 	u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
1418 	int pipe_size = usbhs_get_dparam(priv, pipe_size);
1419 	int old_type, dir_in, i;
1420 
1421 	/* init all pipe */
1422 	old_type = USB_ENDPOINT_XFER_CONTROL;
1423 	for (i = 0; i < pipe_size; i++) {
1424 
1425 		/*
1426 		 * data "output" will be finished as soon as possible,
1427 		 * but there is no guaranty at data "input" case.
1428 		 *
1429 		 * "input" needs "standby" pipe.
1430 		 * So, "input" direction pipe > "output" direction pipe
1431 		 * is good idea.
1432 		 *
1433 		 * 1st USB_ENDPOINT_XFER_xxx will be output direction,
1434 		 * and the other will be input direction here.
1435 		 *
1436 		 * ex)
1437 		 * ...
1438 		 * USB_ENDPOINT_XFER_ISOC -> dir out
1439 		 * USB_ENDPOINT_XFER_ISOC -> dir in
1440 		 * USB_ENDPOINT_XFER_BULK -> dir out
1441 		 * USB_ENDPOINT_XFER_BULK -> dir in
1442 		 * USB_ENDPOINT_XFER_BULK -> dir in
1443 		 * ...
1444 		 */
1445 		dir_in = (pipe_type[i] == old_type);
1446 		old_type = pipe_type[i];
1447 
1448 		if (USB_ENDPOINT_XFER_CONTROL == pipe_type[i]) {
1449 			pipe = usbhs_dcp_malloc(priv);
1450 			usbhsh_hpriv_to_dcp(hpriv) = pipe;
1451 		} else {
1452 			pipe = usbhs_pipe_malloc(priv,
1453 						 pipe_type[i],
1454 						 dir_in);
1455 		}
1456 
1457 		pipe->mod_private = NULL;
1458 	}
1459 }
1460 
1461 static int usbhsh_start(struct usbhs_priv *priv)
1462 {
1463 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1464 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1465 	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1466 	struct device *dev = usbhs_priv_to_dev(priv);
1467 	int ret;
1468 
1469 	/* add hcd */
1470 	ret = usb_add_hcd(hcd, 0, 0);
1471 	if (ret < 0)
1472 		return 0;
1473 	device_wakeup_enable(hcd->self.controller);
1474 
1475 	/*
1476 	 * pipe initialize and enable DCP
1477 	 */
1478 	usbhs_fifo_init(priv);
1479 	usbhs_pipe_init(priv,
1480 			usbhsh_dma_map_ctrl);
1481 	usbhsh_pipe_init_for_host(priv);
1482 
1483 	/*
1484 	 * system config enble
1485 	 * - HI speed
1486 	 * - host
1487 	 * - usb module
1488 	 */
1489 	usbhs_sys_host_ctrl(priv, 1);
1490 
1491 	/*
1492 	 * enable irq callback
1493 	 */
1494 	mod->irq_attch		= usbhsh_irq_attch;
1495 	mod->irq_dtch		= usbhsh_irq_dtch;
1496 	mod->irq_sack		= usbhsh_irq_setup_ack;
1497 	mod->irq_sign		= usbhsh_irq_setup_err;
1498 	usbhs_irq_callback_update(priv, mod);
1499 
1500 	dev_dbg(dev, "start host\n");
1501 
1502 	return ret;
1503 }
1504 
1505 static int usbhsh_stop(struct usbhs_priv *priv)
1506 {
1507 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1508 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1509 	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1510 	struct device *dev = usbhs_priv_to_dev(priv);
1511 
1512 	/*
1513 	 * disable irq callback
1514 	 */
1515 	mod->irq_attch	= NULL;
1516 	mod->irq_dtch	= NULL;
1517 	mod->irq_sack	= NULL;
1518 	mod->irq_sign	= NULL;
1519 	usbhs_irq_callback_update(priv, mod);
1520 
1521 	usb_remove_hcd(hcd);
1522 
1523 	/* disable sys */
1524 	usbhs_sys_host_ctrl(priv, 0);
1525 
1526 	dev_dbg(dev, "quit host\n");
1527 
1528 	return 0;
1529 }
1530 
1531 int usbhs_mod_host_probe(struct usbhs_priv *priv)
1532 {
1533 	struct usbhsh_hpriv *hpriv;
1534 	struct usb_hcd *hcd;
1535 	struct usbhsh_device *udev;
1536 	struct device *dev = usbhs_priv_to_dev(priv);
1537 	int i;
1538 
1539 	/* initialize hcd */
1540 	hcd = usb_create_hcd(&usbhsh_driver, dev, usbhsh_hcd_name);
1541 	if (!hcd) {
1542 		dev_err(dev, "Failed to create hcd\n");
1543 		return -ENOMEM;
1544 	}
1545 	hcd->has_tt = 1; /* for low/full speed */
1546 
1547 	/*
1548 	 * CAUTION
1549 	 *
1550 	 * There is no guarantee that it is possible to access usb module here.
1551 	 * Don't accesses to it.
1552 	 * The accesse will be enable after "usbhsh_start"
1553 	 */
1554 
1555 	hpriv = usbhsh_hcd_to_hpriv(hcd);
1556 
1557 	/*
1558 	 * register itself
1559 	 */
1560 	usbhs_mod_register(priv, &hpriv->mod, USBHS_HOST);
1561 
1562 	/* init hpriv */
1563 	hpriv->mod.name		= "host";
1564 	hpriv->mod.start	= usbhsh_start;
1565 	hpriv->mod.stop		= usbhsh_stop;
1566 	usbhsh_port_stat_init(hpriv);
1567 
1568 	/* init all device */
1569 	usbhsh_for_each_udev_with_dev0(udev, hpriv, i) {
1570 		udev->usbv	= NULL;
1571 		INIT_LIST_HEAD(&udev->ep_list_head);
1572 	}
1573 
1574 	dev_info(dev, "host probed\n");
1575 
1576 	return 0;
1577 }
1578 
1579 int usbhs_mod_host_remove(struct usbhs_priv *priv)
1580 {
1581 	struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1582 	struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1583 
1584 	usb_put_hcd(hcd);
1585 
1586 	return 0;
1587 }
1588