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_fsl_susp_errata(ehci))
 314		/*
 315		 * Wait for at least 10 millisecondes to ensure the controller
 316		 * enter the suspend status before initiating a port resume
 317		 * using the Force Port Resume bit (Not-EHCI compatible).
 318		 */
 319		usleep_range(10000, 20000);
 320
 321	if ((changed && ehci->has_tdi_phy_lpm) || fs_idle_delay) {
 322		/*
 323		 * Wait for HCD to enter low-power mode or for the bus
 324		 * to switch to full-speed idle.
 325		 */
 326		usleep_range(5000, 5500);
 327	}
 328
 329	if (changed && ehci->has_tdi_phy_lpm) {
 330		spin_lock_irq(&ehci->lock);
 331		port = HCS_N_PORTS(ehci->hcs_params);
 332		while (port--) {
 333			u32 __iomem	*hostpc_reg = &ehci->regs->hostpc[port];
 334			u32		t3;
 335
 336			t3 = ehci_readl(ehci, hostpc_reg);
 337			ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
 338			t3 = ehci_readl(ehci, hostpc_reg);
 339			ehci_dbg(ehci, "Port %d phy low-power mode %s\n",
 340					port, (t3 & HOSTPC_PHCD) ?
 341					"succeeded" : "failed");
 342		}
 343		spin_unlock_irq(&ehci->lock);
 344	}
 345
 346	/* Apparently some devices need a >= 1-uframe delay here */
 347	if (ehci->bus_suspended)
 348		udelay(150);
 349
 350	/* turn off now-idle HC */
 351	ehci_halt (ehci);
 352
 353	spin_lock_irq(&ehci->lock);
 354	if (ehci->enabled_hrtimer_events & BIT(EHCI_HRTIMER_POLL_DEAD))
 355		ehci_handle_controller_death(ehci);
 356	if (ehci->rh_state != EHCI_RH_RUNNING)
 357		goto done;
 358	ehci->rh_state = EHCI_RH_SUSPENDED;
 359
 
 360	unlink_empty_async_suspended(ehci);
 361
 362	/* Any IAA cycle that started before the suspend is now invalid */
 363	end_iaa_cycle(ehci);
 364	ehci_handle_start_intr_unlinks(ehci);
 365	ehci_handle_intr_unlinks(ehci);
 366	end_free_itds(ehci);
 367
 368	/* allow remote wakeup */
 369	mask = INTR_MASK;
 370	if (!hcd->self.root_hub->do_remote_wakeup)
 371		mask &= ~STS_PCD;
 372	ehci_writel(ehci, mask, &ehci->regs->intr_enable);
 373	ehci_readl(ehci, &ehci->regs->intr_enable);
 374
 375 done:
 376	ehci->next_statechange = jiffies + msecs_to_jiffies(10);
 377	ehci->enabled_hrtimer_events = 0;
 378	ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
 379	spin_unlock_irq (&ehci->lock);
 380
 381	hrtimer_cancel(&ehci->hrtimer);
 382	return 0;
 383}
 384
 385
 386/* caller has locked the root hub, and should reset/reinit on error */
 387static int ehci_bus_resume (struct usb_hcd *hcd)
 388{
 389	struct ehci_hcd		*ehci = hcd_to_ehci (hcd);
 390	u32			temp;
 391	u32			power_okay;
 392	int			i;
 393	unsigned long		resume_needed = 0;
 394
 395	if (time_before (jiffies, ehci->next_statechange))
 396		msleep(5);
 397	spin_lock_irq (&ehci->lock);
 398	if (!HCD_HW_ACCESSIBLE(hcd) || ehci->shutdown)
 399		goto shutdown;
 400
 401	if (unlikely(ehci->debug)) {
 402		if (!dbgp_reset_prep(hcd))
 403			ehci->debug = NULL;
 404		else
 405			dbgp_external_startup(hcd);
 406	}
 407
 408	/* Ideally and we've got a real resume here, and no port's power
 409	 * was lost.  (For PCI, that means Vaux was maintained.)  But we
 410	 * could instead be restoring a swsusp snapshot -- so that BIOS was
 411	 * the last user of the controller, not reset/pm hardware keeping
 412	 * state we gave to it.
 413	 */
 414	power_okay = ehci_readl(ehci, &ehci->regs->intr_enable);
 415	ehci_dbg(ehci, "resume root hub%s\n",
 416			power_okay ? "" : " after power loss");
 417
 418	/* at least some APM implementations will try to deliver
 419	 * IRQs right away, so delay them until we're ready.
 420	 */
 421	ehci_writel(ehci, 0, &ehci->regs->intr_enable);
 422
 423	/* re-init operational registers */
 424	ehci_writel(ehci, 0, &ehci->regs->segment);
 425	ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
 426	ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
 427
 428	/* restore CMD_RUN, framelist size, and irq threshold */
 429	ehci->command |= CMD_RUN;
 430	ehci_writel(ehci, ehci->command, &ehci->regs->command);
 431	ehci->rh_state = EHCI_RH_RUNNING;
 432
 433	/*
 434	 * According to Bugzilla #8190, the port status for some controllers
 435	 * will be wrong without a delay. At their wrong status, the port
 436	 * is enabled, but not suspended neither resumed.
 437	 */
 438	i = HCS_N_PORTS(ehci->hcs_params);
 439	while (i--) {
 440		temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
 441		if ((temp & PORT_PE) &&
 442				!(temp & (PORT_SUSPEND | PORT_RESUME))) {
 443			ehci_dbg(ehci, "Port status(0x%x) is wrong\n", temp);
 444			spin_unlock_irq(&ehci->lock);
 445			msleep(8);
 446			spin_lock_irq(&ehci->lock);
 447			break;
 448		}
 449	}
 450
 451	if (ehci->shutdown)
 452		goto shutdown;
 453
 454	/* clear phy low-power mode before resume */
 455	if (ehci->bus_suspended && ehci->has_tdi_phy_lpm) {
 456		i = HCS_N_PORTS(ehci->hcs_params);
 457		while (i--) {
 458			if (test_bit(i, &ehci->bus_suspended)) {
 459				u32 __iomem	*hostpc_reg =
 460							&ehci->regs->hostpc[i];
 461
 462				temp = ehci_readl(ehci, hostpc_reg);
 463				ehci_writel(ehci, temp & ~HOSTPC_PHCD,
 464						hostpc_reg);
 465			}
 466		}
 467		spin_unlock_irq(&ehci->lock);
 468		msleep(5);
 469		spin_lock_irq(&ehci->lock);
 470		if (ehci->shutdown)
 471			goto shutdown;
 472	}
 473
 474	/* manually resume the ports we suspended during bus_suspend() */
 475	i = HCS_N_PORTS (ehci->hcs_params);
 476	while (i--) {
 477		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
 478		temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
 479		if (test_bit(i, &ehci->bus_suspended) &&
 480				(temp & PORT_SUSPEND)) {
 481			temp |= PORT_RESUME;
 482			set_bit(i, &resume_needed);
 483		}
 484		ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
 485	}
 486
 487	/*
 488	 * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
 489	 * port
 490	 */
 491	if (resume_needed) {
 492		spin_unlock_irq(&ehci->lock);
 493		msleep(USB_RESUME_TIMEOUT);
 494		spin_lock_irq(&ehci->lock);
 495		if (ehci->shutdown)
 496			goto shutdown;
 497	}
 498
 499	i = HCS_N_PORTS (ehci->hcs_params);
 500	while (i--) {
 501		temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
 502		if (test_bit(i, &resume_needed)) {
 503			temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
 504			ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
 505		}
 506	}
 507
 508	ehci->next_statechange = jiffies + msecs_to_jiffies(5);
 509	spin_unlock_irq(&ehci->lock);
 510
 511	ehci_handover_companion_ports(ehci);
 512
 513	/* Now we can safely re-enable irqs */
 514	spin_lock_irq(&ehci->lock);
 515	if (ehci->shutdown)
 516		goto shutdown;
 517	ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
 518	(void) ehci_readl(ehci, &ehci->regs->intr_enable);
 519	spin_unlock_irq(&ehci->lock);
 520
 521	return 0;
 522
 523 shutdown:
 524	spin_unlock_irq(&ehci->lock);
 525	return -ESHUTDOWN;
 526}
 527
 528#else
 529
 530#define ehci_bus_suspend	NULL
 531#define ehci_bus_resume		NULL
 532
 533#endif	/* CONFIG_PM */
 534
 535/*-------------------------------------------------------------------------*/
 536
 537/*
 538 * Sets the owner of a port
 539 */
 540static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
 541{
 542	u32 __iomem		*status_reg;
 543	u32			port_status;
 544	int 			try;
 545
 546	status_reg = &ehci->regs->port_status[portnum];
 547
 548	/*
 549	 * The controller won't set the OWNER bit if the port is
 550	 * enabled, so this loop will sometimes require at least two
 551	 * iterations: one to disable the port and one to set OWNER.
 552	 */
 553	for (try = 4; try > 0; --try) {
 554		spin_lock_irq(&ehci->lock);
 555		port_status = ehci_readl(ehci, status_reg);
 556		if ((port_status & PORT_OWNER) == new_owner
 557				|| (port_status & (PORT_OWNER | PORT_CONNECT))
 558					== 0)
 559			try = 0;
 560		else {
 561			port_status ^= PORT_OWNER;
 562			port_status &= ~(PORT_PE | PORT_RWC_BITS);
 563			ehci_writel(ehci, port_status, status_reg);
 564		}
 565		spin_unlock_irq(&ehci->lock);
 566		if (try > 1)
 567			msleep(5);
 568	}
 569}
 570
 571/*-------------------------------------------------------------------------*/
 572
 573static int check_reset_complete (
 574	struct ehci_hcd	*ehci,
 575	int		index,
 576	u32 __iomem	*status_reg,
 577	int		port_status
 578) {
 579	if (!(port_status & PORT_CONNECT))
 580		return port_status;
 581
 582	/* if reset finished and it's still not enabled -- handoff */
 583	if (!(port_status & PORT_PE)) {
 584
 585		/* with integrated TT, there's nobody to hand it to! */
 586		if (ehci_is_TDI(ehci)) {
 587			ehci_dbg (ehci,
 588				"Failed to enable port %d on root hub TT\n",
 589				index+1);
 590			return port_status;
 591		}
 592
 593		ehci_dbg (ehci, "port %d full speed --> companion\n",
 594			index + 1);
 595
 596		// what happens if HCS_N_CC(params) == 0 ?
 597		port_status |= PORT_OWNER;
 598		port_status &= ~PORT_RWC_BITS;
 599		ehci_writel(ehci, port_status, status_reg);
 600
 601		/* ensure 440EPX ohci controller state is operational */
 602		if (ehci->has_amcc_usb23)
 603			set_ohci_hcfs(ehci, 1);
 604	} else {
 605		ehci_dbg(ehci, "port %d reset complete, port enabled\n",
 606			index + 1);
 607		/* ensure 440EPx ohci controller state is suspended */
 608		if (ehci->has_amcc_usb23)
 609			set_ohci_hcfs(ehci, 0);
 610	}
 611
 612	return port_status;
 613}
 614
 615/*-------------------------------------------------------------------------*/
 616
 617
 618/* build "status change" packet (one or two bytes) from HC registers */
 619
 620static int
 621ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
 622{
 623	struct ehci_hcd	*ehci = hcd_to_ehci (hcd);
 624	u32		temp, status;
 625	u32		mask;
 626	int		ports, i, retval = 1;
 627	unsigned long	flags;
 628	u32		ppcd = ~0;
 629
 630	/* init status to no-changes */
 631	buf [0] = 0;
 632	ports = HCS_N_PORTS (ehci->hcs_params);
 633	if (ports > 7) {
 634		buf [1] = 0;
 635		retval++;
 636	}
 637
 638	/* Inform the core about resumes-in-progress by returning
 639	 * a non-zero value even if there are no status changes.
 640	 */
 641	status = ehci->resuming_ports;
 642
 643	/* Some boards (mostly VIA?) report bogus overcurrent indications,
 644	 * causing massive log spam unless we completely ignore them.  It
 645	 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
 646	 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
 647	 * PORT_POWER; that's surprising, but maybe within-spec.
 648	 */
 649	if (!ignore_oc)
 650		mask = PORT_CSC | PORT_PEC | PORT_OCC;
 651	else
 652		mask = PORT_CSC | PORT_PEC;
 653	// PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
 654
 655	/* no hub change reports (bit 0) for now (power, ...) */
 656
 657	/* port N changes (bit N)? */
 658	spin_lock_irqsave (&ehci->lock, flags);
 659
 660	/* get per-port change detect bits */
 661	if (ehci->has_ppcd)
 662		ppcd = ehci_readl(ehci, &ehci->regs->status) >> 16;
 663
 664	for (i = 0; i < ports; i++) {
 665		/* leverage per-port change bits feature */
 666		if (ppcd & (1 << i))
 667			temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
 668		else
 669			temp = 0;
 670
 671		/*
 672		 * Return status information even for ports with OWNER set.
 673		 * Otherwise hub_wq wouldn't see the disconnect event when a
 674		 * high-speed device is switched over to the companion
 675		 * controller by the user.
 676		 */
 677
 678		if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend)
 679				|| (ehci->reset_done[i] && time_after_eq(
 680					jiffies, ehci->reset_done[i]))) {
 681			if (i < 7)
 682			    buf [0] |= 1 << (i + 1);
 683			else
 684			    buf [1] |= 1 << (i - 7);
 685			status = STS_PCD;
 686		}
 687	}
 688
 689	/* If a resume is in progress, make sure it can finish */
 690	if (ehci->resuming_ports)
 691		mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(25));
 692
 693	spin_unlock_irqrestore (&ehci->lock, flags);
 694	return status ? retval : 0;
 695}
 696
 697/*-------------------------------------------------------------------------*/
 698
 699static void
 700ehci_hub_descriptor (
 701	struct ehci_hcd			*ehci,
 702	struct usb_hub_descriptor	*desc
 703) {
 704	int		ports = HCS_N_PORTS (ehci->hcs_params);
 705	u16		temp;
 706
 707	desc->bDescriptorType = USB_DT_HUB;
 708	desc->bPwrOn2PwrGood = 10;	/* ehci 1.0, 2.3.9 says 20ms max */
 709	desc->bHubContrCurrent = 0;
 710
 711	desc->bNbrPorts = ports;
 712	temp = 1 + (ports / 8);
 713	desc->bDescLength = 7 + 2 * temp;
 714
 715	/* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
 716	memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
 717	memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 718
 719	temp = HUB_CHAR_INDV_PORT_OCPM;	/* per-port overcurrent reporting */
 720	if (HCS_PPC (ehci->hcs_params))
 721		temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */
 722	else
 723		temp |= HUB_CHAR_NO_LPSM; /* no power switching */
 724#if 0
 725// re-enable when we support USB_PORT_FEAT_INDICATOR below.
 726	if (HCS_INDICATOR (ehci->hcs_params))
 727		temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */
 728#endif
 729	desc->wHubCharacteristics = cpu_to_le16(temp);
 730}
 731
 732/*-------------------------------------------------------------------------*/
 733#ifdef CONFIG_USB_HCD_TEST_MODE
 734
 735#define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06
 736
 737static void usb_ehset_completion(struct urb *urb)
 738{
 739	struct completion  *done = urb->context;
 740
 741	complete(done);
 742}
 743static int submit_single_step_set_feature(
 744	struct usb_hcd	*hcd,
 745	struct urb	*urb,
 746	int		is_setup
 747);
 748
 749/*
 750 * Allocate and initialize a control URB. This request will be used by the
 751 * EHSET SINGLE_STEP_SET_FEATURE test in which the DATA and STATUS stages
 752 * of the GetDescriptor request are sent 15 seconds after the SETUP stage.
 753 * Return NULL if failed.
 754 */
 755static struct urb *request_single_step_set_feature_urb(
 756	struct usb_device	*udev,
 757	void			*dr,
 758	void			*buf,
 759	struct completion	*done
 760) {
 761	struct urb *urb;
 762	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 763	struct usb_host_endpoint *ep;
 764
 765	urb = usb_alloc_urb(0, GFP_KERNEL);
 766	if (!urb)
 767		return NULL;
 768
 769	urb->pipe = usb_rcvctrlpipe(udev, 0);
 770	ep = (usb_pipein(urb->pipe) ? udev->ep_in : udev->ep_out)
 771				[usb_pipeendpoint(urb->pipe)];
 772	if (!ep) {
 773		usb_free_urb(urb);
 774		return NULL;
 775	}
 776
 777	urb->ep = ep;
 778	urb->dev = udev;
 779	urb->setup_packet = (void *)dr;
 780	urb->transfer_buffer = buf;
 781	urb->transfer_buffer_length = USB_DT_DEVICE_SIZE;
 782	urb->complete = usb_ehset_completion;
 783	urb->status = -EINPROGRESS;
 784	urb->actual_length = 0;
 785	urb->transfer_flags = URB_DIR_IN;
 786	usb_get_urb(urb);
 787	atomic_inc(&urb->use_count);
 788	atomic_inc(&urb->dev->urbnum);
 789	urb->setup_dma = dma_map_single(
 790			hcd->self.controller,
 791			urb->setup_packet,
 792			sizeof(struct usb_ctrlrequest),
 793			DMA_TO_DEVICE);
 794	urb->transfer_dma = dma_map_single(
 795			hcd->self.controller,
 796			urb->transfer_buffer,
 797			urb->transfer_buffer_length,
 798			DMA_FROM_DEVICE);
 799	urb->context = done;
 800	return urb;
 801}
 802
 803static int ehset_single_step_set_feature(struct usb_hcd *hcd, int port)
 804{
 805	int retval = -ENOMEM;
 806	struct usb_ctrlrequest *dr;
 807	struct urb *urb;
 808	struct usb_device *udev;
 809	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 810	struct usb_device_descriptor *buf;
 811	DECLARE_COMPLETION_ONSTACK(done);
 812
 813	/* Obtain udev of the rhub's child port */
 814	udev = usb_hub_find_child(hcd->self.root_hub, port);
 815	if (!udev) {
 816		ehci_err(ehci, "No device attached to the RootHub\n");
 817		return -ENODEV;
 818	}
 819	buf = kmalloc(USB_DT_DEVICE_SIZE, GFP_KERNEL);
 820	if (!buf)
 821		return -ENOMEM;
 822
 823	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 824	if (!dr) {
 825		kfree(buf);
 826		return -ENOMEM;
 827	}
 828
 829	/* Fill Setup packet for GetDescriptor */
 830	dr->bRequestType = USB_DIR_IN;
 831	dr->bRequest = USB_REQ_GET_DESCRIPTOR;
 832	dr->wValue = cpu_to_le16(USB_DT_DEVICE << 8);
 833	dr->wIndex = 0;
 834	dr->wLength = cpu_to_le16(USB_DT_DEVICE_SIZE);
 835	urb = request_single_step_set_feature_urb(udev, dr, buf, &done);
 836	if (!urb)
 837		goto cleanup;
 838
 839	/* Submit just the SETUP stage */
 840	retval = submit_single_step_set_feature(hcd, urb, 1);
 841	if (retval)
 842		goto out1;
 843	if (!wait_for_completion_timeout(&done, msecs_to_jiffies(2000))) {
 844		usb_kill_urb(urb);
 845		retval = -ETIMEDOUT;
 846		ehci_err(ehci, "%s SETUP stage timed out on ep0\n", __func__);
 847		goto out1;
 848	}
 849	msleep(15 * 1000);
 850
 851	/* Complete remaining DATA and STATUS stages using the same URB */
 852	urb->status = -EINPROGRESS;
 853	usb_get_urb(urb);
 854	atomic_inc(&urb->use_count);
 855	atomic_inc(&urb->dev->urbnum);
 856	retval = submit_single_step_set_feature(hcd, urb, 0);
 857	if (!retval && !wait_for_completion_timeout(&done,
 858						msecs_to_jiffies(2000))) {
 859		usb_kill_urb(urb);
 860		retval = -ETIMEDOUT;
 861		ehci_err(ehci, "%s IN stage timed out on ep0\n", __func__);
 862	}
 863out1:
 864	usb_free_urb(urb);
 865cleanup:
 866	kfree(dr);
 867	kfree(buf);
 868	return retval;
 869}
 870#endif /* CONFIG_USB_HCD_TEST_MODE */
 871/*-------------------------------------------------------------------------*/
 872
 873int ehci_hub_control(
 874	struct usb_hcd	*hcd,
 875	u16		typeReq,
 876	u16		wValue,
 877	u16		wIndex,
 878	char		*buf,
 879	u16		wLength
 880) {
 881	struct ehci_hcd	*ehci = hcd_to_ehci (hcd);
 882	int		ports = HCS_N_PORTS (ehci->hcs_params);
 883	u32 __iomem	*status_reg, *hostpc_reg;
 
 
 884	u32		temp, temp1, status;
 885	unsigned long	flags;
 886	int		retval = 0;
 887	unsigned	selector;
 888
 889	/*
 890	 * Avoid underflow while calculating (wIndex & 0xff) - 1.
 891	 * The compiler might deduce that wIndex can never be 0 and then
 892	 * optimize away the tests for !wIndex below.
 893	 */
 894	temp = wIndex & 0xff;
 895	temp -= (temp > 0);
 896	status_reg = &ehci->regs->port_status[temp];
 897	hostpc_reg = &ehci->regs->hostpc[temp];
 898
 899	/*
 900	 * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
 901	 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
 902	 * (track current state ourselves) ... blink for diagnostics,
 903	 * power, "this is the one", etc.  EHCI spec supports this.
 904	 */
 905
 906	spin_lock_irqsave (&ehci->lock, flags);
 907	switch (typeReq) {
 908	case ClearHubFeature:
 909		switch (wValue) {
 910		case C_HUB_LOCAL_POWER:
 911		case C_HUB_OVER_CURRENT:
 912			/* no hub-wide feature/status flags */
 913			break;
 914		default:
 915			goto error;
 916		}
 917		break;
 918	case ClearPortFeature:
 919		if (!wIndex || wIndex > ports)
 920			goto error;
 921		wIndex--;
 922		temp = ehci_readl(ehci, status_reg);
 923		temp &= ~PORT_RWC_BITS;
 924
 925		/*
 926		 * Even if OWNER is set, so the port is owned by the
 927		 * companion controller, hub_wq needs to be able to clear
 928		 * the port-change status bits (especially
 929		 * USB_PORT_STAT_C_CONNECTION).
 930		 */
 931
 932		switch (wValue) {
 933		case USB_PORT_FEAT_ENABLE:
 934			ehci_writel(ehci, temp & ~PORT_PE, status_reg);
 935			break;
 936		case USB_PORT_FEAT_C_ENABLE:
 937			ehci_writel(ehci, temp | PORT_PEC, status_reg);
 938			break;
 939		case USB_PORT_FEAT_SUSPEND:
 940			if (temp & PORT_RESET)
 941				goto error;
 942			if (ehci->no_selective_suspend)
 943				break;
 944#ifdef CONFIG_USB_OTG
 945			if ((hcd->self.otg_port == (wIndex + 1))
 946			    && hcd->self.b_hnp_enable) {
 947				otg_start_hnp(hcd->usb_phy->otg);
 948				break;
 949			}
 950#endif
 951			if (!(temp & PORT_SUSPEND))
 952				break;
 953			if ((temp & PORT_PE) == 0)
 954				goto error;
 955
 956			/* clear phy low-power mode before resume */
 957			if (ehci->has_tdi_phy_lpm) {
 958				temp1 = ehci_readl(ehci, hostpc_reg);
 959				ehci_writel(ehci, temp1 & ~HOSTPC_PHCD,
 960						hostpc_reg);
 961				spin_unlock_irqrestore(&ehci->lock, flags);
 962				msleep(5);/* wait to leave low-power mode */
 963				spin_lock_irqsave(&ehci->lock, flags);
 964			}
 965			/* resume signaling for 20 msec */
 966			temp &= ~PORT_WAKE_BITS;
 967			ehci_writel(ehci, temp | PORT_RESUME, status_reg);
 968			ehci->reset_done[wIndex] = jiffies
 969					+ msecs_to_jiffies(USB_RESUME_TIMEOUT);
 970			set_bit(wIndex, &ehci->resuming_ports);
 971			usb_hcd_start_port_resume(&hcd->self, wIndex);
 972			break;
 973		case USB_PORT_FEAT_C_SUSPEND:
 974			clear_bit(wIndex, &ehci->port_c_suspend);
 975			break;
 976		case USB_PORT_FEAT_POWER:
 977			if (HCS_PPC(ehci->hcs_params)) {
 978				spin_unlock_irqrestore(&ehci->lock, flags);
 979				ehci_port_power(ehci, wIndex, false);
 980				spin_lock_irqsave(&ehci->lock, flags);
 981			}
 982			break;
 983		case USB_PORT_FEAT_C_CONNECTION:
 984			ehci_writel(ehci, temp | PORT_CSC, status_reg);
 985			break;
 986		case USB_PORT_FEAT_C_OVER_CURRENT:
 987			ehci_writel(ehci, temp | PORT_OCC, status_reg);
 988			break;
 989		case USB_PORT_FEAT_C_RESET:
 990			/* GetPortStatus clears reset */
 991			break;
 992		default:
 993			goto error;
 994		}
 995		ehci_readl(ehci, &ehci->regs->command);	/* unblock posted write */
 996		break;
 997	case GetHubDescriptor:
 998		ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
 999			buf);
1000		break;
1001	case GetHubStatus:
1002		/* no hub-wide feature/status flags */
1003		memset (buf, 0, 4);
1004		//cpu_to_le32s ((u32 *) buf);
1005		break;
1006	case GetPortStatus:
1007		if (!wIndex || wIndex > ports)
1008			goto error;
1009		wIndex--;
1010		status = 0;
1011		temp = ehci_readl(ehci, status_reg);
1012
1013		// wPortChange bits
1014		if (temp & PORT_CSC)
1015			status |= USB_PORT_STAT_C_CONNECTION << 16;
1016		if (temp & PORT_PEC)
1017			status |= USB_PORT_STAT_C_ENABLE << 16;
1018
1019		if ((temp & PORT_OCC) && !ignore_oc){
1020			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
1021
1022			/*
1023			 * Hubs should disable port power on over-current.
1024			 * However, not all EHCI implementations do this
1025			 * automatically, even if they _do_ support per-port
1026			 * power switching; they're allowed to just limit the
1027			 * current.  hub_wq will turn the power back on.
1028			 */
1029			if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle))
1030					&& HCS_PPC(ehci->hcs_params)) {
1031				spin_unlock_irqrestore(&ehci->lock, flags);
1032				ehci_port_power(ehci, wIndex, false);
1033				spin_lock_irqsave(&ehci->lock, flags);
1034				temp = ehci_readl(ehci, status_reg);
1035			}
1036		}
1037
1038		/* no reset or resume pending */
1039		if (!ehci->reset_done[wIndex]) {
1040
1041			/* Remote Wakeup received? */
1042			if (temp & PORT_RESUME) {
1043				/* resume signaling for 20 msec */
1044				ehci->reset_done[wIndex] = jiffies
1045						+ msecs_to_jiffies(20);
1046				usb_hcd_start_port_resume(&hcd->self, wIndex);
1047				set_bit(wIndex, &ehci->resuming_ports);
1048				/* check the port again */
1049				mod_timer(&ehci_to_hcd(ehci)->rh_timer,
1050						ehci->reset_done[wIndex]);
1051			}
1052
1053		/* reset or resume not yet complete */
1054		} else if (!time_after_eq(jiffies, ehci->reset_done[wIndex])) {
1055			;	/* wait until it is complete */
1056
1057		/* resume completed */
1058		} else if (test_bit(wIndex, &ehci->resuming_ports)) {
1059			clear_bit(wIndex, &ehci->suspended_ports);
1060			set_bit(wIndex, &ehci->port_c_suspend);
1061			ehci->reset_done[wIndex] = 0;
1062			usb_hcd_end_port_resume(&hcd->self, wIndex);
1063
1064			/* stop resume signaling */
1065			temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
1066			ehci_writel(ehci, temp, status_reg);
1067			clear_bit(wIndex, &ehci->resuming_ports);
1068			retval = ehci_handshake(ehci, status_reg,
1069					PORT_RESUME, 0, 2000 /* 2msec */);
1070			if (retval != 0) {
1071				ehci_err(ehci, "port %d resume error %d\n",
1072						wIndex + 1, retval);
1073				goto error;
1074			}
1075			temp = ehci_readl(ehci, status_reg);
1076
1077		/* whoever resets must GetPortStatus to complete it!! */
1078		} else {
1079			status |= USB_PORT_STAT_C_RESET << 16;
1080			ehci->reset_done [wIndex] = 0;
1081
1082			/* force reset to complete */
1083			ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
1084					status_reg);
1085			/* REVISIT:  some hardware needs 550+ usec to clear
1086			 * this bit; seems too long to spin routinely...
1087			 */
1088			retval = ehci_handshake(ehci, status_reg,
1089					PORT_RESET, 0, 1000);
1090			if (retval != 0) {
1091				ehci_err (ehci, "port %d reset error %d\n",
1092					wIndex + 1, retval);
1093				goto error;
1094			}
1095
1096			/* see what we found out */
1097			temp = check_reset_complete (ehci, wIndex, status_reg,
1098					ehci_readl(ehci, status_reg));
1099		}
1100
1101		/* transfer dedicated ports to the companion hc */
1102		if ((temp & PORT_CONNECT) &&
1103				test_bit(wIndex, &ehci->companion_ports)) {
1104			temp &= ~PORT_RWC_BITS;
1105			temp |= PORT_OWNER;
1106			ehci_writel(ehci, temp, status_reg);
1107			ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
1108			temp = ehci_readl(ehci, status_reg);
1109		}
1110
1111		/*
1112		 * Even if OWNER is set, there's no harm letting hub_wq
1113		 * see the wPortStatus values (they should all be 0 except
1114		 * for PORT_POWER anyway).
1115		 */
1116
1117		if (temp & PORT_CONNECT) {
1118			status |= USB_PORT_STAT_CONNECTION;
1119			// status may be from integrated TT
1120			if (ehci->has_hostpc) {
1121				temp1 = ehci_readl(ehci, hostpc_reg);
1122				status |= ehci_port_speed(ehci, temp1);
1123			} else
1124				status |= ehci_port_speed(ehci, temp);
1125		}
1126		if (temp & PORT_PE)
1127			status |= USB_PORT_STAT_ENABLE;
1128
1129		/* maybe the port was unsuspended without our knowledge */
1130		if (temp & (PORT_SUSPEND|PORT_RESUME)) {
1131			status |= USB_PORT_STAT_SUSPEND;
1132		} else if (test_bit(wIndex, &ehci->suspended_ports)) {
1133			clear_bit(wIndex, &ehci->suspended_ports);
1134			clear_bit(wIndex, &ehci->resuming_ports);
1135			ehci->reset_done[wIndex] = 0;
1136			if (temp & PORT_PE)
1137				set_bit(wIndex, &ehci->port_c_suspend);
1138			usb_hcd_end_port_resume(&hcd->self, wIndex);
1139		}
1140
1141		if (temp & PORT_OC)
1142			status |= USB_PORT_STAT_OVERCURRENT;
1143		if (temp & PORT_RESET)
1144			status |= USB_PORT_STAT_RESET;
1145		if (temp & PORT_POWER)
1146			status |= USB_PORT_STAT_POWER;
1147		if (test_bit(wIndex, &ehci->port_c_suspend))
1148			status |= USB_PORT_STAT_C_SUSPEND << 16;
1149
1150		if (status & ~0xffff)	/* only if wPortChange is interesting */
1151			dbg_port(ehci, "GetStatus", wIndex + 1, temp);
1152		put_unaligned_le32(status, buf);
1153		break;
1154	case SetHubFeature:
1155		switch (wValue) {
1156		case C_HUB_LOCAL_POWER:
1157		case C_HUB_OVER_CURRENT:
1158			/* no hub-wide feature/status flags */
1159			break;
1160		default:
1161			goto error;
1162		}
1163		break;
1164	case SetPortFeature:
1165		selector = wIndex >> 8;
1166		wIndex &= 0xff;
1167		if (unlikely(ehci->debug)) {
1168			/* If the debug port is active any port
1169			 * feature requests should get denied */
1170			if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) &&
1171			    (readl(&ehci->debug->control) & DBGP_ENABLED)) {
1172				retval = -ENODEV;
1173				goto error_exit;
1174			}
1175		}
1176		if (!wIndex || wIndex > ports)
1177			goto error;
1178		wIndex--;
1179		temp = ehci_readl(ehci, status_reg);
1180		if (temp & PORT_OWNER)
1181			break;
1182
1183		temp &= ~PORT_RWC_BITS;
1184		switch (wValue) {
1185		case USB_PORT_FEAT_SUSPEND:
1186			if (ehci->no_selective_suspend)
1187				break;
1188			if ((temp & PORT_PE) == 0
1189					|| (temp & PORT_RESET) != 0)
1190				goto error;
1191
1192			/* After above check the port must be connected.
1193			 * Set appropriate bit thus could put phy into low power
1194			 * mode if we have tdi_phy_lpm feature
1195			 */
1196			temp &= ~PORT_WKCONN_E;
1197			temp |= PORT_WKDISC_E | PORT_WKOC_E;
1198			ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
1199			if (ehci->has_tdi_phy_lpm) {
1200				spin_unlock_irqrestore(&ehci->lock, flags);
1201				msleep(5);/* 5ms for HCD enter low pwr mode */
1202				spin_lock_irqsave(&ehci->lock, flags);
1203				temp1 = ehci_readl(ehci, hostpc_reg);
1204				ehci_writel(ehci, temp1 | HOSTPC_PHCD,
1205					hostpc_reg);
1206				temp1 = ehci_readl(ehci, hostpc_reg);
1207				ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
1208					wIndex, (temp1 & HOSTPC_PHCD) ?
1209					"succeeded" : "failed");
1210			}
1211			if (ehci_has_fsl_susp_errata(ehci)) {
1212				/* 10ms for HCD enter suspend */
1213				spin_unlock_irqrestore(&ehci->lock, flags);
1214				usleep_range(10000, 20000);
1215				spin_lock_irqsave(&ehci->lock, flags);
1216			}
1217			set_bit(wIndex, &ehci->suspended_ports);
1218			break;
1219		case USB_PORT_FEAT_POWER:
1220			if (HCS_PPC(ehci->hcs_params)) {
1221				spin_unlock_irqrestore(&ehci->lock, flags);
1222				ehci_port_power(ehci, wIndex, true);
1223				spin_lock_irqsave(&ehci->lock, flags);
1224			}
1225			break;
1226		case USB_PORT_FEAT_RESET:
1227			if (temp & (PORT_SUSPEND|PORT_RESUME))
1228				goto error;
1229			/* line status bits may report this as low speed,
1230			 * which can be fine if this root hub has a
1231			 * transaction translator built in.
1232			 */
1233			if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
1234					&& !ehci_is_TDI(ehci)
1235					&& PORT_USB11 (temp)) {
1236				ehci_dbg (ehci,
1237					"port %d low speed --> companion\n",
1238					wIndex + 1);
1239				temp |= PORT_OWNER;
1240			} else {
1241				temp |= PORT_RESET;
1242				temp &= ~PORT_PE;
1243
1244				/*
1245				 * caller must wait, then call GetPortStatus
1246				 * usb 2.0 spec says 50 ms resets on root
1247				 */
1248				ehci->reset_done [wIndex] = jiffies
1249						+ msecs_to_jiffies (50);
1250
1251				/*
1252				 * Force full-speed connect for FSL high-speed
1253				 * erratum; disable HS Chirp by setting PFSC bit
1254				 */
1255				if (ehci_has_fsl_hs_errata(ehci))
1256					temp |= (1 << PORTSC_FSL_PFSC);
1257			}
1258			ehci_writel(ehci, temp, status_reg);
1259			break;
1260
1261		/* For downstream facing ports (these):  one hub port is put
1262		 * into test mode according to USB2 11.24.2.13, then the hub
1263		 * must be reset (which for root hub now means rmmod+modprobe,
1264		 * or else system reboot).  See EHCI 2.3.9 and 4.14 for info
1265		 * about the EHCI-specific stuff.
1266		 */
1267		case USB_PORT_FEAT_TEST:
1268#ifdef CONFIG_USB_HCD_TEST_MODE
1269			if (selector == EHSET_TEST_SINGLE_STEP_SET_FEATURE) {
1270				spin_unlock_irqrestore(&ehci->lock, flags);
1271				retval = ehset_single_step_set_feature(hcd,
1272								wIndex + 1);
1273				spin_lock_irqsave(&ehci->lock, flags);
1274				break;
1275			}
1276#endif
1277			if (!selector || selector > 5)
1278				goto error;
1279			spin_unlock_irqrestore(&ehci->lock, flags);
1280			ehci_quiesce(ehci);
1281			spin_lock_irqsave(&ehci->lock, flags);
1282
1283			/* Put all enabled ports into suspend */
1284			while (ports--) {
1285				u32 __iomem *sreg =
1286						&ehci->regs->port_status[ports];
1287
1288				temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
1289				if (temp & PORT_PE)
1290					ehci_writel(ehci, temp | PORT_SUSPEND,
1291							sreg);
1292			}
1293
1294			spin_unlock_irqrestore(&ehci->lock, flags);
1295			ehci_halt(ehci);
1296			spin_lock_irqsave(&ehci->lock, flags);
1297
1298			temp = ehci_readl(ehci, status_reg);
1299			temp |= selector << 16;
1300			ehci_writel(ehci, temp, status_reg);
1301			break;
1302
1303		default:
1304			goto error;
1305		}
1306		ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */
1307		break;
1308
1309	default:
1310error:
1311		/* "stall" on error */
1312		retval = -EPIPE;
1313	}
1314error_exit:
1315	spin_unlock_irqrestore (&ehci->lock, flags);
1316	return retval;
1317}
1318EXPORT_SYMBOL_GPL(ehci_hub_control);
1319
1320static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
1321{
1322	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
1323
1324	if (ehci_is_TDI(ehci))
1325		return;
1326	set_owner(ehci, --portnum, PORT_OWNER);
1327}
1328
1329static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
1330{
1331	struct ehci_hcd		*ehci = hcd_to_ehci(hcd);
1332	u32 __iomem		*reg;
1333
1334	if (ehci_is_TDI(ehci))
1335		return 0;
1336	reg = &ehci->regs->port_status[portnum - 1];
1337	return ehci_readl(ehci, reg) & PORT_OWNER;
1338}
1339
1340static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable)
1341{
1342	struct usb_hcd *hcd = ehci_to_hcd(ehci);
1343	u32 __iomem *status_reg = &ehci->regs->port_status[portnum];
1344	u32 temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
1345
1346	if (enable)
1347		ehci_writel(ehci, temp | PORT_POWER, status_reg);
1348	else
1349		ehci_writel(ehci, temp & ~PORT_POWER, status_reg);
1350
1351	if (hcd->driver->port_power)
1352		hcd->driver->port_power(hcd, portnum, enable);
1353
1354	return 0;
1355}