1/*
   2 * Copyright (C) 2001-2004 by David Brownell
   3 *
   4 * This program is free software; you can redistribute it and/or modify it
   5 * under the terms of the GNU General Public License as published by the
   6 * Free Software Foundation; either version 2 of the License, or (at your
   7 * option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful, but
  10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 * for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write to the Free Software Foundation,
  16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19/* this file is part of ehci-hcd.c */
  20
  21/*-------------------------------------------------------------------------*/
  22
  23/*
  24 * EHCI Root Hub ... the nonsharable stuff
  25 *
  26 * Registers don't need cpu_to_le32, that happens transparently
  27 */
  28
  29/*-------------------------------------------------------------------------*/
  30#include <linux/usb/otg.h>
  31
  32#define	PORT_WAKE_BITS	(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
  33
  34#ifdef	CONFIG_PM
  35
  36static void unlink_empty_async_suspended(struct ehci_hcd *ehci);
 
 
 
 
 
 
 
  37
  38static int persist_enabled_on_companion(struct usb_device *udev, void *unused)
  39{
  40	return !udev->maxchild && udev->persist_enabled &&
  41		udev->bus->root_hub->speed < USB_SPEED_HIGH;
  42}
  43
  44/* After a power loss, ports that were owned by the companion must be
  45 * reset so that the companion can still own them.
  46 */
  47static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
  48{
  49	u32 __iomem	*reg;
  50	u32		status;
  51	int		port;
  52	__le32		buf;
  53	struct usb_hcd	*hcd = ehci_to_hcd(ehci);
  54
  55	if (!ehci->owned_ports)
  56		return;
  57
  58	/*
  59	 * USB 1.1 devices are mostly HIDs, which don't need to persist across
  60	 * suspends. If we ensure that none of our companion's devices have
  61	 * persist_enabled (by looking through all USB 1.1 buses in the system),
  62	 * we can skip this and avoid slowing resume down. Devices without
  63	 * persist will just get reenumerated shortly after resume anyway.
  64	 */
  65	if (!usb_for_each_dev(NULL, persist_enabled_on_companion))
  66		return;
  67
  68	/* Make sure the ports are powered */
  69	port = HCS_N_PORTS(ehci->hcs_params);
  70	while (port--) {
  71		if (test_bit(port, &ehci->owned_ports)) {
  72			reg = &ehci->regs->port_status[port];
  73			status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
  74			if (!(status & PORT_POWER))
  75				ehci_port_power(ehci, port, true);
 
 
  76		}
  77	}
  78
  79	/* Give the connections some time to appear */
  80	msleep(20);
  81
  82	spin_lock_irq(&ehci->lock);
  83	port = HCS_N_PORTS(ehci->hcs_params);
  84	while (port--) {
  85		if (test_bit(port, &ehci->owned_ports)) {
  86			reg = &ehci->regs->port_status[port];
  87			status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
  88
  89			/* Port already owned by companion? */
  90			if (status & PORT_OWNER)
  91				clear_bit(port, &ehci->owned_ports);
  92			else if (test_bit(port, &ehci->companion_ports))
  93				ehci_writel(ehci, status & ~PORT_PE, reg);
  94			else {
  95				spin_unlock_irq(&ehci->lock);
  96				ehci_hub_control(hcd, SetPortFeature,
  97						USB_PORT_FEAT_RESET, port + 1,
  98						NULL, 0);
  99				spin_lock_irq(&ehci->lock);
 100			}
 101		}
 102	}
 103	spin_unlock_irq(&ehci->lock);
 104
 105	if (!ehci->owned_ports)
 106		return;
 107	msleep(90);		/* Wait for resets to complete */
 108
 109	spin_lock_irq(&ehci->lock);
 110	port = HCS_N_PORTS(ehci->hcs_params);
 111	while (port--) {
 112		if (test_bit(port, &ehci->owned_ports)) {
 113			spin_unlock_irq(&ehci->lock);
 114			ehci_hub_control(hcd, GetPortStatus,
 115					0, port + 1,
 116					(char *) &buf, sizeof(buf));
 117			spin_lock_irq(&ehci->lock);
 118
 119			/* The companion should now own the port,
 120			 * but if something went wrong the port must not
 121			 * remain enabled.
 122			 */
 123			reg = &ehci->regs->port_status[port];
 124			status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 125			if (status & PORT_OWNER)
 126				ehci_writel(ehci, status | PORT_CSC, reg);
 127			else {
 128				ehci_dbg(ehci, "failed handover port %d: %x\n",
 129						port + 1, status);
 130				ehci_writel(ehci, status & ~PORT_PE, reg);
 131			}
 132		}
 133	}
 134
 135	ehci->owned_ports = 0;
 136	spin_unlock_irq(&ehci->lock);
 137}
 138
 139static int ehci_port_change(struct ehci_hcd *ehci)
 140{
 141	int i = HCS_N_PORTS(ehci->hcs_params);
 142
 143	/* First check if the controller indicates a change event */
 144
 145	if (ehci_readl(ehci, &ehci->regs->status) & STS_PCD)
 146		return 1;
 147
 148	/*
 149	 * Not all controllers appear to update this while going from D3 to D0,
 150	 * so check the individual port status registers as well
 151	 */
 152
 153	while (i--)
 154		if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC)
 155			return 1;
 156
 157	return 0;
 158}
 159
 160void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
 161		bool suspending, bool do_wakeup)
 162{
 163	int		port;
 164	u32		temp;
 165
 166	/* If remote wakeup is enabled for the root hub but disabled
 167	 * for the controller, we must adjust all the port wakeup flags
 168	 * when the controller is suspended or resumed.  In all other
 169	 * cases they don't need to be changed.
 170	 */
 171	if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup)
 172		return;
 173
 174	spin_lock_irq(&ehci->lock);
 175
 176	/* clear phy low-power mode before changing wakeup flags */
 177	if (ehci->has_tdi_phy_lpm) {
 178		port = HCS_N_PORTS(ehci->hcs_params);
 179		while (port--) {
 180			u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[port];
 181
 182			temp = ehci_readl(ehci, hostpc_reg);
 183			ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg);
 184		}
 185		spin_unlock_irq(&ehci->lock);
 186		msleep(5);
 187		spin_lock_irq(&ehci->lock);
 188	}
 189
 190	port = HCS_N_PORTS(ehci->hcs_params);
 191	while (port--) {
 192		u32 __iomem	*reg = &ehci->regs->port_status[port];
 193		u32		t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 194		u32		t2 = t1 & ~PORT_WAKE_BITS;
 195
 196		/* If we are suspending the controller, clear the flags.
 197		 * If we are resuming the controller, set the wakeup flags.
 198		 */
 199		if (!suspending) {
 200			if (t1 & PORT_CONNECT)
 201				t2 |= PORT_WKOC_E | PORT_WKDISC_E;
 202			else
 203				t2 |= PORT_WKOC_E | PORT_WKCONN_E;
 204		}
 205		ehci_writel(ehci, t2, reg);
 206	}
 207
 208	/* enter phy low-power mode again */
 209	if (ehci->has_tdi_phy_lpm) {
 210		port = HCS_N_PORTS(ehci->hcs_params);
 211		while (port--) {
 212			u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[port];
 213
 214			temp = ehci_readl(ehci, hostpc_reg);
 215			ehci_writel(ehci, temp | HOSTPC_PHCD, hostpc_reg);
 216		}
 217	}
 218
 219	/* Does the root hub have a port wakeup pending? */
 220	if (!suspending && ehci_port_change(ehci))
 221		usb_hcd_resume_root_hub(ehci_to_hcd(ehci));
 222
 223	spin_unlock_irq(&ehci->lock);
 224}
 225EXPORT_SYMBOL_GPL(ehci_adjust_port_wakeup_flags);
 226
 227static int ehci_bus_suspend (struct usb_hcd *hcd)
 228{
 229	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
 230	int			port;
 231	int			mask;
 232	int			changed;
 233	bool			fs_idle_delay;
 234
 235	ehci_dbg(ehci, "suspend root hub\n");
 236
 237	if (time_before (jiffies, ehci->next_statechange))
 238		msleep(5);
 239
 240	/* stop the schedules */
 241	ehci_quiesce(ehci);
 242
 243	spin_lock_irq (&ehci->lock);
 244	if (ehci->rh_state < EHCI_RH_RUNNING)
 245		goto done;
 246
 247	/* Once the controller is stopped, port resumes that are already
 248	 * in progress won't complete.  Hence if remote wakeup is enabled
 249	 * for the root hub and any ports are in the middle of a resume or
 250	 * remote wakeup, we must fail the suspend.
 251	 */
 252	if (hcd->self.root_hub->do_remote_wakeup) {
 253		if (ehci->resuming_ports) {
 254			spin_unlock_irq(&ehci->lock);
 255			ehci_dbg(ehci, "suspend failed because a port is resuming\n");
 256			return -EBUSY;
 257		}
 258	}
 259
 260	/* Unlike other USB host controller types, EHCI doesn't have
 261	 * any notion of "global" or bus-wide suspend.  The driver has
 262	 * to manually suspend all the active unsuspended ports, and
 263	 * then manually resume them in the bus_resume() routine.
 264	 */
 265	ehci->bus_suspended = 0;
 266	ehci->owned_ports = 0;
 267	changed = 0;
 268	fs_idle_delay = false;
 269	port = HCS_N_PORTS(ehci->hcs_params);
 270	while (port--) {
 271		u32 __iomem	*reg = &ehci->regs->port_status [port];
 272		u32		t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
 273		u32		t2 = t1 & ~PORT_WAKE_BITS;
 274
 275		/* keep track of which ports we suspend */
 276		if (t1 & PORT_OWNER)
 277			set_bit(port, &ehci->owned_ports);
 278		else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) {
 279			t2 |= PORT_SUSPEND;
 280			set_bit(port, &ehci->bus_suspended);
 281		}
 282
 283		/* enable remote wakeup on all ports, if told to do so */
 284		if (hcd->self.root_hub->do_remote_wakeup) {
 285			/* only enable appropriate wake bits, otherwise the
 286			 * hardware can not go phy low power mode. If a race
 287			 * condition happens here(connection change during bits
 288			 * set), the port change detection will finally fix it.
 289			 */
 290			if (t1 & PORT_CONNECT)
 291				t2 |= PORT_WKOC_E | PORT_WKDISC_E;
 292			else
 293				t2 |= PORT_WKOC_E | PORT_WKCONN_E;
 294		}
 295
 296		if (t1 != t2) {
 297			/*
 298			 * On some controllers, Wake-On-Disconnect will
 299			 * generate false wakeup signals until the bus
 300			 * switches over to full-speed idle.  For their
 301			 * sake, add a delay if we need one.
 302			 */
 303			if ((t2 & PORT_WKDISC_E) &&
 304					ehci_port_speed(ehci, t2) ==
 305						USB_PORT_STAT_HIGH_SPEED)
 306				fs_idle_delay = true;
 307			ehci_writel(ehci, t2, reg);
 308			changed = 1;
 309		}
 310	}
 311	spin_unlock_irq(&ehci->lock);
 312
 313	if ((changed && ehci->has_tdi_phy_lpm) || fs_idle_delay) {
 314		/*
 315		 * Wait for HCD to enter low-power mode or for the bus
 316		 * to switch to full-speed idle.
 317		 */
 318		usleep_range(5000, 5500);
 319	}
 320
 321	if (changed && ehci->has_tdi_phy_lpm) {
 322		spin_lock_irq(&ehci->lock);
 323		port = HCS_N_PORTS(ehci->hcs_params);
 324		while (port--) {
 325			u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[port];
 326			u32		t3;
 327
 328			t3 = ehci_readl(ehci, hostpc_reg);
 329			ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
 330			t3 = ehci_readl(ehci, hostpc_reg);
 331			ehci_dbg(ehci, "Port %d phy low-power mode %s\n",
 332					port, (t3 & HOSTPC_PHCD) ?
 333					"succeeded" : "failed");
 334		}
 335		spin_unlock_irq(&ehci->lock);
 336	}
 337
 338	/* Apparently some devices need a >= 1-uframe delay here */
 339	if (ehci->bus_suspended)
 340		udelay(150);
 341
 342	/* turn off now-idle HC */
 343	ehci_halt (ehci);
 344
 345	spin_lock_irq(&ehci->lock);
 346	if (ehci->enabled_hrtimer_events & BIT(EHCI_HRTIMER_POLL_DEAD))
 347		ehci_handle_controller_death(ehci);
 348	if (ehci->rh_state != EHCI_RH_RUNNING)
 349		goto done;
 350	ehci->rh_state = EHCI_RH_SUSPENDED;
 351
 
 352	unlink_empty_async_suspended(ehci);
 353
 354	/* Any IAA cycle that started before the suspend is now invalid */
 355	end_iaa_cycle(ehci);
 356	ehci_handle_start_intr_unlinks(ehci);
 357	ehci_handle_intr_unlinks(ehci);
 358	end_free_itds(ehci);
 359
 360	/* allow remote wakeup */
 361	mask = INTR_MASK;
 362	if (!hcd->self.root_hub->do_remote_wakeup)
 363		mask &= ~STS_PCD;
 364	ehci_writel(ehci, mask, &ehci->regs->intr_enable);
 365	ehci_readl(ehci, &ehci->regs->intr_enable);
 366
 367 done:
 368	ehci->next_statechange = jiffies + msecs_to_jiffies(10);
 369	ehci->enabled_hrtimer_events = 0;
 370	ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
 371	spin_unlock_irq (&ehci->lock);
 372
 373	hrtimer_cancel(&ehci->hrtimer);
 374	return 0;
 375}
 376
 377
 378/* caller has locked the root hub, and should reset/reinit on error */
 379static int ehci_bus_resume (struct usb_hcd *hcd)
 380{
 381	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
 382	u32			temp;
 383	u32			power_okay;
 384	int			i;
 385	unsigned long		resume_needed = 0;
 386
 387	if (time_before (jiffies, ehci->next_statechange))
 388		msleep(5);
 389	spin_lock_irq (&ehci->lock);
 390	if (!HCD_HW_ACCESSIBLE(hcd) || ehci->shutdown)
 391		goto shutdown;
 392
 393	if (unlikely(ehci->debug)) {
 394		if (!dbgp_reset_prep(hcd))
 395			ehci->debug = NULL;
 396		else
 397			dbgp_external_startup(hcd);
 398	}
 399
 400	/* Ideally and we've got a real resume here, and no port's power
 401	 * was lost.  (For PCI, that means Vaux was maintained.)  But we
 402	 * could instead be restoring a swsusp snapshot -- so that BIOS was
 403	 * the last user of the controller, not reset/pm hardware keeping
 404	 * state we gave to it.
 405	 */
 406	power_okay = ehci_readl(ehci, &ehci->regs->intr_enable);
 407	ehci_dbg(ehci, "resume root hub%s\n",
 408			power_okay ? "" : " after power loss");
 409
 410	/* at least some APM implementations will try to deliver
 411	 * IRQs right away, so delay them until we're ready.
 412	 */
 413	ehci_writel(ehci, 0, &ehci->regs->intr_enable);
 414
 415	/* re-init operational registers */
 416	ehci_writel(ehci, 0, &ehci->regs->segment);
 417	ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
 418	ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
 419
 420	/* restore CMD_RUN, framelist size, and irq threshold */
 421	ehci->command |= CMD_RUN;
 422	ehci_writel(ehci, ehci->command, &ehci->regs->command);
 423	ehci->rh_state = EHCI_RH_RUNNING;
 424
 425	/*
 426	 * According to Bugzilla #8190, the port status for some controllers
 427	 * will be wrong without a delay. At their wrong status, the port
 428	 * is enabled, but not suspended neither resumed.
 429	 */
 430	i = HCS_N_PORTS(ehci->hcs_params);
 431	while (i--) {
 432		temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
 433		if ((temp & PORT_PE) &&
 434				!(temp & (PORT_SUSPEND | PORT_RESUME))) {
 435			ehci_dbg(ehci, "Port status(0x%x) is wrong\n", temp);
 436			spin_unlock_irq(&ehci->lock);
 437			msleep(8);
 438			spin_lock_irq(&ehci->lock);
 439			break;
 440		}
 441	}
 442
 443	if (ehci->shutdown)
 444		goto shutdown;
 445
 446	/* clear phy low-power mode before resume */
 447	if (ehci->bus_suspended && ehci->has_tdi_phy_lpm) {
 448		i = HCS_N_PORTS(ehci->hcs_params);
 449		while (i--) {
 450			if (test_bit(i, &ehci->bus_suspended)) {
 451				u32 __iomem	*hostpc_reg =
 452							&ehci->regs->hostpc[i];
 453
 454				temp = ehci_readl(ehci, hostpc_reg);
 455				ehci_writel(ehci, temp & ~HOSTPC_PHCD,
 456						hostpc_reg);
 457			}
 458		}
 459		spin_unlock_irq(&ehci->lock);
 460		msleep(5);
 461		spin_lock_irq(&ehci->lock);
 462		if (ehci->shutdown)
 463			goto shutdown;
 464	}
 465
 466	/* manually resume the ports we suspended during bus_suspend() */
 467	i = HCS_N_PORTS (ehci->hcs_params);
 468	while (i--) {
 469		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
 470		temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
 471		if (test_bit(i, &ehci->bus_suspended) &&
 472				(temp & PORT_SUSPEND)) {
 473			temp |= PORT_RESUME;
 474			set_bit(i, &resume_needed);
 475		}
 476		ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
 477	}
 478
 479	/*
 480	 * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
 481	 * port
 482	 */
 483	if (resume_needed) {
 484		spin_unlock_irq(&ehci->lock);
 485		msleep(USB_RESUME_TIMEOUT);
 486		spin_lock_irq(&ehci->lock);
 487		if (ehci->shutdown)
 488			goto shutdown;
 489	}
 490
 491	i = HCS_N_PORTS (ehci->hcs_params);
 492	while (i--) {
 493		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
 494		if (test_bit(i, &resume_needed)) {
 495			temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
 496			ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
 497		}
 498	}
 499
 500	ehci->next_statechange = jiffies + msecs_to_jiffies(5);
 501	spin_unlock_irq(&ehci->lock);
 502
 503	ehci_handover_companion_ports(ehci);
 504
 505	/* Now we can safely re-enable irqs */
 506	spin_lock_irq(&ehci->lock);
 507	if (ehci->shutdown)
 508		goto shutdown;
 509	ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
 510	(void) ehci_readl(ehci, &ehci->regs->intr_enable);
 511	spin_unlock_irq(&ehci->lock);
 512
 513	return 0;
 514
 515 shutdown:
 516	spin_unlock_irq(&ehci->lock);
 517	return -ESHUTDOWN;
 518}
 519
 520#else
 521
 522#define ehci_bus_suspend	NULL
 523#define ehci_bus_resume		NULL
 524
 525#endif	/* CONFIG_PM */
 526
 527/*-------------------------------------------------------------------------*/
 528
 529/*
 530 * Sets the owner of a port
 531 */
 532static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
 533{
 534	u32 __iomem		*status_reg;
 535	u32			port_status;
 536	int 			try;
 537
 538	status_reg = &ehci->regs->port_status[portnum];
 539
 540	/*
 541	 * The controller won't set the OWNER bit if the port is
 542	 * enabled, so this loop will sometimes require at least two
 543	 * iterations: one to disable the port and one to set OWNER.
 544	 */
 545	for (try = 4; try > 0; --try) {
 546		spin_lock_irq(&ehci->lock);
 547		port_status = ehci_readl(ehci, status_reg);
 548		if ((port_status & PORT_OWNER) == new_owner
 549				|| (port_status & (PORT_OWNER | PORT_CONNECT))
 550					== 0)
 551			try = 0;
 552		else {
 553			port_status ^= PORT_OWNER;
 554			port_status &= ~(PORT_PE | PORT_RWC_BITS);
 555			ehci_writel(ehci, port_status, status_reg);
 556		}
 557		spin_unlock_irq(&ehci->lock);
 558		if (try > 1)
 559			msleep(5);
 560	}
 561}
 562
 563/*-------------------------------------------------------------------------*/
 564
 565static int check_reset_complete (
 566	struct ehci_hcd	*ehci,
 567	int		index,
 568	u32 __iomem	*status_reg,
 569	int		port_status
 570) {
 571	if (!(port_status & PORT_CONNECT))
 572		return port_status;
 573
 574	/* if reset finished and it's still not enabled -- handoff */
 575	if (!(port_status & PORT_PE)) {
 576
 577		/* with integrated TT, there's nobody to hand it to! */
 578		if (ehci_is_TDI(ehci)) {
 579			ehci_dbg (ehci,
 580				"Failed to enable port %d on root hub TT\n",
 581				index+1);
 582			return port_status;
 583		}
 584
 585		ehci_dbg (ehci, "port %d full speed --> companion\n",
 586			index + 1);
 587
 588		// what happens if HCS_N_CC(params) == 0 ?
 589		port_status |= PORT_OWNER;
 590		port_status &= ~PORT_RWC_BITS;
 591		ehci_writel(ehci, port_status, status_reg);
 592
 593		/* ensure 440EPX ohci controller state is operational */
 594		if (ehci->has_amcc_usb23)
 595			set_ohci_hcfs(ehci, 1);
 596	} else {
 597		ehci_dbg(ehci, "port %d reset complete, port enabled\n",
 598			index + 1);
 599		/* ensure 440EPx ohci controller state is suspended */
 600		if (ehci->has_amcc_usb23)
 601			set_ohci_hcfs(ehci, 0);
 602	}
 603
 604	return port_status;
 605}
 606
 607/*-------------------------------------------------------------------------*/
 608
 609
 610/* build "status change" packet (one or two bytes) from HC registers */
 611
 612static int
 613ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
 614{
 615	struct ehci_hcd	*ehci = hcd_to_ehci (hcd);
 616	u32		temp, status;
 617	u32		mask;
 618	int		ports, i, retval = 1;
 619	unsigned long	flags;
 620	u32		ppcd = ~0;
 621
 622	/* init status to no-changes */
 623	buf [0] = 0;
 624	ports = HCS_N_PORTS (ehci->hcs_params);
 625	if (ports > 7) {
 626		buf [1] = 0;
 627		retval++;
 628	}
 629
 630	/* Inform the core about resumes-in-progress by returning
 631	 * a non-zero value even if there are no status changes.
 632	 */
 633	status = ehci->resuming_ports;
 634
 635	/* Some boards (mostly VIA?) report bogus overcurrent indications,
 636	 * causing massive log spam unless we completely ignore them.  It
 637	 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
 638	 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
 639	 * PORT_POWER; that's surprising, but maybe within-spec.
 640	 */
 641	if (!ignore_oc)
 642		mask = PORT_CSC | PORT_PEC | PORT_OCC;
 643	else
 644		mask = PORT_CSC | PORT_PEC;
 645	// PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
 646
 647	/* no hub change reports (bit 0) for now (power, ...) */
 648
 649	/* port N changes (bit N)? */
 650	spin_lock_irqsave (&ehci->lock, flags);
 651
 652	/* get per-port change detect bits */
 653	if (ehci->has_ppcd)
 654		ppcd = ehci_readl(ehci, &ehci->regs->status) >> 16;
 655
 656	for (i = 0; i < ports; i++) {
 657		/* leverage per-port change bits feature */
 658		if (ppcd & (1 << i))
 659			temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
 660		else
 661			temp = 0;
 662
 663		/*
 664		 * Return status information even for ports with OWNER set.
 665		 * Otherwise hub_wq wouldn't see the disconnect event when a
 666		 * high-speed device is switched over to the companion
 667		 * controller by the user.
 668		 */
 669
 670		if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend)
 671				|| (ehci->reset_done[i] && time_after_eq(
 672					jiffies, ehci->reset_done[i]))) {
 673			if (i < 7)
 674			    buf [0] |= 1 << (i + 1);
 675			else
 676			    buf [1] |= 1 << (i - 7);
 677			status = STS_PCD;
 678		}
 679	}
 680
 681	/* If a resume is in progress, make sure it can finish */
 682	if (ehci->resuming_ports)
 683		mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(25));
 684
 685	spin_unlock_irqrestore (&ehci->lock, flags);
 686	return status ? retval : 0;
 687}
 688
 689/*-------------------------------------------------------------------------*/
 690
 691static void
 692ehci_hub_descriptor (
 693	struct ehci_hcd			*ehci,
 694	struct usb_hub_descriptor	*desc
 695) {
 696	int		ports = HCS_N_PORTS (ehci->hcs_params);
 697	u16		temp;
 698
 699	desc->bDescriptorType = USB_DT_HUB;
 700	desc->bPwrOn2PwrGood = 10;	/* ehci 1.0, 2.3.9 says 20ms max */
 701	desc->bHubContrCurrent = 0;
 702
 703	desc->bNbrPorts = ports;
 704	temp = 1 + (ports / 8);
 705	desc->bDescLength = 7 + 2 * temp;
 706
 707	/* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
 708	memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
 709	memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 710
 711	temp = HUB_CHAR_INDV_PORT_OCPM;	/* per-port overcurrent reporting */
 712	if (HCS_PPC (ehci->hcs_params))
 713		temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */
 714	else
 715		temp |= HUB_CHAR_NO_LPSM; /* no power switching */
 716#if 0
 717// re-enable when we support USB_PORT_FEAT_INDICATOR below.
 718	if (HCS_INDICATOR (ehci->hcs_params))
 719		temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */
 720#endif
 721	desc->wHubCharacteristics = cpu_to_le16(temp);
 722}
 723
 724/*-------------------------------------------------------------------------*/
 725#ifdef CONFIG_USB_HCD_TEST_MODE
 726
 727#define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06
 728
 729static void usb_ehset_completion(struct urb *urb)
 730{
 731	struct completion  *done = urb->context;
 732
 733	complete(done);
 734}
 735static int submit_single_step_set_feature(
 736	struct usb_hcd	*hcd,
 737	struct urb	*urb,
 738	int		is_setup
 739);
 740
 741/*
 742 * Allocate and initialize a control URB. This request will be used by the
 743 * EHSET SINGLE_STEP_SET_FEATURE test in which the DATA and STATUS stages
 744 * of the GetDescriptor request are sent 15 seconds after the SETUP stage.
 745 * Return NULL if failed.
 746 */
 747static struct urb *request_single_step_set_feature_urb(
 748	struct usb_device	*udev,
 749	void			*dr,
 750	void			*buf,
 751	struct completion	*done
 752) {
 753	struct urb *urb;
 754	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 755	struct usb_host_endpoint *ep;
 756
 757	urb = usb_alloc_urb(0, GFP_KERNEL);
 758	if (!urb)
 759		return NULL;
 760
 761	urb->pipe = usb_rcvctrlpipe(udev, 0);
 762	ep = (usb_pipein(urb->pipe) ? udev->ep_in : udev->ep_out)
 763				[usb_pipeendpoint(urb->pipe)];
 764	if (!ep) {
 765		usb_free_urb(urb);
 766		return NULL;
 767	}
 768
 769	urb->ep = ep;
 770	urb->dev = udev;
 771	urb->setup_packet = (void *)dr;
 772	urb->transfer_buffer = buf;
 773	urb->transfer_buffer_length = USB_DT_DEVICE_SIZE;
 774	urb->complete = usb_ehset_completion;
 775	urb->status = -EINPROGRESS;
 776	urb->actual_length = 0;
 777	urb->transfer_flags = URB_DIR_IN;
 778	usb_get_urb(urb);
 779	atomic_inc(&urb->use_count);
 780	atomic_inc(&urb->dev->urbnum);
 781	urb->setup_dma = dma_map_single(
 782			hcd->self.controller,
 783			urb->setup_packet,
 784			sizeof(struct usb_ctrlrequest),
 785			DMA_TO_DEVICE);
 786	urb->transfer_dma = dma_map_single(
 787			hcd->self.controller,
 788			urb->transfer_buffer,
 789			urb->transfer_buffer_length,
 790			DMA_FROM_DEVICE);
 791	urb->context = done;
 792	return urb;
 793}
 794
 795static int ehset_single_step_set_feature(struct usb_hcd *hcd, int port)
 796{
 797	int retval = -ENOMEM;
 798	struct usb_ctrlrequest *dr;
 799	struct urb *urb;
 800	struct usb_device *udev;
 801	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 802	struct usb_device_descriptor *buf;
 803	DECLARE_COMPLETION_ONSTACK(done);
 804
 805	/* Obtain udev of the rhub's child port */
 806	udev = usb_hub_find_child(hcd->self.root_hub, port);
 807	if (!udev) {
 808		ehci_err(ehci, "No device attached to the RootHub\n");
 809		return -ENODEV;
 810	}
 811	buf = kmalloc(USB_DT_DEVICE_SIZE, GFP_KERNEL);
 812	if (!buf)
 813		return -ENOMEM;
 814
 815	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 816	if (!dr) {
 817		kfree(buf);
 818		return -ENOMEM;
 819	}
 820
 821	/* Fill Setup packet for GetDescriptor */
 822	dr->bRequestType = USB_DIR_IN;
 823	dr->bRequest = USB_REQ_GET_DESCRIPTOR;
 824	dr->wValue = cpu_to_le16(USB_DT_DEVICE << 8);
 825	dr->wIndex = 0;
 826	dr->wLength = cpu_to_le16(USB_DT_DEVICE_SIZE);
 827	urb = request_single_step_set_feature_urb(udev, dr, buf, &done);
 828	if (!urb)
 829		goto cleanup;
 830
 831	/* Submit just the SETUP stage */
 832	retval = submit_single_step_set_feature(hcd, urb, 1);
 833	if (retval)
 834		goto out1;
 835	if (!wait_for_completion_timeout(&done, msecs_to_jiffies(2000))) {
 836		usb_kill_urb(urb);
 837		retval = -ETIMEDOUT;
 838		ehci_err(ehci, "%s SETUP stage timed out on ep0\n", __func__);
 839		goto out1;
 840	}
 841	msleep(15 * 1000);
 842
 843	/* Complete remaining DATA and STATUS stages using the same URB */
 844	urb->status = -EINPROGRESS;
 845	usb_get_urb(urb);
 846	atomic_inc(&urb->use_count);
 847	atomic_inc(&urb->dev->urbnum);
 848	retval = submit_single_step_set_feature(hcd, urb, 0);
 849	if (!retval && !wait_for_completion_timeout(&done,
 850						msecs_to_jiffies(2000))) {
 851		usb_kill_urb(urb);
 852		retval = -ETIMEDOUT;
 853		ehci_err(ehci, "%s IN stage timed out on ep0\n", __func__);
 854	}
 855out1:
 856	usb_free_urb(urb);
 857cleanup:
 858	kfree(dr);
 859	kfree(buf);
 860	return retval;
 861}
 862#endif /* CONFIG_USB_HCD_TEST_MODE */
 863/*-------------------------------------------------------------------------*/
 864
 865int ehci_hub_control(
 866	struct usb_hcd	*hcd,
 867	u16		typeReq,
 868	u16		wValue,
 869	u16		wIndex,
 870	char		*buf,
 871	u16		wLength
 872) {
 873	struct ehci_hcd	*ehci = hcd_to_ehci (hcd);
 874	int		ports = HCS_N_PORTS (ehci->hcs_params);
 875	u32 __iomem	*status_reg = &ehci->regs->port_status[
 876				(wIndex & 0xff) - 1];
 877	u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[(wIndex & 0xff) - 1];
 878	u32		temp, temp1, status;
 879	unsigned long	flags;
 880	int		retval = 0;
 881	unsigned	selector;
 882
 883	/*
 884	 * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
 885	 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
 886	 * (track current state ourselves) ... blink for diagnostics,
 887	 * power, "this is the one", etc.  EHCI spec supports this.
 888	 */
 889
 890	spin_lock_irqsave (&ehci->lock, flags);
 891	switch (typeReq) {
 892	case ClearHubFeature:
 893		switch (wValue) {
 894		case C_HUB_LOCAL_POWER:
 895		case C_HUB_OVER_CURRENT:
 896			/* no hub-wide feature/status flags */
 897			break;
 898		default:
 899			goto error;
 900		}
 901		break;
 902	case ClearPortFeature:
 903		if (!wIndex || wIndex > ports)
 904			goto error;
 905		wIndex--;
 906		temp = ehci_readl(ehci, status_reg);
 907		temp &= ~PORT_RWC_BITS;
 908
 909		/*
 910		 * Even if OWNER is set, so the port is owned by the
 911		 * companion controller, hub_wq needs to be able to clear
 912		 * the port-change status bits (especially
 913		 * USB_PORT_STAT_C_CONNECTION).
 914		 */
 915
 916		switch (wValue) {
 917		case USB_PORT_FEAT_ENABLE:
 918			ehci_writel(ehci, temp & ~PORT_PE, status_reg);
 919			break;
 920		case USB_PORT_FEAT_C_ENABLE:
 921			ehci_writel(ehci, temp | PORT_PEC, status_reg);
 922			break;
 923		case USB_PORT_FEAT_SUSPEND:
 924			if (temp & PORT_RESET)
 925				goto error;
 926			if (ehci->no_selective_suspend)
 927				break;
 928#ifdef CONFIG_USB_OTG
 929			if ((hcd->self.otg_port == (wIndex + 1))
 930			    && hcd->self.b_hnp_enable) {
 931				otg_start_hnp(hcd->usb_phy->otg);
 932				break;
 933			}
 934#endif
 935			if (!(temp & PORT_SUSPEND))
 936				break;
 937			if ((temp & PORT_PE) == 0)
 938				goto error;
 939
 940			/* clear phy low-power mode before resume */
 941			if (ehci->has_tdi_phy_lpm) {
 942				temp1 = ehci_readl(ehci, hostpc_reg);
 943				ehci_writel(ehci, temp1 & ~HOSTPC_PHCD,
 944						hostpc_reg);
 945				spin_unlock_irqrestore(&ehci->lock, flags);
 946				msleep(5);/* wait to leave low-power mode */
 947				spin_lock_irqsave(&ehci->lock, flags);
 948			}
 949			/* resume signaling for 20 msec */
 950			temp &= ~PORT_WAKE_BITS;
 951			ehci_writel(ehci, temp | PORT_RESUME, status_reg);
 952			ehci->reset_done[wIndex] = jiffies
 953					+ msecs_to_jiffies(USB_RESUME_TIMEOUT);
 954			set_bit(wIndex, &ehci->resuming_ports);
 955			usb_hcd_start_port_resume(&hcd->self, wIndex);
 956			break;
 957		case USB_PORT_FEAT_C_SUSPEND:
 958			clear_bit(wIndex, &ehci->port_c_suspend);
 959			break;
 960		case USB_PORT_FEAT_POWER:
 961			if (HCS_PPC(ehci->hcs_params)) {
 962				spin_unlock_irqrestore(&ehci->lock, flags);
 963				ehci_port_power(ehci, wIndex, false);
 964				spin_lock_irqsave(&ehci->lock, flags);
 965			}
 966			break;
 967		case USB_PORT_FEAT_C_CONNECTION:
 968			ehci_writel(ehci, temp | PORT_CSC, status_reg);
 969			break;
 970		case USB_PORT_FEAT_C_OVER_CURRENT:
 971			ehci_writel(ehci, temp | PORT_OCC, status_reg);
 972			break;
 973		case USB_PORT_FEAT_C_RESET:
 974			/* GetPortStatus clears reset */
 975			break;
 976		default:
 977			goto error;
 978		}
 979		ehci_readl(ehci, &ehci->regs->command);	/* unblock posted write */
 980		break;
 981	case GetHubDescriptor:
 982		ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
 983			buf);
 984		break;
 985	case GetHubStatus:
 986		/* no hub-wide feature/status flags */
 987		memset (buf, 0, 4);
 988		//cpu_to_le32s ((u32 *) buf);
 989		break;
 990	case GetPortStatus:
 991		if (!wIndex || wIndex > ports)
 992			goto error;
 993		wIndex--;
 994		status = 0;
 995		temp = ehci_readl(ehci, status_reg);
 996
 997		// wPortChange bits
 998		if (temp & PORT_CSC)
 999			status |= USB_PORT_STAT_C_CONNECTION << 16;
1000		if (temp & PORT_PEC)
1001			status |= USB_PORT_STAT_C_ENABLE << 16;
1002
1003		if ((temp & PORT_OCC) && !ignore_oc){
1004			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
1005
1006			/*
1007			 * Hubs should disable port power on over-current.
1008			 * However, not all EHCI implementations do this
1009			 * automatically, even if they _do_ support per-port
1010			 * power switching; they're allowed to just limit the
1011			 * current.  hub_wq will turn the power back on.
1012			 */
1013			if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle))
1014					&& HCS_PPC(ehci->hcs_params)) {
1015				spin_unlock_irqrestore(&ehci->lock, flags);
1016				ehci_port_power(ehci, wIndex, false);
1017				spin_lock_irqsave(&ehci->lock, flags);
1018				temp = ehci_readl(ehci, status_reg);
1019			}
1020		}
1021
1022		/* no reset or resume pending */
1023		if (!ehci->reset_done[wIndex]) {
1024
1025			/* Remote Wakeup received? */
1026			if (temp & PORT_RESUME) {
1027				/* resume signaling for 20 msec */
1028				ehci->reset_done[wIndex] = jiffies
1029						+ msecs_to_jiffies(20);
1030				usb_hcd_start_port_resume(&hcd->self, wIndex);
1031				set_bit(wIndex, &ehci->resuming_ports);
1032				/* check the port again */
1033				mod_timer(&ehci_to_hcd(ehci)->rh_timer,
1034						ehci->reset_done[wIndex]);
1035			}
1036
1037		/* reset or resume not yet complete */
1038		} else if (!time_after_eq(jiffies, ehci->reset_done[wIndex])) {
1039			;	/* wait until it is complete */
1040
1041		/* resume completed */
1042		} else if (test_bit(wIndex, &ehci->resuming_ports)) {
1043			clear_bit(wIndex, &ehci->suspended_ports);
1044			set_bit(wIndex, &ehci->port_c_suspend);
1045			ehci->reset_done[wIndex] = 0;
1046			usb_hcd_end_port_resume(&hcd->self, wIndex);
1047
1048			/* stop resume signaling */
1049			temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
1050			ehci_writel(ehci, temp, status_reg);
1051			clear_bit(wIndex, &ehci->resuming_ports);
1052			retval = ehci_handshake(ehci, status_reg,
1053					PORT_RESUME, 0, 2000 /* 2msec */);
1054			if (retval != 0) {
1055				ehci_err(ehci, "port %d resume error %d\n",
1056						wIndex + 1, retval);
1057				goto error;
1058			}
1059			temp = ehci_readl(ehci, status_reg);
1060
1061		/* whoever resets must GetPortStatus to complete it!! */
1062		} else {
1063			status |= USB_PORT_STAT_C_RESET << 16;
1064			ehci->reset_done [wIndex] = 0;
1065
1066			/* force reset to complete */
1067			ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
1068					status_reg);
1069			/* REVISIT:  some hardware needs 550+ usec to clear
1070			 * this bit; seems too long to spin routinely...
1071			 */
1072			retval = ehci_handshake(ehci, status_reg,
1073					PORT_RESET, 0, 1000);
1074			if (retval != 0) {
1075				ehci_err (ehci, "port %d reset error %d\n",
1076					wIndex + 1, retval);
1077				goto error;
1078			}
1079
1080			/* see what we found out */
1081			temp = check_reset_complete (ehci, wIndex, status_reg,
1082					ehci_readl(ehci, status_reg));
1083		}
1084
1085		/* transfer dedicated ports to the companion hc */
1086		if ((temp & PORT_CONNECT) &&
1087				test_bit(wIndex, &ehci->companion_ports)) {
1088			temp &= ~PORT_RWC_BITS;
1089			temp |= PORT_OWNER;
1090			ehci_writel(ehci, temp, status_reg);
1091			ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
1092			temp = ehci_readl(ehci, status_reg);
1093		}
1094
1095		/*
1096		 * Even if OWNER is set, there's no harm letting hub_wq
1097		 * see the wPortStatus values (they should all be 0 except
1098		 * for PORT_POWER anyway).
1099		 */
1100
1101		if (temp & PORT_CONNECT) {
1102			status |= USB_PORT_STAT_CONNECTION;
1103			// status may be from integrated TT
1104			if (ehci->has_hostpc) {
1105				temp1 = ehci_readl(ehci, hostpc_reg);
1106				status |= ehci_port_speed(ehci, temp1);
1107			} else
1108				status |= ehci_port_speed(ehci, temp);
1109		}
1110		if (temp & PORT_PE)
1111			status |= USB_PORT_STAT_ENABLE;
1112
1113		/* maybe the port was unsuspended without our knowledge */
1114		if (temp & (PORT_SUSPEND|PORT_RESUME)) {
1115			status |= USB_PORT_STAT_SUSPEND;
1116		} else if (test_bit(wIndex, &ehci->suspended_ports)) {
1117			clear_bit(wIndex, &ehci->suspended_ports);
1118			clear_bit(wIndex, &ehci->resuming_ports);
1119			ehci->reset_done[wIndex] = 0;
1120			if (temp & PORT_PE)
1121				set_bit(wIndex, &ehci->port_c_suspend);
1122			usb_hcd_end_port_resume(&hcd->self, wIndex);
1123		}
1124
1125		if (temp & PORT_OC)
1126			status |= USB_PORT_STAT_OVERCURRENT;
1127		if (temp & PORT_RESET)
1128			status |= USB_PORT_STAT_RESET;
1129		if (temp & PORT_POWER)
1130			status |= USB_PORT_STAT_POWER;
1131		if (test_bit(wIndex, &ehci->port_c_suspend))
1132			status |= USB_PORT_STAT_C_SUSPEND << 16;
1133
1134		if (status & ~0xffff)	/* only if wPortChange is interesting */
1135			dbg_port(ehci, "GetStatus", wIndex + 1, temp);
1136		put_unaligned_le32(status, buf);
1137		break;
1138	case SetHubFeature:
1139		switch (wValue) {
1140		case C_HUB_LOCAL_POWER:
1141		case C_HUB_OVER_CURRENT:
1142			/* no hub-wide feature/status flags */
1143			break;
1144		default:
1145			goto error;
1146		}
1147		break;
1148	case SetPortFeature:
1149		selector = wIndex >> 8;
1150		wIndex &= 0xff;
1151		if (unlikely(ehci->debug)) {
1152			/* If the debug port is active any port
1153			 * feature requests should get denied */
1154			if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) &&
1155			    (readl(&ehci->debug->control) & DBGP_ENABLED)) {
1156				retval = -ENODEV;
1157				goto error_exit;
1158			}
1159		}
1160		if (!wIndex || wIndex > ports)
1161			goto error;
1162		wIndex--;
1163		temp = ehci_readl(ehci, status_reg);
1164		if (temp & PORT_OWNER)
1165			break;
1166
1167		temp &= ~PORT_RWC_BITS;
1168		switch (wValue) {
1169		case USB_PORT_FEAT_SUSPEND:
1170			if (ehci->no_selective_suspend)
1171				break;
1172			if ((temp & PORT_PE) == 0
1173					|| (temp & PORT_RESET) != 0)
1174				goto error;
1175
1176			/* After above check the port must be connected.
1177			 * Set appropriate bit thus could put phy into low power
1178			 * mode if we have tdi_phy_lpm feature
1179			 */
1180			temp &= ~PORT_WKCONN_E;
1181			temp |= PORT_WKDISC_E | PORT_WKOC_E;
1182			ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
1183			if (ehci->has_tdi_phy_lpm) {
1184				spin_unlock_irqrestore(&ehci->lock, flags);
1185				msleep(5);/* 5ms for HCD enter low pwr mode */
1186				spin_lock_irqsave(&ehci->lock, flags);
1187				temp1 = ehci_readl(ehci, hostpc_reg);
1188				ehci_writel(ehci, temp1 | HOSTPC_PHCD,
1189					hostpc_reg);
1190				temp1 = ehci_readl(ehci, hostpc_reg);
1191				ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
1192					wIndex, (temp1 & HOSTPC_PHCD) ?
1193					"succeeded" : "failed");
1194			}
1195			set_bit(wIndex, &ehci->suspended_ports);
1196			break;
1197		case USB_PORT_FEAT_POWER:
1198			if (HCS_PPC(ehci->hcs_params)) {
1199				spin_unlock_irqrestore(&ehci->lock, flags);
1200				ehci_port_power(ehci, wIndex, true);
1201				spin_lock_irqsave(&ehci->lock, flags);
1202			}
1203			break;
1204		case USB_PORT_FEAT_RESET:
1205			if (temp & (PORT_SUSPEND|PORT_RESUME))
1206				goto error;
1207			/* line status bits may report this as low speed,
1208			 * which can be fine if this root hub has a
1209			 * transaction translator built in.
1210			 */
1211			if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
1212					&& !ehci_is_TDI(ehci)
1213					&& PORT_USB11 (temp)) {
1214				ehci_dbg (ehci,
1215					"port %d low speed --> companion\n",
1216					wIndex + 1);
1217				temp |= PORT_OWNER;
1218			} else {
1219				temp |= PORT_RESET;
1220				temp &= ~PORT_PE;
1221
1222				/*
1223				 * caller must wait, then call GetPortStatus
1224				 * usb 2.0 spec says 50 ms resets on root
1225				 */
1226				ehci->reset_done [wIndex] = jiffies
1227						+ msecs_to_jiffies (50);
1228
1229				/*
1230				 * Force full-speed connect for FSL high-speed
1231				 * erratum; disable HS Chirp by setting PFSC bit
1232				 */
1233				if (ehci_has_fsl_hs_errata(ehci))
1234					temp |= (1 << PORTSC_FSL_PFSC);
1235			}
1236			ehci_writel(ehci, temp, status_reg);
1237			break;
1238
1239		/* For downstream facing ports (these):  one hub port is put
1240		 * into test mode according to USB2 11.24.2.13, then the hub
1241		 * must be reset (which for root hub now means rmmod+modprobe,
1242		 * or else system reboot).  See EHCI 2.3.9 and 4.14 for info
1243		 * about the EHCI-specific stuff.
1244		 */
1245		case USB_PORT_FEAT_TEST:
1246#ifdef CONFIG_USB_HCD_TEST_MODE
1247			if (selector == EHSET_TEST_SINGLE_STEP_SET_FEATURE) {
1248				spin_unlock_irqrestore(&ehci->lock, flags);
1249				retval = ehset_single_step_set_feature(hcd,
1250								wIndex + 1);
1251				spin_lock_irqsave(&ehci->lock, flags);
1252				break;
1253			}
1254#endif
1255			if (!selector || selector > 5)
1256				goto error;
1257			spin_unlock_irqrestore(&ehci->lock, flags);
1258			ehci_quiesce(ehci);
1259			spin_lock_irqsave(&ehci->lock, flags);
1260
1261			/* Put all enabled ports into suspend */
1262			while (ports--) {
1263				u32 __iomem *sreg =
1264						&ehci->regs->port_status[ports];
1265
1266				temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
1267				if (temp & PORT_PE)
1268					ehci_writel(ehci, temp | PORT_SUSPEND,
1269							sreg);
1270			}
1271
1272			spin_unlock_irqrestore(&ehci->lock, flags);
1273			ehci_halt(ehci);
1274			spin_lock_irqsave(&ehci->lock, flags);
1275
1276			temp = ehci_readl(ehci, status_reg);
1277			temp |= selector << 16;
1278			ehci_writel(ehci, temp, status_reg);
1279			break;
1280
1281		default:
1282			goto error;
1283		}
1284		ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */
1285		break;
1286
1287	default:
1288error:
1289		/* "stall" on error */
1290		retval = -EPIPE;
1291	}
1292error_exit:
1293	spin_unlock_irqrestore (&ehci->lock, flags);
1294	return retval;
1295}
1296EXPORT_SYMBOL_GPL(ehci_hub_control);
1297
1298static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
1299{
1300	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
1301
1302	if (ehci_is_TDI(ehci))
1303		return;
1304	set_owner(ehci, --portnum, PORT_OWNER);
1305}
1306
1307static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
1308{
1309	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
1310	u32 __iomem		*reg;
1311
1312	if (ehci_is_TDI(ehci))
1313		return 0;
1314	reg = &ehci->regs->port_status[portnum - 1];
1315	return ehci_readl(ehci, reg) & PORT_OWNER;
1316}
1317
1318static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable)
1319{
1320	struct usb_hcd *hcd = ehci_to_hcd(ehci);
1321	u32 __iomem *status_reg = &ehci->regs->port_status[portnum];
1322	u32 temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
1323
1324	if (enable)
1325		ehci_writel(ehci, temp | PORT_POWER, status_reg);
1326	else
1327		ehci_writel(ehci, temp & ~PORT_POWER, status_reg);
1328
1329	if (hcd->driver->port_power)
1330		hcd->driver->port_power(hcd, portnum, enable);
1331
1332	return 0;
1333}