xref: /openbmc/linux/drivers/usb/host/isp116x-hcd.c (revision 22246614)
1 /*
2  * ISP116x HCD (Host Controller Driver) for USB.
3  *
4  * Derived from the SL811 HCD, rewritten for ISP116x.
5  * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
6  *
7  * Portions:
8  * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
9  * Copyright (C) 2004 David Brownell
10  *
11  * Periodic scheduling is based on Roman's OHCI code
12  * Copyright (C) 1999 Roman Weissgaerber
13  *
14  */
15 
16 /*
17  * The driver basically works. A number of people have used it with a range
18  * of devices.
19  *
20  * The driver passes all usbtests 1-14.
21  *
22  * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
23  * And suspending/resuming of platform device works too. Suspend/resume
24  * via HCD operations vector is not implemented.
25  *
26  * Iso transfer support is not implemented. Adding this would include
27  * implementing recovery from the failure to service the processed ITL
28  * fifo ram in time, which will involve chip reset.
29  *
30  * TODO:
31  + More testing of suspend/resume.
32 */
33 
34 /*
35   ISP116x chips require certain delays between accesses to its
36   registers. The following timing options exist.
37 
38   1. Configure your memory controller (the best)
39   2. Implement platform-specific delay function possibly
40   combined with configuring the memory controller; see
41   include/linux/usb-isp116x.h for more info. Some broken
42   memory controllers line LH7A400 SMC need this. Also,
43   uncomment for that to work the following
44   USE_PLATFORM_DELAY macro.
45   3. Use ndelay (easiest, poorest). For that, uncomment
46   the following USE_NDELAY macro.
47 */
48 #define USE_PLATFORM_DELAY
49 //#define USE_NDELAY
50 
51 //#define DEBUG
52 //#define VERBOSE
53 /* Transfer descriptors. See dump_ptd() for printout format  */
54 //#define PTD_TRACE
55 /* enqueuing/finishing log of urbs */
56 //#define URB_TRACE
57 
58 #include <linux/module.h>
59 #include <linux/delay.h>
60 #include <linux/debugfs.h>
61 #include <linux/seq_file.h>
62 #include <linux/errno.h>
63 #include <linux/init.h>
64 #include <linux/list.h>
65 #include <linux/usb.h>
66 #include <linux/usb/isp116x.h>
67 #include <linux/platform_device.h>
68 
69 #include <asm/io.h>
70 #include <asm/irq.h>
71 #include <asm/system.h>
72 #include <asm/byteorder.h>
73 
74 #include "../core/hcd.h"
75 #include "isp116x.h"
76 
77 #define DRIVER_VERSION	"03 Nov 2005"
78 #define DRIVER_DESC	"ISP116x USB Host Controller Driver"
79 
80 MODULE_DESCRIPTION(DRIVER_DESC);
81 MODULE_LICENSE("GPL");
82 
83 static const char hcd_name[] = "isp116x-hcd";
84 
85 /*-----------------------------------------------------------------*/
86 
87 /*
88   Write len bytes to fifo, pad till 32-bit boundary
89  */
90 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
91 {
92 	u8 *dp = (u8 *) buf;
93 	u16 *dp2 = (u16 *) buf;
94 	u16 w;
95 	int quot = len % 4;
96 
97 	if ((unsigned long)dp2 & 1) {
98 		/* not aligned */
99 		for (; len > 1; len -= 2) {
100 			w = *dp++;
101 			w |= *dp++ << 8;
102 			isp116x_raw_write_data16(isp116x, w);
103 		}
104 		if (len)
105 			isp116x_write_data16(isp116x, (u16) * dp);
106 	} else {
107 		/* aligned */
108 		for (; len > 1; len -= 2)
109 			isp116x_raw_write_data16(isp116x, *dp2++);
110 		if (len)
111 			isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
112 	}
113 	if (quot == 1 || quot == 2)
114 		isp116x_raw_write_data16(isp116x, 0);
115 }
116 
117 /*
118   Read len bytes from fifo and then read till 32-bit boundary.
119  */
120 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
121 {
122 	u8 *dp = (u8 *) buf;
123 	u16 *dp2 = (u16 *) buf;
124 	u16 w;
125 	int quot = len % 4;
126 
127 	if ((unsigned long)dp2 & 1) {
128 		/* not aligned */
129 		for (; len > 1; len -= 2) {
130 			w = isp116x_raw_read_data16(isp116x);
131 			*dp++ = w & 0xff;
132 			*dp++ = (w >> 8) & 0xff;
133 		}
134 		if (len)
135 			*dp = 0xff & isp116x_read_data16(isp116x);
136 	} else {
137 		/* aligned */
138 		for (; len > 1; len -= 2)
139 			*dp2++ = isp116x_raw_read_data16(isp116x);
140 		if (len)
141 			*(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
142 	}
143 	if (quot == 1 || quot == 2)
144 		isp116x_raw_read_data16(isp116x);
145 }
146 
147 /*
148   Write ptd's and data for scheduled transfers into
149   the fifo ram. Fifo must be empty and ready.
150 */
151 static void pack_fifo(struct isp116x *isp116x)
152 {
153 	struct isp116x_ep *ep;
154 	struct ptd *ptd;
155 	int buflen = isp116x->atl_last_dir == PTD_DIR_IN
156 	    ? isp116x->atl_bufshrt : isp116x->atl_buflen;
157 
158 	isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
159 	isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
160 	isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
161 	for (ep = isp116x->atl_active; ep; ep = ep->active) {
162 		ptd = &ep->ptd;
163 		dump_ptd(ptd);
164 		dump_ptd_out_data(ptd, ep->data);
165 		isp116x_write_data16(isp116x, ptd->count);
166 		isp116x_write_data16(isp116x, ptd->mps);
167 		isp116x_write_data16(isp116x, ptd->len);
168 		isp116x_write_data16(isp116x, ptd->faddr);
169 		buflen -= sizeof(struct ptd);
170 		/* Skip writing data for last IN PTD */
171 		if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
172 			write_ptddata_to_fifo(isp116x, ep->data, ep->length);
173 			buflen -= ALIGN(ep->length, 4);
174 		}
175 	}
176 	BUG_ON(buflen);
177 }
178 
179 /*
180   Read the processed ptd's and data from fifo ram back to
181   URBs' buffers. Fifo must be full and done
182 */
183 static void unpack_fifo(struct isp116x *isp116x)
184 {
185 	struct isp116x_ep *ep;
186 	struct ptd *ptd;
187 	int buflen = isp116x->atl_last_dir == PTD_DIR_IN
188 	    ? isp116x->atl_buflen : isp116x->atl_bufshrt;
189 
190 	isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
191 	isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
192 	isp116x_write_addr(isp116x, HCATLPORT);
193 	for (ep = isp116x->atl_active; ep; ep = ep->active) {
194 		ptd = &ep->ptd;
195 		ptd->count = isp116x_read_data16(isp116x);
196 		ptd->mps = isp116x_read_data16(isp116x);
197 		ptd->len = isp116x_read_data16(isp116x);
198 		ptd->faddr = isp116x_read_data16(isp116x);
199 		buflen -= sizeof(struct ptd);
200 		/* Skip reading data for last Setup or Out PTD */
201 		if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
202 			read_ptddata_from_fifo(isp116x, ep->data, ep->length);
203 			buflen -= ALIGN(ep->length, 4);
204 		}
205 		dump_ptd(ptd);
206 		dump_ptd_in_data(ptd, ep->data);
207 	}
208 	BUG_ON(buflen);
209 }
210 
211 /*---------------------------------------------------------------*/
212 
213 /*
214   Set up PTD's.
215 */
216 static void preproc_atl_queue(struct isp116x *isp116x)
217 {
218 	struct isp116x_ep *ep;
219 	struct urb *urb;
220 	struct ptd *ptd;
221 	u16 len;
222 
223 	for (ep = isp116x->atl_active; ep; ep = ep->active) {
224 		u16 toggle = 0, dir = PTD_DIR_SETUP;
225 
226 		BUG_ON(list_empty(&ep->hep->urb_list));
227 		urb = container_of(ep->hep->urb_list.next,
228 				   struct urb, urb_list);
229 		ptd = &ep->ptd;
230 		len = ep->length;
231 		ep->data = (unsigned char *)urb->transfer_buffer
232 		    + urb->actual_length;
233 
234 		switch (ep->nextpid) {
235 		case USB_PID_IN:
236 			toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
237 			dir = PTD_DIR_IN;
238 			break;
239 		case USB_PID_OUT:
240 			toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
241 			dir = PTD_DIR_OUT;
242 			break;
243 		case USB_PID_SETUP:
244 			len = sizeof(struct usb_ctrlrequest);
245 			ep->data = urb->setup_packet;
246 			break;
247 		case USB_PID_ACK:
248 			toggle = 1;
249 			len = 0;
250 			dir = (urb->transfer_buffer_length
251 			       && usb_pipein(urb->pipe))
252 			    ? PTD_DIR_OUT : PTD_DIR_IN;
253 			break;
254 		default:
255 			ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
256 			    ep->nextpid);
257 			BUG();
258 		}
259 
260 		ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
261 		ptd->mps = PTD_MPS(ep->maxpacket)
262 		    | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
263 		    | PTD_EP(ep->epnum);
264 		ptd->len = PTD_LEN(len) | PTD_DIR(dir);
265 		ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
266 		if (!ep->active) {
267 			ptd->mps |= PTD_LAST_MSK;
268 			isp116x->atl_last_dir = dir;
269 		}
270 		isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
271 		isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
272 	}
273 }
274 
275 /*
276   Take done or failed requests out of schedule. Give back
277   processed urbs.
278 */
279 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
280 			   struct urb *urb, int status)
281 __releases(isp116x->lock) __acquires(isp116x->lock)
282 {
283 	unsigned i;
284 
285 	ep->error_count = 0;
286 
287 	if (usb_pipecontrol(urb->pipe))
288 		ep->nextpid = USB_PID_SETUP;
289 
290 	urb_dbg(urb, "Finish");
291 
292 	usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
293 	spin_unlock(&isp116x->lock);
294 	usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
295 	spin_lock(&isp116x->lock);
296 
297 	/* take idle endpoints out of the schedule */
298 	if (!list_empty(&ep->hep->urb_list))
299 		return;
300 
301 	/* async deschedule */
302 	if (!list_empty(&ep->schedule)) {
303 		list_del_init(&ep->schedule);
304 		return;
305 	}
306 
307 	/* periodic deschedule */
308 	DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
309 	for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
310 		struct isp116x_ep *temp;
311 		struct isp116x_ep **prev = &isp116x->periodic[i];
312 
313 		while (*prev && ((temp = *prev) != ep))
314 			prev = &temp->next;
315 		if (*prev)
316 			*prev = ep->next;
317 		isp116x->load[i] -= ep->load;
318 	}
319 	ep->branch = PERIODIC_SIZE;
320 	isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
321 	    ep->load / ep->period;
322 
323 	/* switch irq type? */
324 	if (!--isp116x->periodic_count) {
325 		isp116x->irqenb &= ~HCuPINT_SOF;
326 		isp116x->irqenb |= HCuPINT_ATL;
327 	}
328 }
329 
330 /*
331   Analyze transfer results, handle partial transfers and errors
332 */
333 static void postproc_atl_queue(struct isp116x *isp116x)
334 {
335 	struct isp116x_ep *ep;
336 	struct urb *urb;
337 	struct usb_device *udev;
338 	struct ptd *ptd;
339 	int short_not_ok;
340 	int status;
341 	u8 cc;
342 
343 	for (ep = isp116x->atl_active; ep; ep = ep->active) {
344 		BUG_ON(list_empty(&ep->hep->urb_list));
345 		urb =
346 		    container_of(ep->hep->urb_list.next, struct urb, urb_list);
347 		udev = urb->dev;
348 		ptd = &ep->ptd;
349 		cc = PTD_GET_CC(ptd);
350 		short_not_ok = 1;
351 		status = -EINPROGRESS;
352 
353 		/* Data underrun is special. For allowed underrun
354 		   we clear the error and continue as normal. For
355 		   forbidden underrun we finish the DATA stage
356 		   immediately while for control transfer,
357 		   we do a STATUS stage. */
358 		if (cc == TD_DATAUNDERRUN) {
359 			if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
360 					usb_pipecontrol(urb->pipe)) {
361 				DBG("Allowed or control data underrun\n");
362 				cc = TD_CC_NOERROR;
363 				short_not_ok = 0;
364 			} else {
365 				ep->error_count = 1;
366 				usb_settoggle(udev, ep->epnum,
367 					      ep->nextpid == USB_PID_OUT,
368 					      PTD_GET_TOGGLE(ptd));
369 				urb->actual_length += PTD_GET_COUNT(ptd);
370 				status = cc_to_error[TD_DATAUNDERRUN];
371 				goto done;
372 			}
373 		}
374 
375 		if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
376 		    && (++ep->error_count >= 3 || cc == TD_CC_STALL
377 			|| cc == TD_DATAOVERRUN)) {
378 			status = cc_to_error[cc];
379 			if (ep->nextpid == USB_PID_ACK)
380 				ep->nextpid = 0;
381 			goto done;
382 		}
383 		/* According to usb spec, zero-length Int transfer signals
384 		   finishing of the urb. Hey, does this apply only
385 		   for IN endpoints? */
386 		if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
387 			status = 0;
388 			goto done;
389 		}
390 
391 		/* Relax after previously failed, but later succeeded
392 		   or correctly NAK'ed retransmission attempt */
393 		if (ep->error_count
394 		    && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
395 			ep->error_count = 0;
396 
397 		/* Take into account idiosyncracies of the isp116x chip
398 		   regarding toggle bit for failed transfers */
399 		if (ep->nextpid == USB_PID_OUT)
400 			usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
401 				      ^ (ep->error_count > 0));
402 		else if (ep->nextpid == USB_PID_IN)
403 			usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
404 				      ^ (ep->error_count > 0));
405 
406 		switch (ep->nextpid) {
407 		case USB_PID_IN:
408 		case USB_PID_OUT:
409 			urb->actual_length += PTD_GET_COUNT(ptd);
410 			if (PTD_GET_ACTIVE(ptd)
411 			    || (cc != TD_CC_NOERROR && cc < 0x0E))
412 				break;
413 			if (urb->transfer_buffer_length != urb->actual_length) {
414 				if (short_not_ok)
415 					break;
416 			} else {
417 				if (urb->transfer_flags & URB_ZERO_PACKET
418 				    && ep->nextpid == USB_PID_OUT
419 				    && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
420 					DBG("Zero packet requested\n");
421 					break;
422 				}
423 			}
424 			/* All data for this URB is transferred, let's finish */
425 			if (usb_pipecontrol(urb->pipe))
426 				ep->nextpid = USB_PID_ACK;
427 			else
428 				status = 0;
429 			break;
430 		case USB_PID_SETUP:
431 			if (PTD_GET_ACTIVE(ptd)
432 			    || (cc != TD_CC_NOERROR && cc < 0x0E))
433 				break;
434 			if (urb->transfer_buffer_length == urb->actual_length)
435 				ep->nextpid = USB_PID_ACK;
436 			else if (usb_pipeout(urb->pipe)) {
437 				usb_settoggle(udev, 0, 1, 1);
438 				ep->nextpid = USB_PID_OUT;
439 			} else {
440 				usb_settoggle(udev, 0, 0, 1);
441 				ep->nextpid = USB_PID_IN;
442 			}
443 			break;
444 		case USB_PID_ACK:
445 			if (PTD_GET_ACTIVE(ptd)
446 			    || (cc != TD_CC_NOERROR && cc < 0x0E))
447 				break;
448 			status = 0;
449 			ep->nextpid = 0;
450 			break;
451 		default:
452 			BUG();
453 		}
454 
455  done:
456 		if (status != -EINPROGRESS || urb->unlinked)
457 			finish_request(isp116x, ep, urb, status);
458 	}
459 }
460 
461 /*
462   Scan transfer lists, schedule transfers, send data off
463   to chip.
464  */
465 static void start_atl_transfers(struct isp116x *isp116x)
466 {
467 	struct isp116x_ep *last_ep = NULL, *ep;
468 	struct urb *urb;
469 	u16 load = 0;
470 	int len, index, speed, byte_time;
471 
472 	if (atomic_read(&isp116x->atl_finishing))
473 		return;
474 
475 	if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
476 		return;
477 
478 	/* FIFO not empty? */
479 	if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
480 		return;
481 
482 	isp116x->atl_active = NULL;
483 	isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
484 
485 	/* Schedule int transfers */
486 	if (isp116x->periodic_count) {
487 		isp116x->fmindex = index =
488 		    (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
489 		if ((load = isp116x->load[index])) {
490 			/* Bring all int transfers for this frame
491 			   into the active queue */
492 			isp116x->atl_active = last_ep =
493 			    isp116x->periodic[index];
494 			while (last_ep->next)
495 				last_ep = (last_ep->active = last_ep->next);
496 			last_ep->active = NULL;
497 		}
498 	}
499 
500 	/* Schedule control/bulk transfers */
501 	list_for_each_entry(ep, &isp116x->async, schedule) {
502 		urb = container_of(ep->hep->urb_list.next,
503 				   struct urb, urb_list);
504 		speed = urb->dev->speed;
505 		byte_time = speed == USB_SPEED_LOW
506 		    ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
507 
508 		if (ep->nextpid == USB_PID_SETUP) {
509 			len = sizeof(struct usb_ctrlrequest);
510 		} else if (ep->nextpid == USB_PID_ACK) {
511 			len = 0;
512 		} else {
513 			/* Find current free length ... */
514 			len = (MAX_LOAD_LIMIT - load) / byte_time;
515 
516 			/* ... then limit it to configured max size ... */
517 			len = min(len, speed == USB_SPEED_LOW ?
518 				  MAX_TRANSFER_SIZE_LOWSPEED :
519 				  MAX_TRANSFER_SIZE_FULLSPEED);
520 
521 			/* ... and finally cut to the multiple of MaxPacketSize,
522 			   or to the real length if there's enough room. */
523 			if (len <
524 			    (urb->transfer_buffer_length -
525 			     urb->actual_length)) {
526 				len -= len % ep->maxpacket;
527 				if (!len)
528 					continue;
529 			} else
530 				len = urb->transfer_buffer_length -
531 				    urb->actual_length;
532 			BUG_ON(len < 0);
533 		}
534 
535 		load += len * byte_time;
536 		if (load > MAX_LOAD_LIMIT)
537 			break;
538 
539 		ep->active = NULL;
540 		ep->length = len;
541 		if (last_ep)
542 			last_ep->active = ep;
543 		else
544 			isp116x->atl_active = ep;
545 		last_ep = ep;
546 	}
547 
548 	/* Avoid starving of endpoints */
549 	if ((&isp116x->async)->next != (&isp116x->async)->prev)
550 		list_move(&isp116x->async, (&isp116x->async)->next);
551 
552 	if (isp116x->atl_active) {
553 		preproc_atl_queue(isp116x);
554 		pack_fifo(isp116x);
555 	}
556 }
557 
558 /*
559   Finish the processed transfers
560 */
561 static void finish_atl_transfers(struct isp116x *isp116x)
562 {
563 	if (!isp116x->atl_active)
564 		return;
565 	/* Fifo not ready? */
566 	if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
567 		return;
568 
569 	atomic_inc(&isp116x->atl_finishing);
570 	unpack_fifo(isp116x);
571 	postproc_atl_queue(isp116x);
572 	atomic_dec(&isp116x->atl_finishing);
573 }
574 
575 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
576 {
577 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
578 	u16 irqstat;
579 	irqreturn_t ret = IRQ_NONE;
580 
581 	spin_lock(&isp116x->lock);
582 	isp116x_write_reg16(isp116x, HCuPINTENB, 0);
583 	irqstat = isp116x_read_reg16(isp116x, HCuPINT);
584 	isp116x_write_reg16(isp116x, HCuPINT, irqstat);
585 
586 	if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
587 		ret = IRQ_HANDLED;
588 		finish_atl_transfers(isp116x);
589 	}
590 
591 	if (irqstat & HCuPINT_OPR) {
592 		u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
593 		isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
594 		if (intstat & HCINT_UE) {
595 			ERR("Unrecoverable error, HC is dead!\n");
596 			/* IRQ's are off, we do no DMA,
597 			   perfectly ready to die ... */
598 			hcd->state = HC_STATE_HALT;
599 			ret = IRQ_HANDLED;
600 			goto done;
601 		}
602 		if (intstat & HCINT_RHSC)
603 			/* When root hub or any of its ports is going
604 			   to come out of suspend, it may take more
605 			   than 10ms for status bits to stabilize. */
606 			mod_timer(&hcd->rh_timer, jiffies
607 				  + msecs_to_jiffies(20) + 1);
608 		if (intstat & HCINT_RD) {
609 			DBG("---- remote wakeup\n");
610 			usb_hcd_resume_root_hub(hcd);
611 		}
612 		irqstat &= ~HCuPINT_OPR;
613 		ret = IRQ_HANDLED;
614 	}
615 
616 	if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
617 		start_atl_transfers(isp116x);
618 	}
619 
620 	isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
621       done:
622 	spin_unlock(&isp116x->lock);
623 	return ret;
624 }
625 
626 /*-----------------------------------------------------------------*/
627 
628 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
629  * this driver doesn't promise that much since it's got to handle an
630  * IRQ per packet; irq handling latencies also use up that time.
631  */
632 
633 /* out of 1000 us */
634 #define	MAX_PERIODIC_LOAD	600
635 static int balance(struct isp116x *isp116x, u16 period, u16 load)
636 {
637 	int i, branch = -ENOSPC;
638 
639 	/* search for the least loaded schedule branch of that period
640 	   which has enough bandwidth left unreserved. */
641 	for (i = 0; i < period; i++) {
642 		if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
643 			int j;
644 
645 			for (j = i; j < PERIODIC_SIZE; j += period) {
646 				if ((isp116x->load[j] + load)
647 				    > MAX_PERIODIC_LOAD)
648 					break;
649 			}
650 			if (j < PERIODIC_SIZE)
651 				continue;
652 			branch = i;
653 		}
654 	}
655 	return branch;
656 }
657 
658 /* NB! ALL the code above this point runs with isp116x->lock
659    held, irqs off
660 */
661 
662 /*-----------------------------------------------------------------*/
663 
664 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
665 			       struct urb *urb,
666 			       gfp_t mem_flags)
667 {
668 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
669 	struct usb_device *udev = urb->dev;
670 	unsigned int pipe = urb->pipe;
671 	int is_out = !usb_pipein(pipe);
672 	int type = usb_pipetype(pipe);
673 	int epnum = usb_pipeendpoint(pipe);
674 	struct usb_host_endpoint *hep = urb->ep;
675 	struct isp116x_ep *ep = NULL;
676 	unsigned long flags;
677 	int i;
678 	int ret = 0;
679 
680 	urb_dbg(urb, "Enqueue");
681 
682 	if (type == PIPE_ISOCHRONOUS) {
683 		ERR("Isochronous transfers not supported\n");
684 		urb_dbg(urb, "Refused to enqueue");
685 		return -ENXIO;
686 	}
687 	/* avoid all allocations within spinlocks: request or endpoint */
688 	if (!hep->hcpriv) {
689 		ep = kzalloc(sizeof *ep, mem_flags);
690 		if (!ep)
691 			return -ENOMEM;
692 	}
693 
694 	spin_lock_irqsave(&isp116x->lock, flags);
695 	if (!HC_IS_RUNNING(hcd->state)) {
696 		kfree(ep);
697 		ret = -ENODEV;
698 		goto fail_not_linked;
699 	}
700 	ret = usb_hcd_link_urb_to_ep(hcd, urb);
701 	if (ret) {
702 		kfree(ep);
703 		goto fail_not_linked;
704 	}
705 
706 	if (hep->hcpriv)
707 		ep = hep->hcpriv;
708 	else {
709 		INIT_LIST_HEAD(&ep->schedule);
710 		ep->udev = udev;
711 		ep->epnum = epnum;
712 		ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
713 		usb_settoggle(udev, epnum, is_out, 0);
714 
715 		if (type == PIPE_CONTROL) {
716 			ep->nextpid = USB_PID_SETUP;
717 		} else if (is_out) {
718 			ep->nextpid = USB_PID_OUT;
719 		} else {
720 			ep->nextpid = USB_PID_IN;
721 		}
722 
723 		if (urb->interval) {
724 			/*
725 			   With INT URBs submitted, the driver works with SOF
726 			   interrupt enabled and ATL interrupt disabled. After
727 			   the PTDs are written to fifo ram, the chip starts
728 			   fifo processing and usb transfers after the next
729 			   SOF and continues until the transfers are finished
730 			   (succeeded or failed) or the frame ends. Therefore,
731 			   the transfers occur only in every second frame,
732 			   while fifo reading/writing and data processing
733 			   occur in every other second frame. */
734 			if (urb->interval < 2)
735 				urb->interval = 2;
736 			if (urb->interval > 2 * PERIODIC_SIZE)
737 				urb->interval = 2 * PERIODIC_SIZE;
738 			ep->period = urb->interval >> 1;
739 			ep->branch = PERIODIC_SIZE;
740 			ep->load = usb_calc_bus_time(udev->speed,
741 						     !is_out,
742 						     (type == PIPE_ISOCHRONOUS),
743 						     usb_maxpacket(udev, pipe,
744 								   is_out)) /
745 			    1000;
746 		}
747 		hep->hcpriv = ep;
748 		ep->hep = hep;
749 	}
750 
751 	/* maybe put endpoint into schedule */
752 	switch (type) {
753 	case PIPE_CONTROL:
754 	case PIPE_BULK:
755 		if (list_empty(&ep->schedule))
756 			list_add_tail(&ep->schedule, &isp116x->async);
757 		break;
758 	case PIPE_INTERRUPT:
759 		urb->interval = ep->period;
760 		ep->length = min((int)ep->maxpacket,
761 				 urb->transfer_buffer_length);
762 
763 		/* urb submitted for already existing endpoint */
764 		if (ep->branch < PERIODIC_SIZE)
765 			break;
766 
767 		ep->branch = ret = balance(isp116x, ep->period, ep->load);
768 		if (ret < 0)
769 			goto fail;
770 		ret = 0;
771 
772 		urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
773 		    + ep->branch;
774 
775 		/* sort each schedule branch by period (slow before fast)
776 		   to share the faster parts of the tree without needing
777 		   dummy/placeholder nodes */
778 		DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
779 		for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
780 			struct isp116x_ep **prev = &isp116x->periodic[i];
781 			struct isp116x_ep *here = *prev;
782 
783 			while (here && ep != here) {
784 				if (ep->period > here->period)
785 					break;
786 				prev = &here->next;
787 				here = *prev;
788 			}
789 			if (ep != here) {
790 				ep->next = here;
791 				*prev = ep;
792 			}
793 			isp116x->load[i] += ep->load;
794 		}
795 		hcd->self.bandwidth_allocated += ep->load / ep->period;
796 
797 		/* switch over to SOFint */
798 		if (!isp116x->periodic_count++) {
799 			isp116x->irqenb &= ~HCuPINT_ATL;
800 			isp116x->irqenb |= HCuPINT_SOF;
801 			isp116x_write_reg16(isp116x, HCuPINTENB,
802 					    isp116x->irqenb);
803 		}
804 	}
805 
806 	urb->hcpriv = hep;
807 	start_atl_transfers(isp116x);
808 
809       fail:
810 	if (ret)
811 		usb_hcd_unlink_urb_from_ep(hcd, urb);
812       fail_not_linked:
813 	spin_unlock_irqrestore(&isp116x->lock, flags);
814 	return ret;
815 }
816 
817 /*
818    Dequeue URBs.
819 */
820 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
821 		int status)
822 {
823 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
824 	struct usb_host_endpoint *hep;
825 	struct isp116x_ep *ep, *ep_act;
826 	unsigned long flags;
827 	int rc;
828 
829 	spin_lock_irqsave(&isp116x->lock, flags);
830 	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
831 	if (rc)
832 		goto done;
833 
834 	hep = urb->hcpriv;
835 	ep = hep->hcpriv;
836 	WARN_ON(hep != ep->hep);
837 
838 	/* In front of queue? */
839 	if (ep->hep->urb_list.next == &urb->urb_list)
840 		/* active? */
841 		for (ep_act = isp116x->atl_active; ep_act;
842 		     ep_act = ep_act->active)
843 			if (ep_act == ep) {
844 				VDBG("dequeue, urb %p active; wait for irq\n",
845 				     urb);
846 				urb = NULL;
847 				break;
848 			}
849 
850 	if (urb)
851 		finish_request(isp116x, ep, urb, status);
852  done:
853 	spin_unlock_irqrestore(&isp116x->lock, flags);
854 	return rc;
855 }
856 
857 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
858 				     struct usb_host_endpoint *hep)
859 {
860 	int i;
861 	struct isp116x_ep *ep = hep->hcpriv;
862 
863 	if (!ep)
864 		return;
865 
866 	/* assume we'd just wait for the irq */
867 	for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
868 		msleep(3);
869 	if (!list_empty(&hep->urb_list))
870 		WARN("ep %p not empty?\n", ep);
871 
872 	kfree(ep);
873 	hep->hcpriv = NULL;
874 }
875 
876 static int isp116x_get_frame(struct usb_hcd *hcd)
877 {
878 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
879 	u32 fmnum;
880 	unsigned long flags;
881 
882 	spin_lock_irqsave(&isp116x->lock, flags);
883 	fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
884 	spin_unlock_irqrestore(&isp116x->lock, flags);
885 	return (int)fmnum;
886 }
887 
888 /*
889   Adapted from ohci-hub.c. Currently we don't support autosuspend.
890 */
891 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
892 {
893 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
894 	int ports, i, changed = 0;
895 	unsigned long flags;
896 
897 	if (!HC_IS_RUNNING(hcd->state))
898 		return -ESHUTDOWN;
899 
900 	/* Report no status change now, if we are scheduled to be
901 	   called later */
902 	if (timer_pending(&hcd->rh_timer))
903 		return 0;
904 
905 	ports = isp116x->rhdesca & RH_A_NDP;
906 	spin_lock_irqsave(&isp116x->lock, flags);
907 	isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
908 	if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
909 		buf[0] = changed = 1;
910 	else
911 		buf[0] = 0;
912 
913 	for (i = 0; i < ports; i++) {
914 		u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
915 
916 		if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
917 			      | RH_PS_OCIC | RH_PS_PRSC)) {
918 			changed = 1;
919 			buf[0] |= 1 << (i + 1);
920 		}
921 	}
922 	spin_unlock_irqrestore(&isp116x->lock, flags);
923 	return changed;
924 }
925 
926 static void isp116x_hub_descriptor(struct isp116x *isp116x,
927 				   struct usb_hub_descriptor *desc)
928 {
929 	u32 reg = isp116x->rhdesca;
930 
931 	desc->bDescriptorType = 0x29;
932 	desc->bDescLength = 9;
933 	desc->bHubContrCurrent = 0;
934 	desc->bNbrPorts = (u8) (reg & 0x3);
935 	/* Power switching, device type, overcurrent. */
936 	desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
937 	desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
938 	/* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
939 	desc->bitmap[0] = 0;
940 	desc->bitmap[1] = ~0;
941 }
942 
943 /* Perform reset of a given port.
944    It would be great to just start the reset and let the
945    USB core to clear the reset in due time. However,
946    root hub ports should be reset for at least 50 ms, while
947    our chip stays in reset for about 10 ms. I.e., we must
948    repeatedly reset it ourself here.
949 */
950 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
951 {
952 	u32 tmp;
953 	unsigned long flags, t;
954 
955 	/* Root hub reset should be 50 ms, but some devices
956 	   want it even longer. */
957 	t = jiffies + msecs_to_jiffies(100);
958 
959 	while (time_before(jiffies, t)) {
960 		spin_lock_irqsave(&isp116x->lock, flags);
961 		/* spin until any current reset finishes */
962 		for (;;) {
963 			tmp = isp116x_read_reg32(isp116x, port ?
964 						 HCRHPORT2 : HCRHPORT1);
965 			if (!(tmp & RH_PS_PRS))
966 				break;
967 			udelay(500);
968 		}
969 		/* Don't reset a disconnected port */
970 		if (!(tmp & RH_PS_CCS)) {
971 			spin_unlock_irqrestore(&isp116x->lock, flags);
972 			break;
973 		}
974 		/* Reset lasts 10ms (claims datasheet) */
975 		isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
976 				    HCRHPORT1, (RH_PS_PRS));
977 		spin_unlock_irqrestore(&isp116x->lock, flags);
978 		msleep(10);
979 	}
980 }
981 
982 /* Adapted from ohci-hub.c */
983 static int isp116x_hub_control(struct usb_hcd *hcd,
984 			       u16 typeReq,
985 			       u16 wValue, u16 wIndex, char *buf, u16 wLength)
986 {
987 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
988 	int ret = 0;
989 	unsigned long flags;
990 	int ports = isp116x->rhdesca & RH_A_NDP;
991 	u32 tmp = 0;
992 
993 	switch (typeReq) {
994 	case ClearHubFeature:
995 		DBG("ClearHubFeature: ");
996 		switch (wValue) {
997 		case C_HUB_OVER_CURRENT:
998 			DBG("C_HUB_OVER_CURRENT\n");
999 			spin_lock_irqsave(&isp116x->lock, flags);
1000 			isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1001 			spin_unlock_irqrestore(&isp116x->lock, flags);
1002 		case C_HUB_LOCAL_POWER:
1003 			DBG("C_HUB_LOCAL_POWER\n");
1004 			break;
1005 		default:
1006 			goto error;
1007 		}
1008 		break;
1009 	case SetHubFeature:
1010 		DBG("SetHubFeature: ");
1011 		switch (wValue) {
1012 		case C_HUB_OVER_CURRENT:
1013 		case C_HUB_LOCAL_POWER:
1014 			DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1015 			break;
1016 		default:
1017 			goto error;
1018 		}
1019 		break;
1020 	case GetHubDescriptor:
1021 		DBG("GetHubDescriptor\n");
1022 		isp116x_hub_descriptor(isp116x,
1023 				       (struct usb_hub_descriptor *)buf);
1024 		break;
1025 	case GetHubStatus:
1026 		DBG("GetHubStatus\n");
1027 		*(__le32 *) buf = 0;
1028 		break;
1029 	case GetPortStatus:
1030 		DBG("GetPortStatus\n");
1031 		if (!wIndex || wIndex > ports)
1032 			goto error;
1033 		spin_lock_irqsave(&isp116x->lock, flags);
1034 		tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1035 		spin_unlock_irqrestore(&isp116x->lock, flags);
1036 		*(__le32 *) buf = cpu_to_le32(tmp);
1037 		DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1038 		break;
1039 	case ClearPortFeature:
1040 		DBG("ClearPortFeature: ");
1041 		if (!wIndex || wIndex > ports)
1042 			goto error;
1043 		wIndex--;
1044 
1045 		switch (wValue) {
1046 		case USB_PORT_FEAT_ENABLE:
1047 			DBG("USB_PORT_FEAT_ENABLE\n");
1048 			tmp = RH_PS_CCS;
1049 			break;
1050 		case USB_PORT_FEAT_C_ENABLE:
1051 			DBG("USB_PORT_FEAT_C_ENABLE\n");
1052 			tmp = RH_PS_PESC;
1053 			break;
1054 		case USB_PORT_FEAT_SUSPEND:
1055 			DBG("USB_PORT_FEAT_SUSPEND\n");
1056 			tmp = RH_PS_POCI;
1057 			break;
1058 		case USB_PORT_FEAT_C_SUSPEND:
1059 			DBG("USB_PORT_FEAT_C_SUSPEND\n");
1060 			tmp = RH_PS_PSSC;
1061 			break;
1062 		case USB_PORT_FEAT_POWER:
1063 			DBG("USB_PORT_FEAT_POWER\n");
1064 			tmp = RH_PS_LSDA;
1065 			break;
1066 		case USB_PORT_FEAT_C_CONNECTION:
1067 			DBG("USB_PORT_FEAT_C_CONNECTION\n");
1068 			tmp = RH_PS_CSC;
1069 			break;
1070 		case USB_PORT_FEAT_C_OVER_CURRENT:
1071 			DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1072 			tmp = RH_PS_OCIC;
1073 			break;
1074 		case USB_PORT_FEAT_C_RESET:
1075 			DBG("USB_PORT_FEAT_C_RESET\n");
1076 			tmp = RH_PS_PRSC;
1077 			break;
1078 		default:
1079 			goto error;
1080 		}
1081 		spin_lock_irqsave(&isp116x->lock, flags);
1082 		isp116x_write_reg32(isp116x, wIndex
1083 				    ? HCRHPORT2 : HCRHPORT1, tmp);
1084 		spin_unlock_irqrestore(&isp116x->lock, flags);
1085 		break;
1086 	case SetPortFeature:
1087 		DBG("SetPortFeature: ");
1088 		if (!wIndex || wIndex > ports)
1089 			goto error;
1090 		wIndex--;
1091 		switch (wValue) {
1092 		case USB_PORT_FEAT_SUSPEND:
1093 			DBG("USB_PORT_FEAT_SUSPEND\n");
1094 			spin_lock_irqsave(&isp116x->lock, flags);
1095 			isp116x_write_reg32(isp116x, wIndex
1096 					    ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1097 			spin_unlock_irqrestore(&isp116x->lock, flags);
1098 			break;
1099 		case USB_PORT_FEAT_POWER:
1100 			DBG("USB_PORT_FEAT_POWER\n");
1101 			spin_lock_irqsave(&isp116x->lock, flags);
1102 			isp116x_write_reg32(isp116x, wIndex
1103 					    ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1104 			spin_unlock_irqrestore(&isp116x->lock, flags);
1105 			break;
1106 		case USB_PORT_FEAT_RESET:
1107 			DBG("USB_PORT_FEAT_RESET\n");
1108 			root_port_reset(isp116x, wIndex);
1109 			break;
1110 		default:
1111 			goto error;
1112 		}
1113 		break;
1114 
1115 	default:
1116 	      error:
1117 		/* "protocol stall" on error */
1118 		DBG("PROTOCOL STALL\n");
1119 		ret = -EPIPE;
1120 	}
1121 	return ret;
1122 }
1123 
1124 /*-----------------------------------------------------------------*/
1125 
1126 #ifdef CONFIG_DEBUG_FS
1127 
1128 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1129 {
1130 	seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1131 		   mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1132 		   mask & HCuPINT_SUSP ? " susp" : "",
1133 		   mask & HCuPINT_OPR ? " opr" : "",
1134 		   mask & HCuPINT_AIIEOT ? " eot" : "",
1135 		   mask & HCuPINT_ATL ? " atl" : "",
1136 		   mask & HCuPINT_SOF ? " sof" : "");
1137 }
1138 
1139 static void dump_int(struct seq_file *s, char *label, u32 mask)
1140 {
1141 	seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1142 		   mask & HCINT_MIE ? " MIE" : "",
1143 		   mask & HCINT_RHSC ? " rhsc" : "",
1144 		   mask & HCINT_FNO ? " fno" : "",
1145 		   mask & HCINT_UE ? " ue" : "",
1146 		   mask & HCINT_RD ? " rd" : "",
1147 		   mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1148 }
1149 
1150 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1151 {
1152 	struct isp116x *isp116x = s->private;
1153 
1154 	seq_printf(s, "%s\n%s version %s\n",
1155 		   isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1156 		   DRIVER_VERSION);
1157 
1158 	if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1159 		seq_printf(s, "HCD is suspended\n");
1160 		return 0;
1161 	}
1162 	if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1163 		seq_printf(s, "HCD not running\n");
1164 		return 0;
1165 	}
1166 
1167 	spin_lock_irq(&isp116x->lock);
1168 	dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1169 	dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1170 	dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1171 	dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1172 	isp116x_show_regs_seq(isp116x, s);
1173 	spin_unlock_irq(&isp116x->lock);
1174 	seq_printf(s, "\n");
1175 
1176 	return 0;
1177 }
1178 
1179 static int isp116x_open_seq(struct inode *inode, struct file *file)
1180 {
1181 	return single_open(file, isp116x_show_dbg, inode->i_private);
1182 }
1183 
1184 static const struct file_operations isp116x_debug_fops = {
1185 	.open = isp116x_open_seq,
1186 	.read = seq_read,
1187 	.llseek = seq_lseek,
1188 	.release = single_release,
1189 };
1190 
1191 static int create_debug_file(struct isp116x *isp116x)
1192 {
1193 	isp116x->dentry = debugfs_create_file(hcd_name,
1194 					      S_IRUGO, NULL, isp116x,
1195 					      &isp116x_debug_fops);
1196 	if (!isp116x->dentry)
1197 		return -ENOMEM;
1198 	return 0;
1199 }
1200 
1201 static void remove_debug_file(struct isp116x *isp116x)
1202 {
1203 	debugfs_remove(isp116x->dentry);
1204 }
1205 
1206 #else
1207 
1208 #define	create_debug_file(d)	0
1209 #define	remove_debug_file(d)	do{}while(0)
1210 
1211 #endif				/* CONFIG_DEBUG_FS */
1212 
1213 /*-----------------------------------------------------------------*/
1214 
1215 /*
1216   Software reset - can be called from any contect.
1217 */
1218 static int isp116x_sw_reset(struct isp116x *isp116x)
1219 {
1220 	int retries = 15;
1221 	unsigned long flags;
1222 	int ret = 0;
1223 
1224 	spin_lock_irqsave(&isp116x->lock, flags);
1225 	isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1226 	isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1227 	while (--retries) {
1228 		/* It usually resets within 1 ms */
1229 		mdelay(1);
1230 		if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1231 			break;
1232 	}
1233 	if (!retries) {
1234 		ERR("Software reset timeout\n");
1235 		ret = -ETIME;
1236 	}
1237 	spin_unlock_irqrestore(&isp116x->lock, flags);
1238 	return ret;
1239 }
1240 
1241 static int isp116x_reset(struct usb_hcd *hcd)
1242 {
1243 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1244 	unsigned long t;
1245 	u16 clkrdy = 0;
1246 	int ret, timeout = 15 /* ms */ ;
1247 
1248 	ret = isp116x_sw_reset(isp116x);
1249 	if (ret)
1250 		return ret;
1251 
1252 	t = jiffies + msecs_to_jiffies(timeout);
1253 	while (time_before_eq(jiffies, t)) {
1254 		msleep(4);
1255 		spin_lock_irq(&isp116x->lock);
1256 		clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1257 		spin_unlock_irq(&isp116x->lock);
1258 		if (clkrdy)
1259 			break;
1260 	}
1261 	if (!clkrdy) {
1262 		ERR("Clock not ready after %dms\n", timeout);
1263 		/* After sw_reset the clock won't report to be ready, if
1264 		   H_WAKEUP pin is high. */
1265 		ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1266 		ret = -ENODEV;
1267 	}
1268 	return ret;
1269 }
1270 
1271 static void isp116x_stop(struct usb_hcd *hcd)
1272 {
1273 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1274 	unsigned long flags;
1275 	u32 val;
1276 
1277 	spin_lock_irqsave(&isp116x->lock, flags);
1278 	isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1279 
1280 	/* Switch off ports' power, some devices don't come up
1281 	   after next 'insmod' without this */
1282 	val = isp116x_read_reg32(isp116x, HCRHDESCA);
1283 	val &= ~(RH_A_NPS | RH_A_PSM);
1284 	isp116x_write_reg32(isp116x, HCRHDESCA, val);
1285 	isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1286 	spin_unlock_irqrestore(&isp116x->lock, flags);
1287 
1288 	isp116x_sw_reset(isp116x);
1289 }
1290 
1291 /*
1292   Configure the chip. The chip must be successfully reset by now.
1293 */
1294 static int isp116x_start(struct usb_hcd *hcd)
1295 {
1296 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1297 	struct isp116x_platform_data *board = isp116x->board;
1298 	u32 val;
1299 	unsigned long flags;
1300 
1301 	spin_lock_irqsave(&isp116x->lock, flags);
1302 
1303 	/* clear interrupt status and disable all interrupt sources */
1304 	isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1305 	isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1306 
1307 	val = isp116x_read_reg16(isp116x, HCCHIPID);
1308 	if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1309 		ERR("Invalid chip ID %04x\n", val);
1310 		spin_unlock_irqrestore(&isp116x->lock, flags);
1311 		return -ENODEV;
1312 	}
1313 
1314 	/* To be removed in future */
1315 	hcd->uses_new_polling = 1;
1316 
1317 	isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1318 	isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1319 
1320 	/* ----- HW conf */
1321 	val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1322 	if (board->sel15Kres)
1323 		val |= HCHWCFG_15KRSEL;
1324 	/* Remote wakeup won't work without working clock */
1325 	if (board->remote_wakeup_enable)
1326 		val |= HCHWCFG_CLKNOTSTOP;
1327 	if (board->oc_enable)
1328 		val |= HCHWCFG_ANALOG_OC;
1329 	if (board->int_act_high)
1330 		val |= HCHWCFG_INT_POL;
1331 	if (board->int_edge_triggered)
1332 		val |= HCHWCFG_INT_TRIGGER;
1333 	isp116x_write_reg16(isp116x, HCHWCFG, val);
1334 
1335 	/* ----- Root hub conf */
1336 	val = (25 << 24) & RH_A_POTPGT;
1337 	/* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1338 	   be always set. Yet, instead, we request individual port
1339 	   power switching. */
1340 	val |= RH_A_PSM;
1341 	/* Report overcurrent per port */
1342 	val |= RH_A_OCPM;
1343 	isp116x_write_reg32(isp116x, HCRHDESCA, val);
1344 	isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1345 
1346 	val = RH_B_PPCM;
1347 	isp116x_write_reg32(isp116x, HCRHDESCB, val);
1348 	isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1349 
1350 	val = 0;
1351 	if (board->remote_wakeup_enable) {
1352 		if (!device_can_wakeup(hcd->self.controller))
1353 			device_init_wakeup(hcd->self.controller, 1);
1354 		val |= RH_HS_DRWE;
1355 	}
1356 	isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1357 	isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1358 
1359 	isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1360 
1361 	hcd->state = HC_STATE_RUNNING;
1362 
1363 	/* Set up interrupts */
1364 	isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1365 	if (board->remote_wakeup_enable)
1366 		isp116x->intenb |= HCINT_RD;
1367 	isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;	/* | HCuPINT_SUSP; */
1368 	isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1369 	isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1370 
1371 	/* Go operational */
1372 	val = HCCONTROL_USB_OPER;
1373 	if (board->remote_wakeup_enable)
1374 		val |= HCCONTROL_RWE;
1375 	isp116x_write_reg32(isp116x, HCCONTROL, val);
1376 
1377 	/* Disable ports to avoid race in device enumeration */
1378 	isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1379 	isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1380 
1381 	isp116x_show_regs_log(isp116x);
1382 	spin_unlock_irqrestore(&isp116x->lock, flags);
1383 	return 0;
1384 }
1385 
1386 #ifdef	CONFIG_PM
1387 
1388 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1389 {
1390 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1391 	unsigned long flags;
1392 	u32 val;
1393 	int ret = 0;
1394 
1395 	spin_lock_irqsave(&isp116x->lock, flags);
1396 	val = isp116x_read_reg32(isp116x, HCCONTROL);
1397 
1398 	switch (val & HCCONTROL_HCFS) {
1399 	case HCCONTROL_USB_OPER:
1400 		spin_unlock_irqrestore(&isp116x->lock, flags);
1401 		val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1402 		val |= HCCONTROL_USB_SUSPEND;
1403 		if (hcd->self.root_hub->do_remote_wakeup)
1404 			val |= HCCONTROL_RWE;
1405 		/* Wait for usb transfers to finish */
1406 		msleep(2);
1407 		spin_lock_irqsave(&isp116x->lock, flags);
1408 		isp116x_write_reg32(isp116x, HCCONTROL, val);
1409 		spin_unlock_irqrestore(&isp116x->lock, flags);
1410 		/* Wait for devices to suspend */
1411 		msleep(5);
1412 		break;
1413 	case HCCONTROL_USB_RESUME:
1414 		isp116x_write_reg32(isp116x, HCCONTROL,
1415 				    (val & ~HCCONTROL_HCFS) |
1416 				    HCCONTROL_USB_RESET);
1417 	case HCCONTROL_USB_RESET:
1418 		ret = -EBUSY;
1419 	default:		/* HCCONTROL_USB_SUSPEND */
1420 		spin_unlock_irqrestore(&isp116x->lock, flags);
1421 		break;
1422 	}
1423 
1424 	return ret;
1425 }
1426 
1427 static int isp116x_bus_resume(struct usb_hcd *hcd)
1428 {
1429 	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1430 	u32 val;
1431 
1432 	msleep(5);
1433 	spin_lock_irq(&isp116x->lock);
1434 
1435 	val = isp116x_read_reg32(isp116x, HCCONTROL);
1436 	switch (val & HCCONTROL_HCFS) {
1437 	case HCCONTROL_USB_SUSPEND:
1438 		val &= ~HCCONTROL_HCFS;
1439 		val |= HCCONTROL_USB_RESUME;
1440 		isp116x_write_reg32(isp116x, HCCONTROL, val);
1441 	case HCCONTROL_USB_RESUME:
1442 		break;
1443 	case HCCONTROL_USB_OPER:
1444 		spin_unlock_irq(&isp116x->lock);
1445 		return 0;
1446 	default:
1447 		/* HCCONTROL_USB_RESET: this may happen, when during
1448 		   suspension the HC lost power. Reinitialize completely */
1449 		spin_unlock_irq(&isp116x->lock);
1450 		DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1451 		isp116x_reset(hcd);
1452 		isp116x_start(hcd);
1453 		isp116x_hub_control(hcd, SetPortFeature,
1454 				    USB_PORT_FEAT_POWER, 1, NULL, 0);
1455 		if ((isp116x->rhdesca & RH_A_NDP) == 2)
1456 			isp116x_hub_control(hcd, SetPortFeature,
1457 					    USB_PORT_FEAT_POWER, 2, NULL, 0);
1458 		return 0;
1459 	}
1460 
1461 	val = isp116x->rhdesca & RH_A_NDP;
1462 	while (val--) {
1463 		u32 stat =
1464 		    isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1465 		/* force global, not selective, resume */
1466 		if (!(stat & RH_PS_PSS))
1467 			continue;
1468 		DBG("%s: Resuming port %d\n", __func__, val);
1469 		isp116x_write_reg32(isp116x, RH_PS_POCI, val
1470 				    ? HCRHPORT2 : HCRHPORT1);
1471 	}
1472 	spin_unlock_irq(&isp116x->lock);
1473 
1474 	hcd->state = HC_STATE_RESUMING;
1475 	msleep(20);
1476 
1477 	/* Go operational */
1478 	spin_lock_irq(&isp116x->lock);
1479 	val = isp116x_read_reg32(isp116x, HCCONTROL);
1480 	isp116x_write_reg32(isp116x, HCCONTROL,
1481 			    (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1482 	spin_unlock_irq(&isp116x->lock);
1483 	hcd->state = HC_STATE_RUNNING;
1484 
1485 	return 0;
1486 }
1487 
1488 #else
1489 
1490 #define	isp116x_bus_suspend	NULL
1491 #define	isp116x_bus_resume	NULL
1492 
1493 #endif
1494 
1495 static struct hc_driver isp116x_hc_driver = {
1496 	.description = hcd_name,
1497 	.product_desc = "ISP116x Host Controller",
1498 	.hcd_priv_size = sizeof(struct isp116x),
1499 
1500 	.irq = isp116x_irq,
1501 	.flags = HCD_USB11,
1502 
1503 	.reset = isp116x_reset,
1504 	.start = isp116x_start,
1505 	.stop = isp116x_stop,
1506 
1507 	.urb_enqueue = isp116x_urb_enqueue,
1508 	.urb_dequeue = isp116x_urb_dequeue,
1509 	.endpoint_disable = isp116x_endpoint_disable,
1510 
1511 	.get_frame_number = isp116x_get_frame,
1512 
1513 	.hub_status_data = isp116x_hub_status_data,
1514 	.hub_control = isp116x_hub_control,
1515 	.bus_suspend = isp116x_bus_suspend,
1516 	.bus_resume = isp116x_bus_resume,
1517 };
1518 
1519 /*----------------------------------------------------------------*/
1520 
1521 static int isp116x_remove(struct platform_device *pdev)
1522 {
1523 	struct usb_hcd *hcd = platform_get_drvdata(pdev);
1524 	struct isp116x *isp116x;
1525 	struct resource *res;
1526 
1527 	if (!hcd)
1528 		return 0;
1529 	isp116x = hcd_to_isp116x(hcd);
1530 	remove_debug_file(isp116x);
1531 	usb_remove_hcd(hcd);
1532 
1533 	iounmap(isp116x->data_reg);
1534 	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1535 	release_mem_region(res->start, 2);
1536 	iounmap(isp116x->addr_reg);
1537 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1538 	release_mem_region(res->start, 2);
1539 
1540 	usb_put_hcd(hcd);
1541 	return 0;
1542 }
1543 
1544 #define resource_len(r) (((r)->end - (r)->start) + 1)
1545 
1546 static int __devinit isp116x_probe(struct platform_device *pdev)
1547 {
1548 	struct usb_hcd *hcd;
1549 	struct isp116x *isp116x;
1550 	struct resource *addr, *data;
1551 	void __iomem *addr_reg;
1552 	void __iomem *data_reg;
1553 	int irq;
1554 	int ret = 0;
1555 
1556 	if (pdev->num_resources < 3) {
1557 		ret = -ENODEV;
1558 		goto err1;
1559 	}
1560 
1561 	data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1562 	addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1563 	irq = platform_get_irq(pdev, 0);
1564 	if (!addr || !data || irq < 0) {
1565 		ret = -ENODEV;
1566 		goto err1;
1567 	}
1568 
1569 	if (pdev->dev.dma_mask) {
1570 		DBG("DMA not supported\n");
1571 		ret = -EINVAL;
1572 		goto err1;
1573 	}
1574 
1575 	if (!request_mem_region(addr->start, 2, hcd_name)) {
1576 		ret = -EBUSY;
1577 		goto err1;
1578 	}
1579 	addr_reg = ioremap(addr->start, resource_len(addr));
1580 	if (addr_reg == NULL) {
1581 		ret = -ENOMEM;
1582 		goto err2;
1583 	}
1584 	if (!request_mem_region(data->start, 2, hcd_name)) {
1585 		ret = -EBUSY;
1586 		goto err3;
1587 	}
1588 	data_reg = ioremap(data->start, resource_len(data));
1589 	if (data_reg == NULL) {
1590 		ret = -ENOMEM;
1591 		goto err4;
1592 	}
1593 
1594 	/* allocate and initialize hcd */
1595 	hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1596 	if (!hcd) {
1597 		ret = -ENOMEM;
1598 		goto err5;
1599 	}
1600 	/* this rsrc_start is bogus */
1601 	hcd->rsrc_start = addr->start;
1602 	isp116x = hcd_to_isp116x(hcd);
1603 	isp116x->data_reg = data_reg;
1604 	isp116x->addr_reg = addr_reg;
1605 	spin_lock_init(&isp116x->lock);
1606 	INIT_LIST_HEAD(&isp116x->async);
1607 	isp116x->board = pdev->dev.platform_data;
1608 
1609 	if (!isp116x->board) {
1610 		ERR("Platform data structure not initialized\n");
1611 		ret = -ENODEV;
1612 		goto err6;
1613 	}
1614 	if (isp116x_check_platform_delay(isp116x)) {
1615 		ERR("USE_PLATFORM_DELAY defined, but delay function not "
1616 		    "implemented.\n");
1617 		ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1618 		ret = -ENODEV;
1619 		goto err6;
1620 	}
1621 
1622 	ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1623 	if (ret)
1624 		goto err6;
1625 
1626 	ret = create_debug_file(isp116x);
1627 	if (ret) {
1628 		ERR("Couldn't create debugfs entry\n");
1629 		goto err7;
1630 	}
1631 
1632 	return 0;
1633 
1634       err7:
1635 	usb_remove_hcd(hcd);
1636       err6:
1637 	usb_put_hcd(hcd);
1638       err5:
1639 	iounmap(data_reg);
1640       err4:
1641 	release_mem_region(data->start, 2);
1642       err3:
1643 	iounmap(addr_reg);
1644       err2:
1645 	release_mem_region(addr->start, 2);
1646       err1:
1647 	ERR("init error, %d\n", ret);
1648 	return ret;
1649 }
1650 
1651 #ifdef	CONFIG_PM
1652 /*
1653   Suspend of platform device
1654 */
1655 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1656 {
1657 	VDBG("%s: state %x\n", __func__, state.event);
1658 	return 0;
1659 }
1660 
1661 /*
1662   Resume platform device
1663 */
1664 static int isp116x_resume(struct platform_device *dev)
1665 {
1666 	VDBG("%s\n", __func__);
1667 	return 0;
1668 }
1669 
1670 #else
1671 
1672 #define	isp116x_suspend    NULL
1673 #define	isp116x_resume     NULL
1674 
1675 #endif
1676 
1677 /* work with hotplug and coldplug */
1678 MODULE_ALIAS("platform:isp116x-hcd");
1679 
1680 static struct platform_driver isp116x_driver = {
1681 	.probe = isp116x_probe,
1682 	.remove = isp116x_remove,
1683 	.suspend = isp116x_suspend,
1684 	.resume = isp116x_resume,
1685 	.driver = {
1686 		.name = (char *)hcd_name,
1687 		.owner	= THIS_MODULE,
1688 	},
1689 };
1690 
1691 /*-----------------------------------------------------------------*/
1692 
1693 static int __init isp116x_init(void)
1694 {
1695 	if (usb_disabled())
1696 		return -ENODEV;
1697 
1698 	INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1699 	return platform_driver_register(&isp116x_driver);
1700 }
1701 
1702 module_init(isp116x_init);
1703 
1704 static void __exit isp116x_cleanup(void)
1705 {
1706 	platform_driver_unregister(&isp116x_driver);
1707 }
1708 
1709 module_exit(isp116x_cleanup);
1710