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			usb_hc_died(hcd);
 616			ret = IRQ_HANDLED;
 617			goto done;
 618		}
 619		if (intstat & HCINT_RHSC)
 620			/* When root hub or any of its ports is going
 621			   to come out of suspend, it may take more
 622			   than 10ms for status bits to stabilize. */
 623			mod_timer(&hcd->rh_timer, jiffies
 624				  + msecs_to_jiffies(20) + 1);
 625		if (intstat & HCINT_RD) {
 626			DBG("---- remote wakeup\n");
 627			usb_hcd_resume_root_hub(hcd);
 628		}
 629		irqstat &= ~HCuPINT_OPR;
 630		ret = IRQ_HANDLED;
 631	}
 632
 633	if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
 634		start_atl_transfers(isp116x);
 635	}
 636
 637	isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
 638      done:
 639	spin_unlock(&isp116x->lock);
 640	return ret;
 641}
 642
 643/*-----------------------------------------------------------------*/
 644
 645/* usb 1.1 says max 90% of a frame is available for periodic transfers.
 646 * this driver doesn't promise that much since it's got to handle an
 647 * IRQ per packet; irq handling latencies also use up that time.
 648 */
 649
 650/* out of 1000 us */
 651#define	MAX_PERIODIC_LOAD	600
 652static int balance(struct isp116x *isp116x, u16 period, u16 load)
 653{
 654	int i, branch = -ENOSPC;
 655
 656	/* search for the least loaded schedule branch of that period
 657	   which has enough bandwidth left unreserved. */
 658	for (i = 0; i < period; i++) {
 659		if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
 660			int j;
 661
 662			for (j = i; j < PERIODIC_SIZE; j += period) {
 663				if ((isp116x->load[j] + load)
 664				    > MAX_PERIODIC_LOAD)
 665					break;
 666			}
 667			if (j < PERIODIC_SIZE)
 668				continue;
 669			branch = i;
 670		}
 671	}
 672	return branch;
 673}
 674
 675/* NB! ALL the code above this point runs with isp116x->lock
 676   held, irqs off
 677*/
 678
 679/*-----------------------------------------------------------------*/
 680
 681static int isp116x_urb_enqueue(struct usb_hcd *hcd,
 682			       struct urb *urb,
 683			       gfp_t mem_flags)
 684{
 685	struct isp116x *isp116x = hcd_to_isp116x(hcd);
 686	struct usb_device *udev = urb->dev;
 687	unsigned int pipe = urb->pipe;
 688	int is_out = !usb_pipein(pipe);
 689	int type = usb_pipetype(pipe);
 690	int epnum = usb_pipeendpoint(pipe);
 691	struct usb_host_endpoint *hep = urb->ep;
 692	struct isp116x_ep *ep = NULL;
 693	unsigned long flags;
 694	int i;
 695	int ret = 0;
 696
 697	urb_dbg(urb, "Enqueue");
 698
 699	if (type == PIPE_ISOCHRONOUS) {
 700		ERR("Isochronous transfers not supported\n");
 701		urb_dbg(urb, "Refused to enqueue");
 702		return -ENXIO;
 703	}
 704	/* avoid all allocations within spinlocks: request or endpoint */
 705	if (!hep->hcpriv) {
 706		ep = kzalloc(sizeof *ep, mem_flags);
 707		if (!ep)
 708			return -ENOMEM;
 709	}
 710
 711	spin_lock_irqsave(&isp116x->lock, flags);
 712	if (!HC_IS_RUNNING(hcd->state)) {
 713		kfree(ep);
 714		ret = -ENODEV;
 715		goto fail_not_linked;
 716	}
 717	ret = usb_hcd_link_urb_to_ep(hcd, urb);
 718	if (ret) {
 719		kfree(ep);
 720		goto fail_not_linked;
 721	}
 722
 723	if (hep->hcpriv)
 724		ep = hep->hcpriv;
 725	else {
 726		INIT_LIST_HEAD(&ep->schedule);
 727		ep->udev = udev;
 728		ep->epnum = epnum;
 729		ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
 730		usb_settoggle(udev, epnum, is_out, 0);
 731
 732		if (type == PIPE_CONTROL) {
 733			ep->nextpid = USB_PID_SETUP;
 734		} else if (is_out) {
 735			ep->nextpid = USB_PID_OUT;
 736		} else {
 737			ep->nextpid = USB_PID_IN;
 738		}
 739
 740		if (urb->interval) {
 741			/*
 742			   With INT URBs submitted, the driver works with SOF
 743			   interrupt enabled and ATL interrupt disabled. After
 744			   the PTDs are written to fifo ram, the chip starts
 745			   fifo processing and usb transfers after the next
 746			   SOF and continues until the transfers are finished
 747			   (succeeded or failed) or the frame ends. Therefore,
 748			   the transfers occur only in every second frame,
 749			   while fifo reading/writing and data processing
 750			   occur in every other second frame. */
 751			if (urb->interval < 2)
 752				urb->interval = 2;
 753			if (urb->interval > 2 * PERIODIC_SIZE)
 754				urb->interval = 2 * PERIODIC_SIZE;
 755			ep->period = urb->interval >> 1;
 756			ep->branch = PERIODIC_SIZE;
 757			ep->load = usb_calc_bus_time(udev->speed,
 758						     !is_out,
 759						     (type == PIPE_ISOCHRONOUS),
 760						     usb_maxpacket(udev, pipe,
 761								   is_out)) /
 762			    1000;
 763		}
 764		hep->hcpriv = ep;
 765		ep->hep = hep;
 766	}
 767
 768	/* maybe put endpoint into schedule */
 769	switch (type) {
 770	case PIPE_CONTROL:
 771	case PIPE_BULK:
 772		if (list_empty(&ep->schedule))
 773			list_add_tail(&ep->schedule, &isp116x->async);
 774		break;
 775	case PIPE_INTERRUPT:
 776		urb->interval = ep->period;
 777		ep->length = min_t(u32, ep->maxpacket,
 778				 urb->transfer_buffer_length);
 779
 780		/* urb submitted for already existing endpoint */
 781		if (ep->branch < PERIODIC_SIZE)
 782			break;
 783
 784		ep->branch = ret = balance(isp116x, ep->period, ep->load);
 785		if (ret < 0)
 786			goto fail;
 787		ret = 0;
 788
 789		urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
 790		    + ep->branch;
 791
 792		/* sort each schedule branch by period (slow before fast)
 793		   to share the faster parts of the tree without needing
 794		   dummy/placeholder nodes */
 795		DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
 796		for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 797			struct isp116x_ep **prev = &isp116x->periodic[i];
 798			struct isp116x_ep *here = *prev;
 799
 800			while (here && ep != here) {
 801				if (ep->period > here->period)
 802					break;
 803				prev = &here->next;
 804				here = *prev;
 805			}
 806			if (ep != here) {
 807				ep->next = here;
 808				*prev = ep;
 809			}
 810			isp116x->load[i] += ep->load;
 811		}
 812		hcd->self.bandwidth_allocated += ep->load / ep->period;
 813
 814		/* switch over to SOFint */
 815		if (!isp116x->periodic_count++) {
 816			isp116x->irqenb &= ~HCuPINT_ATL;
 817			isp116x->irqenb |= HCuPINT_SOF;
 818			isp116x_write_reg16(isp116x, HCuPINTENB,
 819					    isp116x->irqenb);
 820		}
 821	}
 822
 823	urb->hcpriv = hep;
 824	start_atl_transfers(isp116x);
 825
 826      fail:
 827	if (ret)
 828		usb_hcd_unlink_urb_from_ep(hcd, urb);
 829      fail_not_linked:
 830	spin_unlock_irqrestore(&isp116x->lock, flags);
 831	return ret;
 832}
 833
 834/*
 835   Dequeue URBs.
 836*/
 837static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
 838		int status)
 839{
 840	struct isp116x *isp116x = hcd_to_isp116x(hcd);
 841	struct usb_host_endpoint *hep;
 842	struct isp116x_ep *ep, *ep_act;
 843	unsigned long flags;
 844	int rc;
 845
 846	spin_lock_irqsave(&isp116x->lock, flags);
 847	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
 848	if (rc)
 849		goto done;
 850
 851	hep = urb->hcpriv;
 852	ep = hep->hcpriv;
 853	WARN_ON(hep != ep->hep);
 854
 855	/* In front of queue? */
 856	if (ep->hep->urb_list.next == &urb->urb_list)
 857		/* active? */
 858		for (ep_act = isp116x->atl_active; ep_act;
 859		     ep_act = ep_act->active)
 860			if (ep_act == ep) {
 861				VDBG("dequeue, urb %p active; wait for irq\n",
 862				     urb);
 863				urb = NULL;
 864				break;
 865			}
 866
 867	if (urb)
 868		finish_request(isp116x, ep, urb, status);
 869 done:
 870	spin_unlock_irqrestore(&isp116x->lock, flags);
 871	return rc;
 872}
 873
 874static void isp116x_endpoint_disable(struct usb_hcd *hcd,
 875				     struct usb_host_endpoint *hep)
 876{
 877	int i;
 878	struct isp116x_ep *ep = hep->hcpriv;
 879
 880	if (!ep)
 881		return;
 882
 883	/* assume we'd just wait for the irq */
 884	for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
 885		msleep(3);
 886	if (!list_empty(&hep->urb_list))
 887		WARNING("ep %p not empty?\n", ep);
 888
 889	kfree(ep);
 890	hep->hcpriv = NULL;
 891}
 892
 893static int isp116x_get_frame(struct usb_hcd *hcd)
 894{
 895	struct isp116x *isp116x = hcd_to_isp116x(hcd);
 896	u32 fmnum;
 897	unsigned long flags;
 898
 899	spin_lock_irqsave(&isp116x->lock, flags);
 900	fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
 901	spin_unlock_irqrestore(&isp116x->lock, flags);
 902	return (int)fmnum;
 903}
 904
 905/*
 906  Adapted from ohci-hub.c. Currently we don't support autosuspend.
 907*/
 908static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 909{
 910	struct isp116x *isp116x = hcd_to_isp116x(hcd);
 911	int ports, i, changed = 0;
 912	unsigned long flags;
 913
 914	if (!HC_IS_RUNNING(hcd->state))
 915		return -ESHUTDOWN;
 916
 917	/* Report no status change now, if we are scheduled to be
 918	   called later */
 919	if (timer_pending(&hcd->rh_timer))
 920		return 0;
 921
 922	ports = isp116x->rhdesca & RH_A_NDP;
 923	spin_lock_irqsave(&isp116x->lock, flags);
 924	isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
 925	if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
 926		buf[0] = changed = 1;
 927	else
 928		buf[0] = 0;
 929
 930	for (i = 0; i < ports; i++) {
 931		u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 932
 933		if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
 934			      | RH_PS_OCIC | RH_PS_PRSC)) {
 935			changed = 1;
 936			buf[0] |= 1 << (i + 1);
 937		}
 938	}
 939	spin_unlock_irqrestore(&isp116x->lock, flags);
 940	return changed;
 941}
 942
 943static void isp116x_hub_descriptor(struct isp116x *isp116x,
 944				   struct usb_hub_descriptor *desc)
 945{
 946	u32 reg = isp116x->rhdesca;
 947
 948	desc->bDescriptorType = 0x29;
 949	desc->bDescLength = 9;
 950	desc->bHubContrCurrent = 0;
 951	desc->bNbrPorts = (u8) (reg & 0x3);
 952	/* Power switching, device type, overcurrent. */
 953	desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
 
 
 
 954	desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 955	/* ports removable, and legacy PortPwrCtrlMask */
 956	desc->u.hs.DeviceRemovable[0] = 0;
 957	desc->u.hs.DeviceRemovable[1] = ~0;
 958}
 959
 960/* Perform reset of a given port.
 961   It would be great to just start the reset and let the
 962   USB core to clear the reset in due time. However,
 963   root hub ports should be reset for at least 50 ms, while
 964   our chip stays in reset for about 10 ms. I.e., we must
 965   repeatedly reset it ourself here.
 966*/
 967static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 968{
 969	u32 tmp;
 970	unsigned long flags, t;
 971
 972	/* Root hub reset should be 50 ms, but some devices
 973	   want it even longer. */
 974	t = jiffies + msecs_to_jiffies(100);
 975
 976	while (time_before(jiffies, t)) {
 977		spin_lock_irqsave(&isp116x->lock, flags);
 978		/* spin until any current reset finishes */
 979		for (;;) {
 980			tmp = isp116x_read_reg32(isp116x, port ?
 981						 HCRHPORT2 : HCRHPORT1);
 982			if (!(tmp & RH_PS_PRS))
 983				break;
 984			udelay(500);
 985		}
 986		/* Don't reset a disconnected port */
 987		if (!(tmp & RH_PS_CCS)) {
 988			spin_unlock_irqrestore(&isp116x->lock, flags);
 989			break;
 990		}
 991		/* Reset lasts 10ms (claims datasheet) */
 992		isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
 993				    HCRHPORT1, (RH_PS_PRS));
 994		spin_unlock_irqrestore(&isp116x->lock, flags);
 995		msleep(10);
 996	}
 997}
 998
 999/* Adapted from ohci-hub.c */
1000static int isp116x_hub_control(struct usb_hcd *hcd,
1001			       u16 typeReq,
1002			       u16 wValue, u16 wIndex, char *buf, u16 wLength)
1003{
1004	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1005	int ret = 0;
1006	unsigned long flags;
1007	int ports = isp116x->rhdesca & RH_A_NDP;
1008	u32 tmp = 0;
1009
1010	switch (typeReq) {
1011	case ClearHubFeature:
1012		DBG("ClearHubFeature: ");
1013		switch (wValue) {
1014		case C_HUB_OVER_CURRENT:
1015			DBG("C_HUB_OVER_CURRENT\n");
1016			spin_lock_irqsave(&isp116x->lock, flags);
1017			isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1018			spin_unlock_irqrestore(&isp116x->lock, flags);
 
1019		case C_HUB_LOCAL_POWER:
1020			DBG("C_HUB_LOCAL_POWER\n");
1021			break;
1022		default:
1023			goto error;
1024		}
1025		break;
1026	case SetHubFeature:
1027		DBG("SetHubFeature: ");
1028		switch (wValue) {
1029		case C_HUB_OVER_CURRENT:
1030		case C_HUB_LOCAL_POWER:
1031			DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1032			break;
1033		default:
1034			goto error;
1035		}
1036		break;
1037	case GetHubDescriptor:
1038		DBG("GetHubDescriptor\n");
1039		isp116x_hub_descriptor(isp116x,
1040				       (struct usb_hub_descriptor *)buf);
1041		break;
1042	case GetHubStatus:
1043		DBG("GetHubStatus\n");
1044		*(__le32 *) buf = 0;
1045		break;
1046	case GetPortStatus:
1047		DBG("GetPortStatus\n");
1048		if (!wIndex || wIndex > ports)
1049			goto error;
1050		spin_lock_irqsave(&isp116x->lock, flags);
1051		tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1052		spin_unlock_irqrestore(&isp116x->lock, flags);
1053		*(__le32 *) buf = cpu_to_le32(tmp);
1054		DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1055		break;
1056	case ClearPortFeature:
1057		DBG("ClearPortFeature: ");
1058		if (!wIndex || wIndex > ports)
1059			goto error;
1060		wIndex--;
1061
1062		switch (wValue) {
1063		case USB_PORT_FEAT_ENABLE:
1064			DBG("USB_PORT_FEAT_ENABLE\n");
1065			tmp = RH_PS_CCS;
1066			break;
1067		case USB_PORT_FEAT_C_ENABLE:
1068			DBG("USB_PORT_FEAT_C_ENABLE\n");
1069			tmp = RH_PS_PESC;
1070			break;
1071		case USB_PORT_FEAT_SUSPEND:
1072			DBG("USB_PORT_FEAT_SUSPEND\n");
1073			tmp = RH_PS_POCI;
1074			break;
1075		case USB_PORT_FEAT_C_SUSPEND:
1076			DBG("USB_PORT_FEAT_C_SUSPEND\n");
1077			tmp = RH_PS_PSSC;
1078			break;
1079		case USB_PORT_FEAT_POWER:
1080			DBG("USB_PORT_FEAT_POWER\n");
1081			tmp = RH_PS_LSDA;
1082			break;
1083		case USB_PORT_FEAT_C_CONNECTION:
1084			DBG("USB_PORT_FEAT_C_CONNECTION\n");
1085			tmp = RH_PS_CSC;
1086			break;
1087		case USB_PORT_FEAT_C_OVER_CURRENT:
1088			DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1089			tmp = RH_PS_OCIC;
1090			break;
1091		case USB_PORT_FEAT_C_RESET:
1092			DBG("USB_PORT_FEAT_C_RESET\n");
1093			tmp = RH_PS_PRSC;
1094			break;
1095		default:
1096			goto error;
1097		}
1098		spin_lock_irqsave(&isp116x->lock, flags);
1099		isp116x_write_reg32(isp116x, wIndex
1100				    ? HCRHPORT2 : HCRHPORT1, tmp);
1101		spin_unlock_irqrestore(&isp116x->lock, flags);
1102		break;
1103	case SetPortFeature:
1104		DBG("SetPortFeature: ");
1105		if (!wIndex || wIndex > ports)
1106			goto error;
1107		wIndex--;
1108		switch (wValue) {
1109		case USB_PORT_FEAT_SUSPEND:
1110			DBG("USB_PORT_FEAT_SUSPEND\n");
1111			spin_lock_irqsave(&isp116x->lock, flags);
1112			isp116x_write_reg32(isp116x, wIndex
1113					    ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1114			spin_unlock_irqrestore(&isp116x->lock, flags);
1115			break;
1116		case USB_PORT_FEAT_POWER:
1117			DBG("USB_PORT_FEAT_POWER\n");
1118			spin_lock_irqsave(&isp116x->lock, flags);
1119			isp116x_write_reg32(isp116x, wIndex
1120					    ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1121			spin_unlock_irqrestore(&isp116x->lock, flags);
1122			break;
1123		case USB_PORT_FEAT_RESET:
1124			DBG("USB_PORT_FEAT_RESET\n");
1125			root_port_reset(isp116x, wIndex);
1126			break;
1127		default:
1128			goto error;
1129		}
1130		break;
1131
1132	default:
1133	      error:
1134		/* "protocol stall" on error */
1135		DBG("PROTOCOL STALL\n");
1136		ret = -EPIPE;
1137	}
1138	return ret;
1139}
1140
1141/*-----------------------------------------------------------------*/
1142
1143#ifdef CONFIG_DEBUG_FS
1144
1145static void dump_irq(struct seq_file *s, char *label, u16 mask)
1146{
1147	seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1148		   mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1149		   mask & HCuPINT_SUSP ? " susp" : "",
1150		   mask & HCuPINT_OPR ? " opr" : "",
1151		   mask & HCuPINT_AIIEOT ? " eot" : "",
1152		   mask & HCuPINT_ATL ? " atl" : "",
1153		   mask & HCuPINT_SOF ? " sof" : "");
1154}
1155
1156static void dump_int(struct seq_file *s, char *label, u32 mask)
1157{
1158	seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1159		   mask & HCINT_MIE ? " MIE" : "",
1160		   mask & HCINT_RHSC ? " rhsc" : "",
1161		   mask & HCINT_FNO ? " fno" : "",
1162		   mask & HCINT_UE ? " ue" : "",
1163		   mask & HCINT_RD ? " rd" : "",
1164		   mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1165}
1166
1167static int isp116x_show_dbg(struct seq_file *s, void *unused)
1168{
1169	struct isp116x *isp116x = s->private;
1170
1171	seq_printf(s, "%s\n%s version %s\n",
1172		   isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1173		   DRIVER_VERSION);
1174
1175	if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1176		seq_printf(s, "HCD is suspended\n");
1177		return 0;
1178	}
1179	if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1180		seq_printf(s, "HCD not running\n");
1181		return 0;
1182	}
1183
1184	spin_lock_irq(&isp116x->lock);
1185	dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1186	dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1187	dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1188	dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1189	isp116x_show_regs_seq(isp116x, s);
1190	spin_unlock_irq(&isp116x->lock);
1191	seq_printf(s, "\n");
1192
1193	return 0;
1194}
 
1195
1196static int isp116x_open_seq(struct inode *inode, struct file *file)
1197{
1198	return single_open(file, isp116x_show_dbg, inode->i_private);
1199}
1200
1201static const struct file_operations isp116x_debug_fops = {
1202	.open = isp116x_open_seq,
1203	.read = seq_read,
1204	.llseek = seq_lseek,
1205	.release = single_release,
1206};
1207
1208static int create_debug_file(struct isp116x *isp116x)
1209{
1210	isp116x->dentry = debugfs_create_file(hcd_name,
1211					      S_IRUGO, NULL, isp116x,
1212					      &isp116x_debug_fops);
1213	if (!isp116x->dentry)
1214		return -ENOMEM;
1215	return 0;
1216}
1217
1218static void remove_debug_file(struct isp116x *isp116x)
1219{
1220	debugfs_remove(isp116x->dentry);
1221}
1222
1223#else
1224
1225#define	create_debug_file(d)	0
1226#define	remove_debug_file(d)	do{}while(0)
1227
1228#endif				/* CONFIG_DEBUG_FS */
1229
1230/*-----------------------------------------------------------------*/
1231
1232/*
1233  Software reset - can be called from any contect.
1234*/
1235static int isp116x_sw_reset(struct isp116x *isp116x)
1236{
1237	int retries = 15;
1238	unsigned long flags;
1239	int ret = 0;
1240
1241	spin_lock_irqsave(&isp116x->lock, flags);
1242	isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1243	isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1244	while (--retries) {
1245		/* It usually resets within 1 ms */
1246		mdelay(1);
1247		if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1248			break;
1249	}
1250	if (!retries) {
1251		ERR("Software reset timeout\n");
1252		ret = -ETIME;
1253	}
1254	spin_unlock_irqrestore(&isp116x->lock, flags);
1255	return ret;
1256}
1257
1258static int isp116x_reset(struct usb_hcd *hcd)
1259{
1260	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1261	unsigned long t;
1262	u16 clkrdy = 0;
1263	int ret, timeout = 15 /* ms */ ;
1264
1265	ret = isp116x_sw_reset(isp116x);
1266	if (ret)
1267		return ret;
1268
1269	t = jiffies + msecs_to_jiffies(timeout);
1270	while (time_before_eq(jiffies, t)) {
1271		msleep(4);
1272		spin_lock_irq(&isp116x->lock);
1273		clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1274		spin_unlock_irq(&isp116x->lock);
1275		if (clkrdy)
1276			break;
1277	}
1278	if (!clkrdy) {
1279		ERR("Clock not ready after %dms\n", timeout);
1280		/* After sw_reset the clock won't report to be ready, if
1281		   H_WAKEUP pin is high. */
1282		ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1283		ret = -ENODEV;
1284	}
1285	return ret;
1286}
1287
1288static void isp116x_stop(struct usb_hcd *hcd)
1289{
1290	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1291	unsigned long flags;
1292	u32 val;
1293
1294	spin_lock_irqsave(&isp116x->lock, flags);
1295	isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1296
1297	/* Switch off ports' power, some devices don't come up
1298	   after next 'insmod' without this */
1299	val = isp116x_read_reg32(isp116x, HCRHDESCA);
1300	val &= ~(RH_A_NPS | RH_A_PSM);
1301	isp116x_write_reg32(isp116x, HCRHDESCA, val);
1302	isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1303	spin_unlock_irqrestore(&isp116x->lock, flags);
1304
1305	isp116x_sw_reset(isp116x);
1306}
1307
1308/*
1309  Configure the chip. The chip must be successfully reset by now.
1310*/
1311static int isp116x_start(struct usb_hcd *hcd)
1312{
1313	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1314	struct isp116x_platform_data *board = isp116x->board;
1315	u32 val;
1316	unsigned long flags;
1317
1318	spin_lock_irqsave(&isp116x->lock, flags);
1319
1320	/* clear interrupt status and disable all interrupt sources */
1321	isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1322	isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1323
1324	val = isp116x_read_reg16(isp116x, HCCHIPID);
1325	if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1326		ERR("Invalid chip ID %04x\n", val);
1327		spin_unlock_irqrestore(&isp116x->lock, flags);
1328		return -ENODEV;
1329	}
1330
1331	/* To be removed in future */
1332	hcd->uses_new_polling = 1;
1333
1334	isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1335	isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1336
1337	/* ----- HW conf */
1338	val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1339	if (board->sel15Kres)
1340		val |= HCHWCFG_15KRSEL;
1341	/* Remote wakeup won't work without working clock */
1342	if (board->remote_wakeup_enable)
1343		val |= HCHWCFG_CLKNOTSTOP;
1344	if (board->oc_enable)
1345		val |= HCHWCFG_ANALOG_OC;
1346	if (board->int_act_high)
1347		val |= HCHWCFG_INT_POL;
1348	if (board->int_edge_triggered)
1349		val |= HCHWCFG_INT_TRIGGER;
1350	isp116x_write_reg16(isp116x, HCHWCFG, val);
1351
1352	/* ----- Root hub conf */
1353	val = (25 << 24) & RH_A_POTPGT;
1354	/* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1355	   be always set. Yet, instead, we request individual port
1356	   power switching. */
1357	val |= RH_A_PSM;
1358	/* Report overcurrent per port */
1359	val |= RH_A_OCPM;
1360	isp116x_write_reg32(isp116x, HCRHDESCA, val);
1361	isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1362
1363	val = RH_B_PPCM;
1364	isp116x_write_reg32(isp116x, HCRHDESCB, val);
1365	isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1366
1367	val = 0;
1368	if (board->remote_wakeup_enable) {
1369		if (!device_can_wakeup(hcd->self.controller))
1370			device_init_wakeup(hcd->self.controller, 1);
1371		val |= RH_HS_DRWE;
1372	}
1373	isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1374	isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1375
1376	isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1377
1378	hcd->state = HC_STATE_RUNNING;
1379
1380	/* Set up interrupts */
1381	isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1382	if (board->remote_wakeup_enable)
1383		isp116x->intenb |= HCINT_RD;
1384	isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;	/* | HCuPINT_SUSP; */
1385	isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1386	isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1387
1388	/* Go operational */
1389	val = HCCONTROL_USB_OPER;
1390	if (board->remote_wakeup_enable)
1391		val |= HCCONTROL_RWE;
1392	isp116x_write_reg32(isp116x, HCCONTROL, val);
1393
1394	/* Disable ports to avoid race in device enumeration */
1395	isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1396	isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1397
1398	isp116x_show_regs_log(isp116x);
1399	spin_unlock_irqrestore(&isp116x->lock, flags);
1400	return 0;
1401}
1402
1403#ifdef	CONFIG_PM
1404
1405static int isp116x_bus_suspend(struct usb_hcd *hcd)
1406{
1407	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1408	unsigned long flags;
1409	u32 val;
1410	int ret = 0;
1411
1412	spin_lock_irqsave(&isp116x->lock, flags);
1413	val = isp116x_read_reg32(isp116x, HCCONTROL);
1414
1415	switch (val & HCCONTROL_HCFS) {
1416	case HCCONTROL_USB_OPER:
1417		spin_unlock_irqrestore(&isp116x->lock, flags);
1418		val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1419		val |= HCCONTROL_USB_SUSPEND;
1420		if (hcd->self.root_hub->do_remote_wakeup)
1421			val |= HCCONTROL_RWE;
1422		/* Wait for usb transfers to finish */
1423		msleep(2);
1424		spin_lock_irqsave(&isp116x->lock, flags);
1425		isp116x_write_reg32(isp116x, HCCONTROL, val);
1426		spin_unlock_irqrestore(&isp116x->lock, flags);
1427		/* Wait for devices to suspend */
1428		msleep(5);
1429		break;
1430	case HCCONTROL_USB_RESUME:
1431		isp116x_write_reg32(isp116x, HCCONTROL,
1432				    (val & ~HCCONTROL_HCFS) |
1433				    HCCONTROL_USB_RESET);
 
1434	case HCCONTROL_USB_RESET:
1435		ret = -EBUSY;
 
1436	default:		/* HCCONTROL_USB_SUSPEND */
1437		spin_unlock_irqrestore(&isp116x->lock, flags);
1438		break;
1439	}
1440
1441	return ret;
1442}
1443
1444static int isp116x_bus_resume(struct usb_hcd *hcd)
1445{
1446	struct isp116x *isp116x = hcd_to_isp116x(hcd);
1447	u32 val;
1448
1449	msleep(5);
1450	spin_lock_irq(&isp116x->lock);
1451
1452	val = isp116x_read_reg32(isp116x, HCCONTROL);
1453	switch (val & HCCONTROL_HCFS) {
1454	case HCCONTROL_USB_SUSPEND:
1455		val &= ~HCCONTROL_HCFS;
1456		val |= HCCONTROL_USB_RESUME;
1457		isp116x_write_reg32(isp116x, HCCONTROL, val);
1458	case HCCONTROL_USB_RESUME:
1459		break;
1460	case HCCONTROL_USB_OPER:
1461		spin_unlock_irq(&isp116x->lock);
1462		return 0;
1463	default:
1464		/* HCCONTROL_USB_RESET: this may happen, when during
1465		   suspension the HC lost power. Reinitialize completely */
1466		spin_unlock_irq(&isp116x->lock);
1467		DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1468		isp116x_reset(hcd);
1469		isp116x_start(hcd);
1470		isp116x_hub_control(hcd, SetPortFeature,
1471				    USB_PORT_FEAT_POWER, 1, NULL, 0);
1472		if ((isp116x->rhdesca & RH_A_NDP) == 2)
1473			isp116x_hub_control(hcd, SetPortFeature,
1474					    USB_PORT_FEAT_POWER, 2, NULL, 0);
1475		return 0;
1476	}
1477
1478	val = isp116x->rhdesca & RH_A_NDP;
1479	while (val--) {
1480		u32 stat =
1481		    isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1482		/* force global, not selective, resume */
1483		if (!(stat & RH_PS_PSS))
1484			continue;
1485		DBG("%s: Resuming port %d\n", __func__, val);
1486		isp116x_write_reg32(isp116x, RH_PS_POCI, val
1487				    ? HCRHPORT2 : HCRHPORT1);
1488	}
1489	spin_unlock_irq(&isp116x->lock);
1490
1491	hcd->state = HC_STATE_RESUMING;
1492	msleep(20);
1493
1494	/* Go operational */
1495	spin_lock_irq(&isp116x->lock);
1496	val = isp116x_read_reg32(isp116x, HCCONTROL);
1497	isp116x_write_reg32(isp116x, HCCONTROL,
1498			    (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1499	spin_unlock_irq(&isp116x->lock);
1500	hcd->state = HC_STATE_RUNNING;
1501
1502	return 0;
1503}
1504
1505#else
1506
1507#define	isp116x_bus_suspend	NULL
1508#define	isp116x_bus_resume	NULL
1509
1510#endif
1511
1512static struct hc_driver isp116x_hc_driver = {
1513	.description = hcd_name,
1514	.product_desc = "ISP116x Host Controller",
1515	.hcd_priv_size = sizeof(struct isp116x),
1516
1517	.irq = isp116x_irq,
1518	.flags = HCD_USB11,
1519
1520	.reset = isp116x_reset,
1521	.start = isp116x_start,
1522	.stop = isp116x_stop,
1523
1524	.urb_enqueue = isp116x_urb_enqueue,
1525	.urb_dequeue = isp116x_urb_dequeue,
1526	.endpoint_disable = isp116x_endpoint_disable,
1527
1528	.get_frame_number = isp116x_get_frame,
1529
1530	.hub_status_data = isp116x_hub_status_data,
1531	.hub_control = isp116x_hub_control,
1532	.bus_suspend = isp116x_bus_suspend,
1533	.bus_resume = isp116x_bus_resume,
1534};
1535
1536/*----------------------------------------------------------------*/
1537
1538static int isp116x_remove(struct platform_device *pdev)
1539{
1540	struct usb_hcd *hcd = platform_get_drvdata(pdev);
1541	struct isp116x *isp116x;
1542	struct resource *res;
1543
1544	if (!hcd)
1545		return 0;
1546	isp116x = hcd_to_isp116x(hcd);
1547	remove_debug_file(isp116x);
1548	usb_remove_hcd(hcd);
1549
1550	iounmap(isp116x->data_reg);
1551	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1552	release_mem_region(res->start, 2);
1553	iounmap(isp116x->addr_reg);
1554	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1555	release_mem_region(res->start, 2);
1556
1557	usb_put_hcd(hcd);
1558	return 0;
1559}
1560
1561static int __devinit isp116x_probe(struct platform_device *pdev)
1562{
1563	struct usb_hcd *hcd;
1564	struct isp116x *isp116x;
1565	struct resource *addr, *data, *ires;
1566	void __iomem *addr_reg;
1567	void __iomem *data_reg;
1568	int irq;
1569	int ret = 0;
1570	unsigned long irqflags;
1571
 
 
 
1572	if (pdev->num_resources < 3) {
1573		ret = -ENODEV;
1574		goto err1;
1575	}
1576
1577	data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1578	addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1579	ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1580
1581	if (!addr || !data || !ires) {
1582		ret = -ENODEV;
1583		goto err1;
1584	}
1585
1586	irq = ires->start;
1587	irqflags = ires->flags & IRQF_TRIGGER_MASK;
1588
1589	if (pdev->dev.dma_mask) {
1590		DBG("DMA not supported\n");
1591		ret = -EINVAL;
1592		goto err1;
1593	}
1594
1595	if (!request_mem_region(addr->start, 2, hcd_name)) {
1596		ret = -EBUSY;
1597		goto err1;
1598	}
1599	addr_reg = ioremap(addr->start, resource_size(addr));
1600	if (addr_reg == NULL) {
1601		ret = -ENOMEM;
1602		goto err2;
1603	}
1604	if (!request_mem_region(data->start, 2, hcd_name)) {
1605		ret = -EBUSY;
1606		goto err3;
1607	}
1608	data_reg = ioremap(data->start, resource_size(data));
1609	if (data_reg == NULL) {
1610		ret = -ENOMEM;
1611		goto err4;
1612	}
1613
1614	/* allocate and initialize hcd */
1615	hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1616	if (!hcd) {
1617		ret = -ENOMEM;
1618		goto err5;
1619	}
1620	/* this rsrc_start is bogus */
1621	hcd->rsrc_start = addr->start;
1622	isp116x = hcd_to_isp116x(hcd);
1623	isp116x->data_reg = data_reg;
1624	isp116x->addr_reg = addr_reg;
1625	spin_lock_init(&isp116x->lock);
1626	INIT_LIST_HEAD(&isp116x->async);
1627	isp116x->board = pdev->dev.platform_data;
1628
1629	if (!isp116x->board) {
1630		ERR("Platform data structure not initialized\n");
1631		ret = -ENODEV;
1632		goto err6;
1633	}
1634	if (isp116x_check_platform_delay(isp116x)) {
1635		ERR("USE_PLATFORM_DELAY defined, but delay function not "
1636		    "implemented.\n");
1637		ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1638		ret = -ENODEV;
1639		goto err6;
1640	}
1641
1642	ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
1643	if (ret)
1644		goto err6;
1645
1646	ret = create_debug_file(isp116x);
1647	if (ret) {
1648		ERR("Couldn't create debugfs entry\n");
1649		goto err7;
1650	}
1651
1652	return 0;
1653
1654      err7:
1655	usb_remove_hcd(hcd);
1656      err6:
1657	usb_put_hcd(hcd);
1658      err5:
1659	iounmap(data_reg);
1660      err4:
1661	release_mem_region(data->start, 2);
1662      err3:
1663	iounmap(addr_reg);
1664      err2:
1665	release_mem_region(addr->start, 2);
1666      err1:
1667	ERR("init error, %d\n", ret);
1668	return ret;
1669}
1670
1671#ifdef	CONFIG_PM
1672/*
1673  Suspend of platform device
1674*/
1675static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1676{
1677	VDBG("%s: state %x\n", __func__, state.event);
1678	return 0;
1679}
1680
1681/*
1682  Resume platform device
1683*/
1684static int isp116x_resume(struct platform_device *dev)
1685{
1686	VDBG("%s\n", __func__);
1687	return 0;
1688}
1689
1690#else
1691
1692#define	isp116x_suspend    NULL
1693#define	isp116x_resume     NULL
1694
1695#endif
1696
1697/* work with hotplug and coldplug */
1698MODULE_ALIAS("platform:isp116x-hcd");
1699
1700static struct platform_driver isp116x_driver = {
1701	.probe = isp116x_probe,
1702	.remove = isp116x_remove,
1703	.suspend = isp116x_suspend,
1704	.resume = isp116x_resume,
1705	.driver = {
1706		.name = (char *)hcd_name,
1707		.owner	= THIS_MODULE,
1708	},
1709};
1710
1711/*-----------------------------------------------------------------*/
1712
1713static int __init isp116x_init(void)
1714{
1715	if (usb_disabled())
1716		return -ENODEV;
1717
1718	INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1719	return platform_driver_register(&isp116x_driver);
1720}
1721
1722module_init(isp116x_init);
1723
1724static void __exit isp116x_cleanup(void)
1725{
1726	platform_driver_unregister(&isp116x_driver);
1727}
1728
1729module_exit(isp116x_cleanup);