xhci-hub.c 27.3 KB
Newer Older
Sarah Sharp's avatar
Sarah Sharp committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * xHCI host controller driver
 *
 * Copyright (C) 2008 Intel Corp.
 *
 * Author: Sarah Sharp
 * Some code borrowed from the Linux EHCI driver.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <asm/unaligned.h>

#include "xhci.h"

27 28 29 30
#define	PORT_WAKE_BITS	(PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E)
#define	PORT_RWC_BITS	(PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
			 PORT_RC | PORT_PLC | PORT_PE)

31 32
static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
		struct usb_hub_descriptor *desc, int ports)
Sarah Sharp's avatar
Sarah Sharp committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
{
	u16 temp;

	desc->bPwrOn2PwrGood = 10;	/* xhci section 5.4.9 says 20ms max */
	desc->bHubContrCurrent = 0;

	desc->bNbrPorts = ports;
	/* Ugh, these should be #defines, FIXME */
	/* Using table 11-13 in USB 2.0 spec. */
	temp = 0;
	/* Bits 1:0 - support port power switching, or power always on */
	if (HCC_PPC(xhci->hcc_params))
		temp |= 0x0001;
	else
		temp |= 0x0002;
	/* Bit  2 - root hubs are not part of a compound device */
	/* Bits 4:3 - individual port over current protection */
	temp |= 0x0008;
	/* Bits 6:5 - no TTs in root ports */
	/* Bit  7 - no port indicators */
53
	desc->wHubCharacteristics = cpu_to_le16(temp);
Sarah Sharp's avatar
Sarah Sharp committed
54 55
}

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
/* Fill in the USB 2.0 roothub descriptor */
static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		struct usb_hub_descriptor *desc)
{
	int ports;
	u16 temp;
	__u8 port_removable[(USB_MAXCHILDREN + 1 + 7) / 8];
	u32 portsc;
	unsigned int i;

	ports = xhci->num_usb2_ports;

	xhci_common_hub_descriptor(xhci, desc, ports);
	desc->bDescriptorType = 0x29;
	temp = 1 + (ports / 8);
	desc->bDescLength = 7 + 2 * temp;

	/* The Device Removable bits are reported on a byte granularity.
	 * If the port doesn't exist within that byte, the bit is set to 0.
	 */
	memset(port_removable, 0, sizeof(port_removable));
	for (i = 0; i < ports; i++) {
		portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
		/* If a device is removable, PORTSC reports a 0, same as in the
		 * hub descriptor DeviceRemovable bits.
		 */
		if (portsc & PORT_DEV_REMOVE)
			/* This math is hairy because bit 0 of DeviceRemovable
			 * is reserved, and bit 1 is for port 1, etc.
			 */
			port_removable[(i + 1) / 8] |= 1 << ((i + 1) % 8);
	}

	/* ch11.h defines a hub descriptor that has room for USB_MAXCHILDREN
	 * ports on it.  The USB 2.0 specification says that there are two
	 * variable length fields at the end of the hub descriptor:
	 * DeviceRemovable and PortPwrCtrlMask.  But since we can have less than
	 * USB_MAXCHILDREN ports, we may need to use the DeviceRemovable array
	 * to set PortPwrCtrlMask bits.  PortPwrCtrlMask must always be set to
	 * 0xFF, so we initialize the both arrays (DeviceRemovable and
	 * PortPwrCtrlMask) to 0xFF.  Then we set the DeviceRemovable for each
	 * set of ports that actually exist.
	 */
	memset(desc->u.hs.DeviceRemovable, 0xff,
			sizeof(desc->u.hs.DeviceRemovable));
	memset(desc->u.hs.PortPwrCtrlMask, 0xff,
			sizeof(desc->u.hs.PortPwrCtrlMask));

	for (i = 0; i < (ports + 1 + 7) / 8; i++)
		memset(&desc->u.hs.DeviceRemovable[i], port_removable[i],
				sizeof(__u8));
}

/* Fill in the USB 3.0 roothub descriptor */
static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		struct usb_hub_descriptor *desc)
{
	int ports;
	u16 port_removable;
	u32 portsc;
	unsigned int i;

	ports = xhci->num_usb3_ports;
	xhci_common_hub_descriptor(xhci, desc, ports);
	desc->bDescriptorType = 0x2a;
	desc->bDescLength = 12;

	/* header decode latency should be zero for roothubs,
	 * see section 4.23.5.2.
	 */
	desc->u.ss.bHubHdrDecLat = 0;
	desc->u.ss.wHubDelay = 0;

	port_removable = 0;
	/* bit 0 is reserved, bit 1 is for port 1, etc. */
	for (i = 0; i < ports; i++) {
		portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
		if (portsc & PORT_DEV_REMOVE)
			port_removable |= 1 << (i + 1);
	}
	memset(&desc->u.ss.DeviceRemovable,
			(__force __u16) cpu_to_le16(port_removable),
			sizeof(__u16));
}

static void xhci_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		struct usb_hub_descriptor *desc)
{

	if (hcd->speed == HCD_USB3)
		xhci_usb3_hub_descriptor(hcd, xhci, desc);
	else
		xhci_usb2_hub_descriptor(hcd, xhci, desc);

}

Sarah Sharp's avatar
Sarah Sharp committed
152 153 154
static unsigned int xhci_port_speed(unsigned int port_status)
{
	if (DEV_LOWSPEED(port_status))
155
		return USB_PORT_STAT_LOW_SPEED;
Sarah Sharp's avatar
Sarah Sharp committed
156
	if (DEV_HIGHSPEED(port_status))
157
		return USB_PORT_STAT_HIGH_SPEED;
Sarah Sharp's avatar
Sarah Sharp committed
158 159 160
	/*
	 * FIXME: Yes, we should check for full speed, but the core uses that as
	 * a default in portspeed() in usb/core/hub.c (which is the only place
161
	 * USB_PORT_STAT_*_SPEED is used).
Sarah Sharp's avatar
Sarah Sharp committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
	 */
	return 0;
}

/*
 * These bits are Read Only (RO) and should be saved and written to the
 * registers: 0, 3, 10:13, 30
 * connect status, over-current status, port speed, and device removable.
 * connect status and port speed are also sticky - meaning they're in
 * the AUX well and they aren't changed by a hot, warm, or cold reset.
 */
#define	XHCI_PORT_RO	((1<<0) | (1<<3) | (0xf<<10) | (1<<30))
/*
 * These bits are RW; writing a 0 clears the bit, writing a 1 sets the bit:
 * bits 5:8, 9, 14:15, 25:27
 * link state, port power, port indicator state, "wake on" enable state
 */
#define XHCI_PORT_RWS	((0xf<<5) | (1<<9) | (0x3<<14) | (0x7<<25))
/*
 * These bits are RW; writing a 1 sets the bit, writing a 0 has no effect:
 * bit 4 (port reset)
 */
#define	XHCI_PORT_RW1S	((1<<4))
/*
 * These bits are RW; writing a 1 clears the bit, writing a 0 has no effect:
 * bits 1, 17, 18, 19, 20, 21, 22, 23
 * port enable/disable, and
 * change bits: connect, PED, warm port reset changed (reserved zero for USB 2.0 ports),
 * over-current, reset, link state, and L1 change
 */
#define XHCI_PORT_RW1CS	((1<<1) | (0x7f<<17))
/*
 * Bit 16 is RW, and writing a '1' to it causes the link state control to be
 * latched in
 */
#define	XHCI_PORT_RW	((1<<16))
/*
 * These bits are Reserved Zero (RsvdZ) and zero should be written to them:
 * bits 2, 24, 28:31
 */
#define	XHCI_PORT_RZ	((1<<2) | (1<<24) | (0xf<<28))

/*
 * Given a port state, this function returns a value that would result in the
 * port being in the same state, if the value was written to the port status
 * control register.
 * Save Read Only (RO) bits and save read/write bits where
 * writing a 0 clears the bit and writing a 1 sets the bit (RWS).
 * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect.
 */
212
u32 xhci_port_state_to_neutral(u32 state)
Sarah Sharp's avatar
Sarah Sharp committed
213 214 215 216 217
{
	/* Save read-only status and port state */
	return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
}

218 219
/*
 * find slot id based on port number.
220
 * @port: The one-based port number from one of the two split roothubs.
221
 */
222 223
int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		u16 port)
224 225 226
{
	int slot_id;
	int i;
227
	enum usb_device_speed speed;
228 229 230 231 232

	slot_id = 0;
	for (i = 0; i < MAX_HC_SLOTS; i++) {
		if (!xhci->devs[i])
			continue;
233 234 235
		speed = xhci->devs[i]->udev->speed;
		if (((speed == USB_SPEED_SUPER) == (hcd->speed == HCD_USB3))
				&& xhci->devs[i]->port == port) {
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
			slot_id = i;
			break;
		}
	}

	return slot_id;
}

/*
 * Stop device
 * It issues stop endpoint command for EP 0 to 30. And wait the last command
 * to complete.
 * suspend will set to 1, if suspend bit need to set in command.
 */
static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
{
	struct xhci_virt_device *virt_dev;
	struct xhci_command *cmd;
	unsigned long flags;
	int timeleft;
	int ret;
	int i;

	ret = 0;
	virt_dev = xhci->devs[slot_id];
	cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
	if (!cmd) {
		xhci_dbg(xhci, "Couldn't allocate command structure.\n");
		return -ENOMEM;
	}

	spin_lock_irqsave(&xhci->lock, flags);
	for (i = LAST_EP_INDEX; i > 0; i--) {
		if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
			xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
	}
	cmd->command_trb = xhci->cmd_ring->enqueue;
	list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
	xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
	xhci_ring_cmd_db(xhci);
	spin_unlock_irqrestore(&xhci->lock, flags);

	/* Wait for last stop endpoint command to finish */
	timeleft = wait_for_completion_interruptible_timeout(
			cmd->completion,
			USB_CTRL_SET_TIMEOUT);
	if (timeleft <= 0) {
		xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
				timeleft == 0 ? "Timeout" : "Signal");
		spin_lock_irqsave(&xhci->lock, flags);
		/* The timeout might have raced with the event ring handler, so
		 * only delete from the list if the item isn't poisoned.
		 */
		if (cmd->cmd_list.next != LIST_POISON1)
			list_del(&cmd->cmd_list);
		spin_unlock_irqrestore(&xhci->lock, flags);
		ret = -ETIME;
		goto command_cleanup;
	}

command_cleanup:
	xhci_free_command(xhci, cmd);
	return ret;
}

/*
 * Ring device, it rings the all doorbells unconditionally.
 */
304
void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
305 306 307 308 309 310 311 312 313 314 315
{
	int i;

	for (i = 0; i < LAST_EP_INDEX + 1; i++)
		if (xhci->devs[slot_id]->eps[i].ring &&
		    xhci->devs[slot_id]->eps[i].ring->dequeue)
			xhci_ring_ep_doorbell(xhci, slot_id, i, 0);

	return;
}

316
static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
317
		u16 wIndex, __le32 __iomem *addr, u32 port_status)
318
{
319
	/* Don't allow the USB core to disable SuperSpeed ports. */
320
	if (hcd->speed == HCD_USB3) {
321 322 323 324 325
		xhci_dbg(xhci, "Ignoring request to disable "
				"SuperSpeed port.\n");
		return;
	}

326 327 328 329 330 331 332
	/* Write 1 to disable the port */
	xhci_writel(xhci, port_status | PORT_PE, addr);
	port_status = xhci_readl(xhci, addr);
	xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",
			wIndex, port_status);
}

333
static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
334
		u16 wIndex, __le32 __iomem *addr, u32 port_status)
335 336 337 338 339 340 341 342 343
{
	char *port_change_bit;
	u32 status;

	switch (wValue) {
	case USB_PORT_FEAT_C_RESET:
		status = PORT_RC;
		port_change_bit = "reset";
		break;
Andiry Xu's avatar
Andiry Xu committed
344 345 346 347
	case USB_PORT_FEAT_C_BH_PORT_RESET:
		status = PORT_WRC;
		port_change_bit = "warm(BH) reset";
		break;
348 349 350 351 352 353 354 355
	case USB_PORT_FEAT_C_CONNECTION:
		status = PORT_CSC;
		port_change_bit = "connect";
		break;
	case USB_PORT_FEAT_C_OVER_CURRENT:
		status = PORT_OCC;
		port_change_bit = "over-current";
		break;
356 357 358 359
	case USB_PORT_FEAT_C_ENABLE:
		status = PORT_PEC;
		port_change_bit = "enable/disable";
		break;
360 361 362 363
	case USB_PORT_FEAT_C_SUSPEND:
		status = PORT_PLC;
		port_change_bit = "suspend/resume";
		break;
364 365 366 367
	case USB_PORT_FEAT_C_PORT_LINK_STATE:
		status = PORT_PLC;
		port_change_bit = "link state";
		break;
368 369 370 371 372 373 374 375 376 377 378
	default:
		/* Should never happen */
		return;
	}
	/* Change bits are all write 1 to clear */
	xhci_writel(xhci, port_status | status, addr);
	port_status = xhci_readl(xhci, addr);
	xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
			port_change_bit, wIndex, port_status);
}

Sarah Sharp's avatar
Sarah Sharp committed
379 380 381 382 383 384
int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
		u16 wIndex, char *buf, u16 wLength)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
	int ports;
	unsigned long flags;
385
	u32 temp, temp1, status;
Sarah Sharp's avatar
Sarah Sharp committed
386
	int retval = 0;
387
	__le32 __iomem **port_array;
388
	int slot_id;
389
	struct xhci_bus_state *bus_state;
Andiry Xu's avatar
Andiry Xu committed
390
	u16 link_state = 0;
Sarah Sharp's avatar
Sarah Sharp committed
391

392 393 394 395 396 397
	if (hcd->speed == HCD_USB3) {
		ports = xhci->num_usb3_ports;
		port_array = xhci->usb3_ports;
	} else {
		ports = xhci->num_usb2_ports;
		port_array = xhci->usb2_ports;
398
	}
399
	bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp's avatar
Sarah Sharp committed
400 401 402 403 404 405 406 407

	spin_lock_irqsave(&xhci->lock, flags);
	switch (typeReq) {
	case GetHubStatus:
		/* No power source, over-current reported per port */
		memset(buf, 0, 4);
		break;
	case GetHubDescriptor:
408 409 410 411 412 413 414 415 416 417 418
		/* Check to make sure userspace is asking for the USB 3.0 hub
		 * descriptor for the USB 3.0 roothub.  If not, we stall the
		 * endpoint, like external hubs do.
		 */
		if (hcd->speed == HCD_USB3 &&
				(wLength < USB_DT_SS_HUB_SIZE ||
				 wValue != (USB_DT_SS_HUB << 8))) {
			xhci_dbg(xhci, "Wrong hub descriptor type for "
					"USB 3.0 roothub.\n");
			goto error;
		}
419 420
		xhci_hub_descriptor(hcd, xhci,
				(struct usb_hub_descriptor *) buf);
Sarah Sharp's avatar
Sarah Sharp committed
421 422 423 424 425 426
		break;
	case GetPortStatus:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
		status = 0;
427
		temp = xhci_readl(xhci, port_array[wIndex]);
428 429 430 431
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
Sarah Sharp's avatar
Sarah Sharp committed
432 433
		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n", wIndex, temp);

434 435 436
		/* FIXME - should we return a port status value like the USB
		 * 3.0 external hubs do?
		 */
Sarah Sharp's avatar
Sarah Sharp committed
437 438
		/* wPortChange bits */
		if (temp & PORT_CSC)
439
			status |= USB_PORT_STAT_C_CONNECTION << 16;
Sarah Sharp's avatar
Sarah Sharp committed
440
		if (temp & PORT_PEC)
441
			status |= USB_PORT_STAT_C_ENABLE << 16;
Sarah Sharp's avatar
Sarah Sharp committed
442
		if ((temp & PORT_OCC))
443
			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
Sarah Sharp's avatar
Sarah Sharp committed
444
		/*
445
		 * FIXME ignoring reset and USB 2.1/3.0 specific
Sarah Sharp's avatar
Sarah Sharp committed
446 447
		 * changes
		 */
448 449 450
		if ((temp & PORT_PLS_MASK) == XDEV_U3
			&& (temp & PORT_POWER))
			status |= 1 << USB_PORT_FEAT_SUSPEND;
451 452 453 454
		if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
			if ((temp & PORT_RESET) || !(temp & PORT_PE))
				goto error;
			if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
455
						bus_state->resume_done[wIndex])) {
456 457
				xhci_dbg(xhci, "Resume USB2 port %d\n",
					wIndex + 1);
458
				bus_state->resume_done[wIndex] = 0;
459 460 461
				temp1 = xhci_port_state_to_neutral(temp);
				temp1 &= ~PORT_PLS_MASK;
				temp1 |= PORT_LINK_STROBE | XDEV_U0;
462
				xhci_writel(xhci, temp1, port_array[wIndex]);
463 464 465

				xhci_dbg(xhci, "set port %d resume\n",
					wIndex + 1);
466
				slot_id = xhci_find_slot_id_by_port(hcd, xhci,
467 468 469 470 471 472
								 wIndex + 1);
				if (!slot_id) {
					xhci_dbg(xhci, "slot_id is zero\n");
					goto error;
				}
				xhci_ring_device(xhci, slot_id);
473 474
				bus_state->port_c_suspend |= 1 << wIndex;
				bus_state->suspended_ports &= ~(1 << wIndex);
475 476
			}
		}
477 478
		if ((temp & PORT_PLS_MASK) == XDEV_U0
			&& (temp & PORT_POWER)
479 480 481
			&& (bus_state->suspended_ports & (1 << wIndex))) {
			bus_state->suspended_ports &= ~(1 << wIndex);
			bus_state->port_c_suspend |= 1 << wIndex;
482
		}
Sarah Sharp's avatar
Sarah Sharp committed
483
		if (temp & PORT_CONNECT) {
484
			status |= USB_PORT_STAT_CONNECTION;
Sarah Sharp's avatar
Sarah Sharp committed
485 486 487
			status |= xhci_port_speed(temp);
		}
		if (temp & PORT_PE)
488
			status |= USB_PORT_STAT_ENABLE;
Sarah Sharp's avatar
Sarah Sharp committed
489
		if (temp & PORT_OC)
490
			status |= USB_PORT_STAT_OVERCURRENT;
Sarah Sharp's avatar
Sarah Sharp committed
491
		if (temp & PORT_RESET)
492
			status |= USB_PORT_STAT_RESET;
Sarah Sharp's avatar
Sarah Sharp committed
493
		if (temp & PORT_POWER)
494
			status |= USB_PORT_STAT_POWER;
495
		if (bus_state->port_c_suspend & (1 << wIndex))
496
			status |= 1 << USB_PORT_FEAT_C_SUSPEND;
Sarah Sharp's avatar
Sarah Sharp committed
497 498 499 500
		xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
		put_unaligned(cpu_to_le32(status), (__le32 *) buf);
		break;
	case SetPortFeature:
Andiry Xu's avatar
Andiry Xu committed
501 502
		if (wValue == USB_PORT_FEAT_LINK_STATE)
			link_state = (wIndex & 0xff00) >> 3;
Sarah Sharp's avatar
Sarah Sharp committed
503 504 505 506
		wIndex &= 0xff;
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
507
		temp = xhci_readl(xhci, port_array[wIndex]);
508 509 510 511
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
Sarah Sharp's avatar
Sarah Sharp committed
512
		temp = xhci_port_state_to_neutral(temp);
513
		/* FIXME: What new port features do we need to support? */
Sarah Sharp's avatar
Sarah Sharp committed
514
		switch (wValue) {
515
		case USB_PORT_FEAT_SUSPEND:
516
			temp = xhci_readl(xhci, port_array[wIndex]);
517 518 519 520 521 522 523 524 525 526 527
			/* In spec software should not attempt to suspend
			 * a port unless the port reports that it is in the
			 * enabled (PED = ‘1’,PLS < ‘3’) state.
			 */
			if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
				|| (temp & PORT_PLS_MASK) >= XDEV_U3) {
				xhci_warn(xhci, "USB core suspending device "
					  "not in U0/U1/U2.\n");
				goto error;
			}

528 529
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
530 531 532 533 534 535 536 537 538 539 540 541
			if (!slot_id) {
				xhci_warn(xhci, "slot_id is zero\n");
				goto error;
			}
			/* unlock to execute stop endpoint commands */
			spin_unlock_irqrestore(&xhci->lock, flags);
			xhci_stop_device(xhci, slot_id, 1);
			spin_lock_irqsave(&xhci->lock, flags);

			temp = xhci_port_state_to_neutral(temp);
			temp &= ~PORT_PLS_MASK;
			temp |= PORT_LINK_STROBE | XDEV_U3;
542
			xhci_writel(xhci, temp, port_array[wIndex]);
543 544 545 546 547

			spin_unlock_irqrestore(&xhci->lock, flags);
			msleep(10); /* wait device to enter */
			spin_lock_irqsave(&xhci->lock, flags);

548
			temp = xhci_readl(xhci, port_array[wIndex]);
549
			bus_state->suspended_ports |= 1 << wIndex;
550
			break;
Andiry Xu's avatar
Andiry Xu committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
		case USB_PORT_FEAT_LINK_STATE:
			temp = xhci_readl(xhci, port_array[wIndex]);
			/* Software should not attempt to set
			 * port link state above '5' (Rx.Detect) and the port
			 * must be enabled.
			 */
			if ((temp & PORT_PE) == 0 ||
				(link_state > USB_SS_PORT_LS_RX_DETECT)) {
				xhci_warn(xhci, "Cannot set link state.\n");
				goto error;
			}

			if (link_state == USB_SS_PORT_LS_U3) {
				slot_id = xhci_find_slot_id_by_port(hcd, xhci,
						wIndex + 1);
				if (slot_id) {
					/* unlock to execute stop endpoint
					 * commands */
					spin_unlock_irqrestore(&xhci->lock,
								flags);
					xhci_stop_device(xhci, slot_id, 1);
					spin_lock_irqsave(&xhci->lock, flags);
				}
			}

			temp = xhci_port_state_to_neutral(temp);
			temp &= ~PORT_PLS_MASK;
			temp |= PORT_LINK_STROBE | link_state;
			xhci_writel(xhci, temp, port_array[wIndex]);

			spin_unlock_irqrestore(&xhci->lock, flags);
			msleep(20); /* wait device to enter */
			spin_lock_irqsave(&xhci->lock, flags);

			temp = xhci_readl(xhci, port_array[wIndex]);
			if (link_state == USB_SS_PORT_LS_U3)
				bus_state->suspended_ports |= 1 << wIndex;
			break;
Sarah Sharp's avatar
Sarah Sharp committed
589 590 591 592 593 594 595
		case USB_PORT_FEAT_POWER:
			/*
			 * Turn on ports, even if there isn't per-port switching.
			 * HC will report connect events even before this is set.
			 * However, khubd will ignore the roothub events until
			 * the roothub is registered.
			 */
596 597
			xhci_writel(xhci, temp | PORT_POWER,
					port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
598

599
			temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
600 601 602 603
			xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
			break;
		case USB_PORT_FEAT_RESET:
			temp = (temp | PORT_RESET);
604
			xhci_writel(xhci, temp, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
605

606
			temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
607 608
			xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
			break;
Andiry Xu's avatar
Andiry Xu committed
609 610 611 612 613 614
		case USB_PORT_FEAT_BH_PORT_RESET:
			temp |= PORT_WR;
			xhci_writel(xhci, temp, port_array[wIndex]);

			temp = xhci_readl(xhci, port_array[wIndex]);
			break;
Sarah Sharp's avatar
Sarah Sharp committed
615 616 617
		default:
			goto error;
		}
618 619
		/* unblock any posted writes */
		temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
620 621 622 623 624
		break;
	case ClearPortFeature:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
625
		temp = xhci_readl(xhci, port_array[wIndex]);
626 627 628 629
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
630
		/* FIXME: What new port features do we need to support? */
Sarah Sharp's avatar
Sarah Sharp committed
631 632
		temp = xhci_port_state_to_neutral(temp);
		switch (wValue) {
633
		case USB_PORT_FEAT_SUSPEND:
634
			temp = xhci_readl(xhci, port_array[wIndex]);
635 636 637 638 639 640 641 642 643 644 645
			xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
			xhci_dbg(xhci, "PORTSC %04x\n", temp);
			if (temp & PORT_RESET)
				goto error;
			if (temp & XDEV_U3) {
				if ((temp & PORT_PE) == 0)
					goto error;
				if (DEV_SUPERSPEED(temp)) {
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_U0;
646 647 648
					xhci_writel(xhci, temp,
							port_array[wIndex]);
					xhci_readl(xhci, port_array[wIndex]);
649 650 651 652
				} else {
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_RESUME;
653 654
					xhci_writel(xhci, temp,
							port_array[wIndex]);
655 656 657 658 659 660

					spin_unlock_irqrestore(&xhci->lock,
							       flags);
					msleep(20);
					spin_lock_irqsave(&xhci->lock, flags);

661 662
					temp = xhci_readl(xhci,
							port_array[wIndex]);
663 664 665
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_U0;
666 667
					xhci_writel(xhci, temp,
							port_array[wIndex]);
668
				}
669
				bus_state->port_c_suspend |= 1 << wIndex;
670 671
			}

672 673
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
674 675 676 677 678 679 680
			if (!slot_id) {
				xhci_dbg(xhci, "slot_id is zero\n");
				goto error;
			}
			xhci_ring_device(xhci, slot_id);
			break;
		case USB_PORT_FEAT_C_SUSPEND:
681
			bus_state->port_c_suspend &= ~(1 << wIndex);
Sarah Sharp's avatar
Sarah Sharp committed
682
		case USB_PORT_FEAT_C_RESET:
Andiry Xu's avatar
Andiry Xu committed
683
		case USB_PORT_FEAT_C_BH_PORT_RESET:
Sarah Sharp's avatar
Sarah Sharp committed
684 685
		case USB_PORT_FEAT_C_CONNECTION:
		case USB_PORT_FEAT_C_OVER_CURRENT:
686
		case USB_PORT_FEAT_C_ENABLE:
687
		case USB_PORT_FEAT_C_PORT_LINK_STATE:
688
			xhci_clear_port_change_bit(xhci, wValue, wIndex,
689
					port_array[wIndex], temp);
Sarah Sharp's avatar
Sarah Sharp committed
690
			break;
691
		case USB_PORT_FEAT_ENABLE:
692
			xhci_disable_port(hcd, xhci, wIndex,
693
					port_array[wIndex], temp);
694
			break;
Sarah Sharp's avatar
Sarah Sharp committed
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
		default:
			goto error;
		}
		break;
	default:
error:
		/* "stall" on error */
		retval = -EPIPE;
	}
	spin_unlock_irqrestore(&xhci->lock, flags);
	return retval;
}

/*
 * Returns 0 if the status hasn't changed, or the number of bytes in buf.
 * Ports are 0-indexed from the HCD point of view,
 * and 1-indexed from the USB core pointer of view.
 *
 * Note that the status change bits will be cleared as soon as a port status
 * change event is generated, so we use the saved status from that event.
 */
int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
{
	unsigned long flags;
	u32 temp, status;
720
	u32 mask;
Sarah Sharp's avatar
Sarah Sharp committed
721 722 723
	int i, retval;
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
	int ports;
724
	__le32 __iomem **port_array;
725
	struct xhci_bus_state *bus_state;
Sarah Sharp's avatar
Sarah Sharp committed
726

727 728 729 730 731 732
	if (hcd->speed == HCD_USB3) {
		ports = xhci->num_usb3_ports;
		port_array = xhci->usb3_ports;
	} else {
		ports = xhci->num_usb2_ports;
		port_array = xhci->usb2_ports;
733
	}
734
	bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp's avatar
Sarah Sharp committed
735 736

	/* Initial status is no changes */
737 738
	retval = (ports + 8) / 8;
	memset(buf, 0, retval);
Sarah Sharp's avatar
Sarah Sharp committed
739 740
	status = 0;

741 742
	mask = PORT_CSC | PORT_PEC | PORT_OCC;

Sarah Sharp's avatar
Sarah Sharp committed
743 744 745
	spin_lock_irqsave(&xhci->lock, flags);
	/* For each port, did anything change?  If so, set that bit in buf. */
	for (i = 0; i < ports; i++) {
746
		temp = xhci_readl(xhci, port_array[i]);
747 748 749 750
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
751
		if ((temp & mask) != 0 ||
752 753 754
			(bus_state->port_c_suspend & 1 << i) ||
			(bus_state->resume_done[i] && time_after_eq(
			    jiffies, bus_state->resume_done[i]))) {
755
			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
Sarah Sharp's avatar
Sarah Sharp committed
756 757 758 759 760 761
			status = 1;
		}
	}
	spin_unlock_irqrestore(&xhci->lock, flags);
	return status ? retval : 0;
}
762 763 764 765 766 767

#ifdef CONFIG_PM

int xhci_bus_suspend(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
768
	int max_ports, port_index;
769
	__le32 __iomem **port_array;
770
	struct xhci_bus_state *bus_state;
771 772
	unsigned long flags;

773 774 775 776 777 778 779 780
	if (hcd->speed == HCD_USB3) {
		max_ports = xhci->num_usb3_ports;
		port_array = xhci->usb3_ports;
		xhci_dbg(xhci, "suspend USB 3.0 root hub\n");
	} else {
		max_ports = xhci->num_usb2_ports;
		port_array = xhci->usb2_ports;
		xhci_dbg(xhci, "suspend USB 2.0 root hub\n");
781
	}
782
	bus_state = &xhci->bus_state[hcd_index(hcd)];
783 784 785 786

	spin_lock_irqsave(&xhci->lock, flags);

	if (hcd->self.root_hub->do_remote_wakeup) {
787 788
		port_index = max_ports;
		while (port_index--) {
789
			if (bus_state->resume_done[port_index] != 0) {
790 791 792
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_dbg(xhci, "suspend failed because "
						"port %d is resuming\n",
793
						port_index + 1);
794 795 796 797 798
				return -EBUSY;
			}
		}
	}

799
	port_index = max_ports;
800
	bus_state->bus_suspended = 0;
801
	while (port_index--) {
802 803 804 805
		/* suspend the port if the port is not suspended */
		u32 t1, t2;
		int slot_id;

806
		t1 = xhci_readl(xhci, port_array[port_index]);
807 808 809
		t2 = xhci_port_state_to_neutral(t1);

		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
810
			xhci_dbg(xhci, "port %d not suspended\n", port_index);
811
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
812
					port_index + 1);
813 814 815 816 817 818 819
			if (slot_id) {
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_stop_device(xhci, slot_id, 1);
				spin_lock_irqsave(&xhci->lock, flags);
			}
			t2 &= ~PORT_PLS_MASK;
			t2 |= PORT_LINK_STROBE | XDEV_U3;
820
			set_bit(port_index, &bus_state->bus_suspended);
821 822 823 824 825 826 827 828 829 830 831 832 833 834
		}
		if (hcd->self.root_hub->do_remote_wakeup) {
			if (t1 & PORT_CONNECT) {
				t2 |= PORT_WKOC_E | PORT_WKDISC_E;
				t2 &= ~PORT_WKCONN_E;
			} else {
				t2 |= PORT_WKOC_E | PORT_WKCONN_E;
				t2 &= ~PORT_WKDISC_E;
			}
		} else
			t2 &= ~PORT_WAKE_BITS;

		t1 = xhci_port_state_to_neutral(t1);
		if (t1 != t2)
835
			xhci_writel(xhci, t2, port_array[port_index]);
836 837 838

		if (DEV_HIGHSPEED(t1)) {
			/* enable remote wake up for USB 2.0 */
839
			__le32 __iomem *addr;
840 841
			u32 tmp;

842 843 844 845
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
846 847 848 849 850 851
			tmp = xhci_readl(xhci, addr);
			tmp |= PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}
	hcd->state = HC_STATE_SUSPENDED;
852
	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
853 854 855 856 857 858 859
	spin_unlock_irqrestore(&xhci->lock, flags);
	return 0;
}

int xhci_bus_resume(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
860
	int max_ports, port_index;
861
	__le32 __iomem **port_array;
862
	struct xhci_bus_state *bus_state;
863 864 865
	u32 temp;
	unsigned long flags;

866 867 868 869 870 871 872 873
	if (hcd->speed == HCD_USB3) {
		max_ports = xhci->num_usb3_ports;
		port_array = xhci->usb3_ports;
		xhci_dbg(xhci, "resume USB 3.0 root hub\n");
	} else {
		max_ports = xhci->num_usb2_ports;
		port_array = xhci->usb2_ports;
		xhci_dbg(xhci, "resume USB 2.0 root hub\n");
874
	}
875
	bus_state = &xhci->bus_state[hcd_index(hcd)];
876

877
	if (time_before(jiffies, bus_state->next_statechange))
878 879 880 881 882 883 884 885 886 887 888 889 890
		msleep(5);

	spin_lock_irqsave(&xhci->lock, flags);
	if (!HCD_HW_ACCESSIBLE(hcd)) {
		spin_unlock_irqrestore(&xhci->lock, flags);
		return -ESHUTDOWN;
	}

	/* delay the irqs */
	temp = xhci_readl(xhci, &xhci->op_regs->command);
	temp &= ~CMD_EIE;
	xhci_writel(xhci, temp, &xhci->op_regs->command);

891 892
	port_index = max_ports;
	while (port_index--) {
893 894 895 896 897
		/* Check whether need resume ports. If needed
		   resume port and disable remote wakeup */
		u32 temp;
		int slot_id;

898
		temp = xhci_readl(xhci, port_array[port_index]);
899 900 901 902
		if (DEV_SUPERSPEED(temp))
			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
		else
			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
903
		if (test_bit(port_index, &bus_state->bus_suspended) &&
904 905 906 907 908
		    (temp & PORT_PLS_MASK)) {
			if (DEV_SUPERSPEED(temp)) {
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_U0;
909
				xhci_writel(xhci, temp, port_array[port_index]);
910 911 912 913
			} else {
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_RESUME;
914
				xhci_writel(xhci, temp, port_array[port_index]);
915 916 917 918 919

				spin_unlock_irqrestore(&xhci->lock, flags);
				msleep(20);
				spin_lock_irqsave(&xhci->lock, flags);

920
				temp = xhci_readl(xhci, port_array[port_index]);
921 922 923
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_U0;
924
				xhci_writel(xhci, temp, port_array[port_index]);
925
			}
926 927
			slot_id = xhci_find_slot_id_by_port(hcd,
					xhci, port_index + 1);
928 929 930
			if (slot_id)
				xhci_ring_device(xhci, slot_id);
		} else
931
			xhci_writel(xhci, temp, port_array[port_index]);
932 933 934

		if (DEV_HIGHSPEED(temp)) {
			/* disable remote wake up for USB 2.0 */
935
			__le32 __iomem *addr;
936 937
			u32 tmp;

938 939 940 941
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
942 943 944 945 946 947 948 949
			tmp = xhci_readl(xhci, addr);
			tmp &= ~PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}

	(void) xhci_readl(xhci, &xhci->op_regs->command);

950
	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
951 952 953 954 955 956 957 958 959 960
	/* re-enable irqs */
	temp = xhci_readl(xhci, &xhci->op_regs->command);
	temp |= CMD_EIE;
	xhci_writel(xhci, temp, &xhci->op_regs->command);
	temp = xhci_readl(xhci, &xhci->op_regs->command);

	spin_unlock_irqrestore(&xhci->lock, flags);
	return 0;
}

961
#endif	/* CONFIG_PM */