xhci-hub.c 25.9 KB
Newer Older
S
Sarah Sharp 已提交
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)
S
Sarah Sharp 已提交
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 */
M
Matt Evans 已提交
53
	desc->wHubCharacteristics = cpu_to_le16(temp);
S
Sarah Sharp 已提交
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);

}

S
Sarah Sharp 已提交
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;
S
Sarah Sharp 已提交
156
	if (DEV_HIGHSPEED(port_status))
157
		return USB_PORT_STAT_HIGH_SPEED;
S
Sarah Sharp 已提交
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).
S
Sarah Sharp 已提交
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)
S
Sarah Sharp 已提交
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,
M
Matt Evans 已提交
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,
M
Matt Evans 已提交
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;
A
Andiry Xu 已提交
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 368 369 370 371 372 373 374
	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);
}

S
Sarah Sharp 已提交
375 376 377 378 379 380
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;
381
	u32 temp, temp1, status;
S
Sarah Sharp 已提交
382
	int retval = 0;
M
Matt Evans 已提交
383
	__le32 __iomem **port_array;
384
	int slot_id;
385
	struct xhci_bus_state *bus_state;
S
Sarah Sharp 已提交
386

387 388 389 390 391 392
	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;
393
	}
394
	bus_state = &xhci->bus_state[hcd_index(hcd)];
S
Sarah Sharp 已提交
395 396 397 398 399 400 401 402

	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:
403 404 405 406 407 408 409 410 411 412 413
		/* 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;
		}
414 415
		xhci_hub_descriptor(hcd, xhci,
				(struct usb_hub_descriptor *) buf);
S
Sarah Sharp 已提交
416 417 418 419 420 421
		break;
	case GetPortStatus:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
		status = 0;
422
		temp = xhci_readl(xhci, port_array[wIndex]);
423 424 425 426
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
S
Sarah Sharp 已提交
427 428
		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n", wIndex, temp);

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

				xhci_dbg(xhci, "set port %d resume\n",
					wIndex + 1);
461
				slot_id = xhci_find_slot_id_by_port(hcd, xhci,
462 463 464 465 466 467
								 wIndex + 1);
				if (!slot_id) {
					xhci_dbg(xhci, "slot_id is zero\n");
					goto error;
				}
				xhci_ring_device(xhci, slot_id);
468 469
				bus_state->port_c_suspend |= 1 << wIndex;
				bus_state->suspended_ports &= ~(1 << wIndex);
470 471
			}
		}
472 473
		if ((temp & PORT_PLS_MASK) == XDEV_U0
			&& (temp & PORT_POWER)
474 475 476
			&& (bus_state->suspended_ports & (1 << wIndex))) {
			bus_state->suspended_ports &= ~(1 << wIndex);
			bus_state->port_c_suspend |= 1 << wIndex;
477
		}
S
Sarah Sharp 已提交
478
		if (temp & PORT_CONNECT) {
479
			status |= USB_PORT_STAT_CONNECTION;
S
Sarah Sharp 已提交
480 481 482
			status |= xhci_port_speed(temp);
		}
		if (temp & PORT_PE)
483
			status |= USB_PORT_STAT_ENABLE;
S
Sarah Sharp 已提交
484
		if (temp & PORT_OC)
485
			status |= USB_PORT_STAT_OVERCURRENT;
S
Sarah Sharp 已提交
486
		if (temp & PORT_RESET)
487
			status |= USB_PORT_STAT_RESET;
S
Sarah Sharp 已提交
488
		if (temp & PORT_POWER)
489
			status |= USB_PORT_STAT_POWER;
490
		if (bus_state->port_c_suspend & (1 << wIndex))
491
			status |= 1 << USB_PORT_FEAT_C_SUSPEND;
S
Sarah Sharp 已提交
492 493 494 495 496 497 498 499
		xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
		put_unaligned(cpu_to_le32(status), (__le32 *) buf);
		break;
	case SetPortFeature:
		wIndex &= 0xff;
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
500
		temp = xhci_readl(xhci, port_array[wIndex]);
501 502 503 504
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
S
Sarah Sharp 已提交
505
		temp = xhci_port_state_to_neutral(temp);
506
		/* FIXME: What new port features do we need to support? */
S
Sarah Sharp 已提交
507
		switch (wValue) {
508
		case USB_PORT_FEAT_SUSPEND:
509
			temp = xhci_readl(xhci, port_array[wIndex]);
510 511 512 513 514 515 516 517 518 519 520
			/* 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;
			}

521 522
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
523 524 525 526 527 528 529 530 531 532 533 534
			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;
535
			xhci_writel(xhci, temp, port_array[wIndex]);
536 537 538 539 540

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

541
			temp = xhci_readl(xhci, port_array[wIndex]);
542
			bus_state->suspended_ports |= 1 << wIndex;
543
			break;
S
Sarah Sharp 已提交
544 545 546 547 548 549 550
		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.
			 */
551 552
			xhci_writel(xhci, temp | PORT_POWER,
					port_array[wIndex]);
S
Sarah Sharp 已提交
553

554
			temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
555 556 557 558
			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);
559
			xhci_writel(xhci, temp, port_array[wIndex]);
S
Sarah Sharp 已提交
560

561
			temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
562 563
			xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
			break;
A
Andiry Xu 已提交
564 565 566 567 568 569
		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;
S
Sarah Sharp 已提交
570 571 572
		default:
			goto error;
		}
573 574
		/* unblock any posted writes */
		temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
575 576 577 578 579
		break;
	case ClearPortFeature:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
580
		temp = xhci_readl(xhci, port_array[wIndex]);
581 582 583 584
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
585
		/* FIXME: What new port features do we need to support? */
S
Sarah Sharp 已提交
586 587
		temp = xhci_port_state_to_neutral(temp);
		switch (wValue) {
588
		case USB_PORT_FEAT_SUSPEND:
589
			temp = xhci_readl(xhci, port_array[wIndex]);
590 591 592 593 594 595 596 597 598 599 600
			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;
601 602 603
					xhci_writel(xhci, temp,
							port_array[wIndex]);
					xhci_readl(xhci, port_array[wIndex]);
604 605 606 607
				} else {
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_RESUME;
608 609
					xhci_writel(xhci, temp,
							port_array[wIndex]);
610 611 612 613 614 615

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

616 617
					temp = xhci_readl(xhci,
							port_array[wIndex]);
618 619 620
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_U0;
621 622
					xhci_writel(xhci, temp,
							port_array[wIndex]);
623
				}
624
				bus_state->port_c_suspend |= 1 << wIndex;
625 626
			}

627 628
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
629 630 631 632 633 634 635
			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:
636
			bus_state->port_c_suspend &= ~(1 << wIndex);
S
Sarah Sharp 已提交
637
		case USB_PORT_FEAT_C_RESET:
A
Andiry Xu 已提交
638
		case USB_PORT_FEAT_C_BH_PORT_RESET:
S
Sarah Sharp 已提交
639 640
		case USB_PORT_FEAT_C_CONNECTION:
		case USB_PORT_FEAT_C_OVER_CURRENT:
641
		case USB_PORT_FEAT_C_ENABLE:
642
			xhci_clear_port_change_bit(xhci, wValue, wIndex,
643
					port_array[wIndex], temp);
S
Sarah Sharp 已提交
644
			break;
645
		case USB_PORT_FEAT_ENABLE:
646
			xhci_disable_port(hcd, xhci, wIndex,
647
					port_array[wIndex], temp);
648
			break;
S
Sarah Sharp 已提交
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
		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;
674
	u32 mask;
S
Sarah Sharp 已提交
675 676 677
	int i, retval;
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
	int ports;
M
Matt Evans 已提交
678
	__le32 __iomem **port_array;
679
	struct xhci_bus_state *bus_state;
S
Sarah Sharp 已提交
680

681 682 683 684 685 686
	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;
687
	}
688
	bus_state = &xhci->bus_state[hcd_index(hcd)];
S
Sarah Sharp 已提交
689 690

	/* Initial status is no changes */
691 692
	retval = (ports + 8) / 8;
	memset(buf, 0, retval);
S
Sarah Sharp 已提交
693 694
	status = 0;

695 696
	mask = PORT_CSC | PORT_PEC | PORT_OCC;

S
Sarah Sharp 已提交
697 698 699
	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++) {
700
		temp = xhci_readl(xhci, port_array[i]);
701 702 703 704
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
705
		if ((temp & mask) != 0 ||
706 707 708
			(bus_state->port_c_suspend & 1 << i) ||
			(bus_state->resume_done[i] && time_after_eq(
			    jiffies, bus_state->resume_done[i]))) {
709
			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
S
Sarah Sharp 已提交
710 711 712 713 714 715
			status = 1;
		}
	}
	spin_unlock_irqrestore(&xhci->lock, flags);
	return status ? retval : 0;
}
716 717 718 719 720 721

#ifdef CONFIG_PM

int xhci_bus_suspend(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
722
	int max_ports, port_index;
M
Matt Evans 已提交
723
	__le32 __iomem **port_array;
724
	struct xhci_bus_state *bus_state;
725 726
	unsigned long flags;

727 728 729 730 731 732 733 734
	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");
735
	}
736
	bus_state = &xhci->bus_state[hcd_index(hcd)];
737 738 739 740

	spin_lock_irqsave(&xhci->lock, flags);

	if (hcd->self.root_hub->do_remote_wakeup) {
741 742
		port_index = max_ports;
		while (port_index--) {
743
			if (bus_state->resume_done[port_index] != 0) {
744 745 746
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_dbg(xhci, "suspend failed because "
						"port %d is resuming\n",
747
						port_index + 1);
748 749 750 751 752
				return -EBUSY;
			}
		}
	}

753
	port_index = max_ports;
754
	bus_state->bus_suspended = 0;
755
	while (port_index--) {
756 757 758 759
		/* suspend the port if the port is not suspended */
		u32 t1, t2;
		int slot_id;

760
		t1 = xhci_readl(xhci, port_array[port_index]);
761 762 763
		t2 = xhci_port_state_to_neutral(t1);

		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
764
			xhci_dbg(xhci, "port %d not suspended\n", port_index);
765
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
766
					port_index + 1);
767 768 769 770 771 772 773
			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;
774
			set_bit(port_index, &bus_state->bus_suspended);
775 776 777 778 779 780 781 782 783 784 785 786 787 788
		}
		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)
789
			xhci_writel(xhci, t2, port_array[port_index]);
790 791 792

		if (DEV_HIGHSPEED(t1)) {
			/* enable remote wake up for USB 2.0 */
M
Matt Evans 已提交
793
			__le32 __iomem *addr;
794 795
			u32 tmp;

796 797 798 799
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
800 801 802 803 804 805
			tmp = xhci_readl(xhci, addr);
			tmp |= PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}
	hcd->state = HC_STATE_SUSPENDED;
806
	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
807 808 809 810 811 812 813
	spin_unlock_irqrestore(&xhci->lock, flags);
	return 0;
}

int xhci_bus_resume(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
814
	int max_ports, port_index;
M
Matt Evans 已提交
815
	__le32 __iomem **port_array;
816
	struct xhci_bus_state *bus_state;
817 818 819
	u32 temp;
	unsigned long flags;

820 821 822 823 824 825 826 827
	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");
828
	}
829
	bus_state = &xhci->bus_state[hcd_index(hcd)];
830

831
	if (time_before(jiffies, bus_state->next_statechange))
832 833 834 835 836 837 838 839 840 841 842 843 844
		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);

845 846
	port_index = max_ports;
	while (port_index--) {
847 848 849 850 851
		/* Check whether need resume ports. If needed
		   resume port and disable remote wakeup */
		u32 temp;
		int slot_id;

852
		temp = xhci_readl(xhci, port_array[port_index]);
853 854 855 856
		if (DEV_SUPERSPEED(temp))
			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
		else
			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
857
		if (test_bit(port_index, &bus_state->bus_suspended) &&
858 859 860 861 862
		    (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;
863
				xhci_writel(xhci, temp, port_array[port_index]);
864 865 866 867
			} else {
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_RESUME;
868
				xhci_writel(xhci, temp, port_array[port_index]);
869 870 871 872 873

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

874
				temp = xhci_readl(xhci, port_array[port_index]);
875 876 877
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_U0;
878
				xhci_writel(xhci, temp, port_array[port_index]);
879
			}
880 881
			slot_id = xhci_find_slot_id_by_port(hcd,
					xhci, port_index + 1);
882 883 884
			if (slot_id)
				xhci_ring_device(xhci, slot_id);
		} else
885
			xhci_writel(xhci, temp, port_array[port_index]);
886 887 888

		if (DEV_HIGHSPEED(temp)) {
			/* disable remote wake up for USB 2.0 */
M
Matt Evans 已提交
889
			__le32 __iomem *addr;
890 891
			u32 tmp;

892 893 894 895
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
896 897 898 899 900 901 902 903
			tmp = xhci_readl(xhci, addr);
			tmp &= ~PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}

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

904
	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
905 906 907 908 909 910 911 912 913 914
	/* 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;
}

915
#endif	/* CONFIG_PM */