PageRenderTime 112ms CodeModel.GetById 17ms app.highlight 82ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/usb/host/isp116x-hcd.c

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