xhci-hub.c 44.9 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
/*
 * 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.
 */

23 24

#include <linux/slab.h>
Sarah Sharp's avatar
Sarah Sharp committed
25 26 27
#include <asm/unaligned.h>

#include "xhci.h"
28
#include "xhci-trace.h"
Sarah Sharp's avatar
Sarah Sharp committed
29

30 31 32 33
#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)

34 35 36
/* USB 3 BOS descriptor and a capability descriptors, combined.
 * Fields will be adjusted and added later in xhci_create_usb3_bos_desc()
 */
37 38 39 40 41
static u8 usb_bos_descriptor [] = {
	USB_DT_BOS_SIZE,		/*  __u8 bLength, 5 bytes */
	USB_DT_BOS,			/*  __u8 bDescriptorType */
	0x0F, 0x00,			/*  __le16 wTotalLength, 15 bytes */
	0x1,				/*  __u8 bNumDeviceCaps */
42
	/* First device capability, SuperSpeed */
43 44 45 46 47 48 49 50
	USB_DT_USB_SS_CAP_SIZE,		/*  __u8 bLength, 10 bytes */
	USB_DT_DEVICE_CAPABILITY,	/* Device Capability */
	USB_SS_CAP_TYPE,		/* bDevCapabilityType, SUPERSPEED_USB */
	0x00,				/* bmAttributes, LTM off by default */
	USB_5GBPS_OPERATION, 0x00,	/* wSpeedsSupported, 5Gbps only */
	0x03,				/* bFunctionalitySupport,
					   USB 3.0 speed only */
	0x00,				/* bU1DevExitLat, set later. */
51 52
	0x00, 0x00,			/* __le16 bU2DevExitLat, set later. */
	/* Second device capability, SuperSpeedPlus */
53
	0x1c,				/* bLength 28, will be adjusted later */
54 55 56
	USB_DT_DEVICE_CAPABILITY,	/* Device Capability */
	USB_SSP_CAP_TYPE,		/* bDevCapabilityType SUPERSPEED_PLUS */
	0x00,				/* bReserved 0 */
57 58
	0x23, 0x00, 0x00, 0x00,		/* bmAttributes, SSAC=3 SSIC=1 */
	0x01, 0x00,			/* wFunctionalitySupport */
59
	0x00, 0x00,			/* wReserved 0 */
60 61 62 63 64
	/* Default Sublink Speed Attributes, overwrite if custom PSI exists */
	0x34, 0x00, 0x05, 0x00,		/* 5Gbps, symmetric, rx, ID = 4 */
	0xb4, 0x00, 0x05, 0x00,		/* 5Gbps, symmetric, tx, ID = 4 */
	0x35, 0x40, 0x0a, 0x00,		/* 10Gbps, SSP, symmetric, rx, ID = 5 */
	0xb5, 0x40, 0x0a, 0x00,		/* 10Gbps, SSP, symmetric, tx, ID = 5 */
65 66
};

67 68 69 70 71 72 73 74 75 76 77 78
static int xhci_create_usb3_bos_desc(struct xhci_hcd *xhci, char *buf,
				     u16 wLength)
{
	int i, ssa_count;
	u32 temp;
	u16 desc_size, ssp_cap_size, ssa_size = 0;
	bool usb3_1 = false;

	desc_size = USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;
	ssp_cap_size = sizeof(usb_bos_descriptor) - desc_size;

	/* does xhci support USB 3.1 Enhanced SuperSpeed */
79 80 81 82 83 84 85 86
	if (xhci->usb3_rhub.min_rev >= 0x01) {
		/* does xhci provide a PSI table for SSA speed attributes? */
		if (xhci->usb3_rhub.psi_count) {
			/* two SSA entries for each unique PSI ID, RX and TX */
			ssa_count = xhci->usb3_rhub.psi_uid_count * 2;
			ssa_size = ssa_count * sizeof(u32);
			ssp_cap_size -= 16; /* skip copying the default SSA */
		}
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
		desc_size += ssp_cap_size;
		usb3_1 = true;
	}
	memcpy(buf, &usb_bos_descriptor, min(desc_size, wLength));

	if (usb3_1) {
		/* modify bos descriptor bNumDeviceCaps and wTotalLength */
		buf[4] += 1;
		put_unaligned_le16(desc_size + ssa_size, &buf[2]);
	}

	if (wLength < USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE)
		return wLength;

	/* Indicate whether the host has LTM support. */
	temp = readl(&xhci->cap_regs->hcc_params);
	if (HCC_LTC(temp))
		buf[8] |= USB_LTM_SUPPORT;

	/* Set the U1 and U2 exit latencies. */
	if ((xhci->quirks & XHCI_LPM_SUPPORT)) {
		temp = readl(&xhci->cap_regs->hcs_params3);
		buf[12] = HCS_U1_LATENCY(temp);
		put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
	}

113 114
	/* If PSI table exists, add the custom speed attributes from it */
	if (usb3_1 && xhci->usb3_rhub.psi_count) {
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 152 153 154 155 156 157 158 159 160 161
		u32 ssp_cap_base, bm_attrib, psi;
		int offset;

		ssp_cap_base = USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;

		if (wLength < desc_size)
			return wLength;
		buf[ssp_cap_base] = ssp_cap_size + ssa_size;

		/* attribute count SSAC bits 4:0 and ID count SSIC bits 8:5 */
		bm_attrib = (ssa_count - 1) & 0x1f;
		bm_attrib |= (xhci->usb3_rhub.psi_uid_count - 1) << 5;
		put_unaligned_le32(bm_attrib, &buf[ssp_cap_base + 4]);

		if (wLength < desc_size + ssa_size)
			return wLength;
		/*
		 * Create the Sublink Speed Attributes (SSA) array.
		 * The xhci PSI field and USB 3.1 SSA fields are very similar,
		 * but link type bits 7:6 differ for values 01b and 10b.
		 * xhci has also only one PSI entry for a symmetric link when
		 * USB 3.1 requires two SSA entries (RX and TX) for every link
		 */
		offset = desc_size;
		for (i = 0; i < xhci->usb3_rhub.psi_count; i++) {
			psi = xhci->usb3_rhub.psi[i];
			psi &= ~USB_SSP_SUBLINK_SPEED_RSVD;
			if ((psi & PLT_MASK) == PLT_SYM) {
			/* Symmetric, create SSA RX and TX from one PSI entry */
				put_unaligned_le32(psi, &buf[offset]);
				psi |= 1 << 7;  /* turn entry to TX */
				offset += 4;
				if (offset >= desc_size + ssa_size)
					return desc_size + ssa_size;
			} else if ((psi & PLT_MASK) == PLT_ASYM_RX) {
				/* Asymetric RX, flip bits 7:6 for SSA */
				psi ^= PLT_MASK;
			}
			put_unaligned_le32(psi, &buf[offset]);
			offset += 4;
			if (offset >= desc_size + ssa_size)
				return desc_size + ssa_size;
		}
	}
	/* ssa_size is 0 for other than usb 3.1 hosts */
	return desc_size + ssa_size;
}
162

163 164
static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
		struct usb_hub_descriptor *desc, int ports)
Sarah Sharp's avatar
Sarah Sharp committed
165 166 167 168 169 170 171 172
{
	u16 temp;

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

	desc->bNbrPorts = ports;
	temp = 0;
173
	/* Bits 1:0 - support per-port power switching, or power always on */
Sarah Sharp's avatar
Sarah Sharp committed
174
	if (HCC_PPC(xhci->hcc_params))
175
		temp |= HUB_CHAR_INDV_PORT_LPSM;
Sarah Sharp's avatar
Sarah Sharp committed
176
	else
177
		temp |= HUB_CHAR_NO_LPSM;
Sarah Sharp's avatar
Sarah Sharp committed
178 179
	/* Bit  2 - root hubs are not part of a compound device */
	/* Bits 4:3 - individual port over current protection */
180
	temp |= HUB_CHAR_INDV_PORT_OCPM;
Sarah Sharp's avatar
Sarah Sharp committed
181 182
	/* Bits 6:5 - no TTs in root ports */
	/* Bit  7 - no port indicators */
183
	desc->wHubCharacteristics = cpu_to_le16(temp);
Sarah Sharp's avatar
Sarah Sharp committed
184 185
}

186 187 188 189 190 191 192 193 194 195 196 197 198
/* 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);
199
	desc->bDescriptorType = USB_DT_HUB;
200
	temp = 1 + (ports / 8);
201
	desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * temp;
202 203 204 205 206 207

	/* 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++) {
208
		portsc = readl(xhci->usb2_ports[i]);
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
		/* 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);
250 251
	desc->bDescriptorType = USB_DT_SS_HUB;
	desc->bDescLength = USB_DT_SS_HUB_SIZE;
252 253 254 255 256 257 258 259 260 261

	/* 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++) {
262
		portsc = readl(xhci->usb3_ports[i]);
263 264 265
		if (portsc & PORT_DEV_REMOVE)
			port_removable |= 1 << (i + 1);
	}
266 267

	desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
268 269 270 271 272 273
}

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

274
	if (hcd->speed >= HCD_USB3)
275 276 277 278 279 280
		xhci_usb3_hub_descriptor(hcd, xhci, desc);
	else
		xhci_usb2_hub_descriptor(hcd, xhci, desc);

}

Sarah Sharp's avatar
Sarah Sharp committed
281 282 283
static unsigned int xhci_port_speed(unsigned int port_status)
{
	if (DEV_LOWSPEED(port_status))
284
		return USB_PORT_STAT_LOW_SPEED;
Sarah Sharp's avatar
Sarah Sharp committed
285
	if (DEV_HIGHSPEED(port_status))
286
		return USB_PORT_STAT_HIGH_SPEED;
Sarah Sharp's avatar
Sarah Sharp committed
287 288 289
	/*
	 * 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
290
	 * USB_PORT_STAT_*_SPEED is used).
Sarah Sharp's avatar
Sarah Sharp committed
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	 */
	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.
 */
341
u32 xhci_port_state_to_neutral(u32 state)
Sarah Sharp's avatar
Sarah Sharp committed
342 343 344 345 346
{
	/* Save read-only status and port state */
	return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
}

347 348
/*
 * find slot id based on port number.
349
 * @port: The one-based port number from one of the two split roothubs.
350
 */
351 352
int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		u16 port)
353 354 355
{
	int slot_id;
	int i;
356
	enum usb_device_speed speed;
357 358 359

	slot_id = 0;
	for (i = 0; i < MAX_HC_SLOTS; i++) {
360
		if (!xhci->devs[i] || !xhci->devs[i]->udev)
361
			continue;
362
		speed = xhci->devs[i]->udev->speed;
363
		if (((speed >= USB_SPEED_SUPER) == (hcd->speed >= HCD_USB3))
364
				&& xhci->devs[i]->fake_port == port) {
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
			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 ret;
	int i;

	ret = 0;
	virt_dev = xhci->devs[slot_id];
389 390 391
	if (!virt_dev)
		return -ENODEV;

392 393 394 395 396 397 398 399
	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--) {
400 401 402
		if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue) {
			struct xhci_command *command;
			command = xhci_alloc_command(xhci, false, false,
403
						     GFP_NOWAIT);
404 405
			if (!command) {
				spin_unlock_irqrestore(&xhci->lock, flags);
406 407 408
				ret = -ENOMEM;
				goto cmd_cleanup;
			}
409

410 411 412 413 414 415
			ret = xhci_queue_stop_endpoint(xhci, command, slot_id,
						       i, suspend);
			if (ret) {
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_free_command(xhci, command);
				goto cmd_cleanup;
416 417
			}
		}
418
	}
419 420 421 422 423 424
	ret = xhci_queue_stop_endpoint(xhci, cmd, slot_id, 0, suspend);
	if (ret) {
		spin_unlock_irqrestore(&xhci->lock, flags);
		goto cmd_cleanup;
	}

425 426 427 428
	xhci_ring_cmd_db(xhci);
	spin_unlock_irqrestore(&xhci->lock, flags);

	/* Wait for last stop endpoint command to finish */
429 430 431 432
	wait_for_completion(cmd->completion);

	if (cmd->status == COMP_CMD_ABORT || cmd->status == COMP_CMD_STOP) {
		xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
433 434
		ret = -ETIME;
	}
435 436

cmd_cleanup:
437 438 439 440 441 442 443
	xhci_free_command(xhci, cmd);
	return ret;
}

/*
 * Ring device, it rings the all doorbells unconditionally.
 */
444
void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
445
{
446 447 448 449 450
	int i, s;
	struct xhci_virt_ep *ep;

	for (i = 0; i < LAST_EP_INDEX + 1; i++) {
		ep = &xhci->devs[slot_id]->eps[i];
451

452 453 454 455
		if (ep->ep_state & EP_HAS_STREAMS) {
			for (s = 1; s < ep->stream_info->num_streams; s++)
				xhci_ring_ep_doorbell(xhci, slot_id, i, s);
		} else if (ep->ring && ep->ring->dequeue) {
456
			xhci_ring_ep_doorbell(xhci, slot_id, i, 0);
457 458
		}
	}
459 460 461 462

	return;
}

463
static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
464
		u16 wIndex, __le32 __iomem *addr, u32 port_status)
465
{
466
	/* Don't allow the USB core to disable SuperSpeed ports. */
467
	if (hcd->speed >= HCD_USB3) {
468 469 470 471 472
		xhci_dbg(xhci, "Ignoring request to disable "
				"SuperSpeed port.\n");
		return;
	}

473
	/* Write 1 to disable the port */
474
	writel(port_status | PORT_PE, addr);
475
	port_status = readl(addr);
476 477 478 479
	xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",
			wIndex, port_status);
}

480
static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
481
		u16 wIndex, __le32 __iomem *addr, u32 port_status)
482 483 484 485 486 487 488 489 490
{
	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
491 492 493 494
	case USB_PORT_FEAT_C_BH_PORT_RESET:
		status = PORT_WRC;
		port_change_bit = "warm(BH) reset";
		break;
495 496 497 498 499 500 501 502
	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;
503 504 505 506
	case USB_PORT_FEAT_C_ENABLE:
		status = PORT_PEC;
		port_change_bit = "enable/disable";
		break;
507 508 509 510
	case USB_PORT_FEAT_C_SUSPEND:
		status = PORT_PLC;
		port_change_bit = "suspend/resume";
		break;
511 512 513 514
	case USB_PORT_FEAT_C_PORT_LINK_STATE:
		status = PORT_PLC;
		port_change_bit = "link state";
		break;
515 516 517 518
	case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
		status = PORT_CEC;
		port_change_bit = "config error";
		break;
519 520 521 522 523
	default:
		/* Should never happen */
		return;
	}
	/* Change bits are all write 1 to clear */
524
	writel(port_status | status, addr);
525
	port_status = readl(addr);
526 527 528 529
	xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
			port_change_bit, wIndex, port_status);
}

530 531 532 533 534
static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
{
	int max_ports;
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);

535
	if (hcd->speed >= HCD_USB3) {
536 537 538 539 540 541 542 543 544 545
		max_ports = xhci->num_usb3_ports;
		*port_array = xhci->usb3_ports;
	} else {
		max_ports = xhci->num_usb2_ports;
		*port_array = xhci->usb2_ports;
	}

	return max_ports;
}

Andiry Xu's avatar
Andiry Xu committed
546 547 548 549 550
void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
				int port_id, u32 link_state)
{
	u32 temp;

551
	temp = readl(port_array[port_id]);
Andiry Xu's avatar
Andiry Xu committed
552 553 554
	temp = xhci_port_state_to_neutral(temp);
	temp &= ~PORT_PLS_MASK;
	temp |= PORT_LINK_STROBE | link_state;
555
	writel(temp, port_array[port_id]);
Andiry Xu's avatar
Andiry Xu committed
556 557
}

Felipe Balbi's avatar
Felipe Balbi committed
558
static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
559 560 561 562
		__le32 __iomem **port_array, int port_id, u16 wake_mask)
{
	u32 temp;

563
	temp = readl(port_array[port_id]);
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
	temp = xhci_port_state_to_neutral(temp);

	if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_CONNECT)
		temp |= PORT_WKCONN_E;
	else
		temp &= ~PORT_WKCONN_E;

	if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT)
		temp |= PORT_WKDISC_E;
	else
		temp &= ~PORT_WKDISC_E;

	if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT)
		temp |= PORT_WKOC_E;
	else
		temp &= ~PORT_WKOC_E;

581
	writel(temp, port_array[port_id]);
582 583
}

Andiry Xu's avatar
Andiry Xu committed
584 585 586 587 588 589
/* Test and clear port RWC bit */
void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
				int port_id, u32 port_bit)
{
	u32 temp;

590
	temp = readl(port_array[port_id]);
Andiry Xu's avatar
Andiry Xu committed
591 592 593
	if (temp & port_bit) {
		temp = xhci_port_state_to_neutral(temp);
		temp |= port_bit;
594
		writel(temp, port_array[port_id]);
Andiry Xu's avatar
Andiry Xu committed
595 596 597
	}
}

598 599 600 601 602 603 604
/* Updates Link Status for USB 2.1 port */
static void xhci_hub_report_usb2_link_state(u32 *status, u32 status_reg)
{
	if ((status_reg & PORT_PLS_MASK) == XDEV_U2)
		*status |= USB_PORT_STAT_L1;
}

605
/* Updates Link Status for super Speed port */
606 607
static void xhci_hub_report_usb3_link_state(struct xhci_hcd *xhci,
		u32 *status, u32 status_reg)
608 609 610 611
{
	u32 pls = status_reg & PORT_PLS_MASK;

	/* resume state is a xHCI internal state.
612 613
	 * Do not report it to usb core, instead, pretend to be U3,
	 * thus usb core knows it's not ready for transfer
614
	 */
615 616
	if (pls == XDEV_RESUME) {
		*status |= USB_SS_PORT_LS_U3;
617
		return;
618
	}
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639

	/* When the CAS bit is set then warm reset
	 * should be performed on port
	 */
	if (status_reg & PORT_CAS) {
		/* The CAS bit can be set while the port is
		 * in any link state.
		 * Only roothubs have CAS bit, so we
		 * pretend to be in compliance mode
		 * unless we're already in compliance
		 * or the inactive state.
		 */
		if (pls != USB_SS_PORT_LS_COMP_MOD &&
		    pls != USB_SS_PORT_LS_SS_INACTIVE) {
			pls = USB_SS_PORT_LS_COMP_MOD;
		}
		/* Return also connection bit -
		 * hub state machine resets port
		 * when this bit is set.
		 */
		pls |= USB_PORT_STAT_CONNECTION;
640 641 642 643 644 645 646 647 648
	} else {
		/*
		 * If CAS bit isn't set but the Port is already at
		 * Compliance Mode, fake a connection so the USB core
		 * notices the Compliance state and resets the port.
		 * This resolves an issue generated by the SN65LVPE502CP
		 * in which sometimes the port enters compliance mode
		 * caused by a delay on the host-device negotiation.
		 */
649 650
		if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
				(pls == USB_SS_PORT_LS_COMP_MOD))
651
			pls |= USB_PORT_STAT_CONNECTION;
652
	}
653

654 655 656 657
	/* update status field */
	*status |= pls;
}

658 659 660 661 662 663 664
/*
 * Function for Compliance Mode Quirk.
 *
 * This Function verifies if all xhc USB3 ports have entered U0, if so,
 * the compliance mode timer is deleted. A port won't enter
 * compliance mode if it has previously entered U0.
 */
665 666
static void xhci_del_comp_mod_timer(struct xhci_hcd *xhci, u32 status,
				    u16 wIndex)
667 668 669 670 671 672 673 674 675 676 677
{
	u32 all_ports_seen_u0 = ((1 << xhci->num_usb3_ports)-1);
	bool port_in_u0 = ((status & PORT_PLS_MASK) == XDEV_U0);

	if (!(xhci->quirks & XHCI_COMP_MODE_QUIRK))
		return;

	if ((xhci->port_status_u0 != all_ports_seen_u0) && port_in_u0) {
		xhci->port_status_u0 |= 1 << wIndex;
		if (xhci->port_status_u0 == all_ports_seen_u0) {
			del_timer_sync(&xhci->comp_mode_recovery_timer);
678 679 680 681
			xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
				"All USB3 ports have entered U0 already!");
			xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
				"Compliance Mode Recovery Timer Deleted.");
682 683 684 685
		}
	}
}

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
static u32 xhci_get_ext_port_status(u32 raw_port_status, u32 port_li)
{
	u32 ext_stat = 0;
	int speed_id;

	/* only support rx and tx lane counts of 1 in usb3.1 spec */
	speed_id = DEV_PORT_SPEED(raw_port_status);
	ext_stat |= speed_id;		/* bits 3:0, RX speed id */
	ext_stat |= speed_id << 4;	/* bits 7:4, TX speed id */

	ext_stat |= PORT_RX_LANES(port_li) << 8;  /* bits 11:8 Rx lane count */
	ext_stat |= PORT_TX_LANES(port_li) << 12; /* bits 15:12 Tx lane count */

	return ext_stat;
}

702 703 704 705 706 707 708 709
/*
 * Converts a raw xHCI port status into the format that external USB 2.0 or USB
 * 3.0 hubs use.
 *
 * Possible side effects:
 *  - Mark a port as being done with device resume,
 *    and ring the endpoint doorbells.
 *  - Stop the Synopsys redriver Compliance Mode polling.
710
 *  - Drop and reacquire the xHCI lock, in order to wait for port resume.
711 712 713 714
 */
static u32 xhci_get_port_status(struct usb_hcd *hcd,
		struct xhci_bus_state *bus_state,
		__le32 __iomem **port_array,
715 716 717 718
		u16 wIndex, u32 raw_port_status,
		unsigned long flags)
	__releases(&xhci->lock)
	__acquires(&xhci->lock)
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
{
	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
	u32 status = 0;
	int slot_id;

	/* wPortChange bits */
	if (raw_port_status & PORT_CSC)
		status |= USB_PORT_STAT_C_CONNECTION << 16;
	if (raw_port_status & PORT_PEC)
		status |= USB_PORT_STAT_C_ENABLE << 16;
	if ((raw_port_status & PORT_OCC))
		status |= USB_PORT_STAT_C_OVERCURRENT << 16;
	if ((raw_port_status & PORT_RC))
		status |= USB_PORT_STAT_C_RESET << 16;
	/* USB3.0 only */
734
	if (hcd->speed >= HCD_USB3) {
735 736 737 738 739 740 741 742
		/* Port link change with port in resume state should not be
		 * reported to usbcore, as this is an internal state to be
		 * handled by xhci driver. Reporting PLC to usbcore may
		 * cause usbcore clearing PLC first and port change event
		 * irq won't be generated.
		 */
		if ((raw_port_status & PORT_PLC) &&
			(raw_port_status & PORT_PLS_MASK) != XDEV_RESUME)
743 744 745
			status |= USB_PORT_STAT_C_LINK_STATE << 16;
		if ((raw_port_status & PORT_WRC))
			status |= USB_PORT_STAT_C_BH_RESET << 16;
746 747
		if ((raw_port_status & PORT_CEC))
			status |= USB_PORT_STAT_C_CONFIG_ERROR << 16;
748 749
	}

750
	if (hcd->speed < HCD_USB3) {
751 752 753 754 755
		if ((raw_port_status & PORT_PLS_MASK) == XDEV_U3
				&& (raw_port_status & PORT_POWER))
			status |= USB_PORT_STAT_SUSPEND;
	}
	if ((raw_port_status & PORT_PLS_MASK) == XDEV_RESUME &&
756
		!DEV_SUPERSPEED_ANY(raw_port_status) && hcd->speed < HCD_USB3) {
757 758 759
		if ((raw_port_status & PORT_RESET) ||
				!(raw_port_status & PORT_PE))
			return 0xffffffff;
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
		/* did port event handler already start resume timing? */
		if (!bus_state->resume_done[wIndex]) {
			/* If not, maybe we are in a host initated resume? */
			if (test_bit(wIndex, &bus_state->resuming_ports)) {
				/* Host initated resume doesn't time the resume
				 * signalling using resume_done[].
				 * It manually sets RESUME state, sleeps 20ms
				 * and sets U0 state. This should probably be
				 * changed, but not right now.
				 */
			} else {
				/* port resume was discovered now and here,
				 * start resume timing
				 */
				unsigned long timeout = jiffies +
					msecs_to_jiffies(USB_RESUME_TIMEOUT);

				set_bit(wIndex, &bus_state->resuming_ports);
				bus_state->resume_done[wIndex] = timeout;
				mod_timer(&hcd->rh_timer, timeout);
			}
		/* Has resume been signalled for USB_RESUME_TIME yet? */
		} else if (time_after_eq(jiffies,
					 bus_state->resume_done[wIndex])) {
784 785
			int time_left;

786 787 788 789
			xhci_dbg(xhci, "Resume USB2 port %d\n",
					wIndex + 1);
			bus_state->resume_done[wIndex] = 0;
			clear_bit(wIndex, &bus_state->resuming_ports);
790 791

			set_bit(wIndex, &bus_state->rexit_ports);
792 793 794

			xhci_test_and_clear_bit(xhci, port_array, wIndex,
						PORT_PLC);
795 796
			xhci_set_link_state(xhci, port_array, wIndex,
					XDEV_U0);
797 798 799 800 801

			spin_unlock_irqrestore(&xhci->lock, flags);
			time_left = wait_for_completion_timeout(
					&bus_state->rexit_done[wIndex],
					msecs_to_jiffies(
802
						XHCI_MAX_REXIT_TIMEOUT_MS));
803 804 805 806 807 808 809 810 811 812 813
			spin_lock_irqsave(&xhci->lock, flags);

			if (time_left) {
				slot_id = xhci_find_slot_id_by_port(hcd,
						xhci, wIndex + 1);
				if (!slot_id) {
					xhci_dbg(xhci, "slot_id is zero\n");
					return 0xffffffff;
				}
				xhci_ring_device(xhci, slot_id);
			} else {
814
				int port_status = readl(port_array[wIndex]);
815
				xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",
816
						XHCI_MAX_REXIT_TIMEOUT_MS,
817 818 819
						port_status);
				status |= USB_PORT_STAT_SUSPEND;
				clear_bit(wIndex, &bus_state->rexit_ports);
820
			}
821

822 823 824 825 826
			bus_state->port_c_suspend |= 1 << wIndex;
			bus_state->suspended_ports &= ~(1 << wIndex);
		} else {
			/*
			 * The resume has been signaling for less than
827 828 829
			 * USB_RESUME_TIME. Report the port status as SUSPEND,
			 * let the usbcore check port status again and clear
			 * resume signaling later.
830 831 832 833
			 */
			status |= USB_PORT_STAT_SUSPEND;
		}
	}
834 835 836 837 838 839 840 841 842 843 844 845 846
	/*
	 * Clear stale usb2 resume signalling variables in case port changed
	 * state during resume signalling. For example on error
	 */
	if ((bus_state->resume_done[wIndex] ||
	     test_bit(wIndex, &bus_state->resuming_ports)) &&
	    (raw_port_status & PORT_PLS_MASK) != XDEV_U3 &&
	    (raw_port_status & PORT_PLS_MASK) != XDEV_RESUME) {
		bus_state->resume_done[wIndex] = 0;
		clear_bit(wIndex, &bus_state->resuming_ports);
	}


847 848 849 850 851 852 853 854 855
	if ((raw_port_status & PORT_PLS_MASK) == XDEV_U0 &&
	    (raw_port_status & PORT_POWER)) {
		if (bus_state->suspended_ports & (1 << wIndex)) {
			bus_state->suspended_ports &= ~(1 << wIndex);
			if (hcd->speed < HCD_USB3)
				bus_state->port_c_suspend |= 1 << wIndex;
		}
		bus_state->resume_done[wIndex] = 0;
		clear_bit(wIndex, &bus_state->resuming_ports);
856 857 858 859 860 861 862 863 864 865 866 867
	}
	if (raw_port_status & PORT_CONNECT) {
		status |= USB_PORT_STAT_CONNECTION;
		status |= xhci_port_speed(raw_port_status);
	}
	if (raw_port_status & PORT_PE)
		status |= USB_PORT_STAT_ENABLE;
	if (raw_port_status & PORT_OC)
		status |= USB_PORT_STAT_OVERCURRENT;
	if (raw_port_status & PORT_RESET)
		status |= USB_PORT_STAT_RESET;
	if (raw_port_status & PORT_POWER) {
868
		if (hcd->speed >= HCD_USB3)
869 870 871 872
			status |= USB_SS_PORT_STAT_POWER;
		else
			status |= USB_PORT_STAT_POWER;
	}
873
	/* Update Port Link State */
874
	if (hcd->speed >= HCD_USB3) {
875
		xhci_hub_report_usb3_link_state(xhci, &status, raw_port_status);
876 877 878 879 880
		/*
		 * Verify if all USB3 Ports Have entered U0 already.
		 * Delete Compliance Mode Timer if so.
		 */
		xhci_del_comp_mod_timer(xhci, raw_port_status, wIndex);
881 882
	} else {
		xhci_hub_report_usb2_link_state(&status, raw_port_status);
883 884 885 886 887 888 889
	}
	if (bus_state->port_c_suspend & (1 << wIndex))
		status |= 1 << USB_PORT_FEAT_C_SUSPEND;

	return status;
}

Sarah Sharp's avatar
Sarah Sharp committed
890 891 892 893
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);
894
	int max_ports;
Sarah Sharp's avatar
Sarah Sharp committed
895
	unsigned long flags;
Andiry Xu's avatar
Andiry Xu committed
896
	u32 temp, status;
Sarah Sharp's avatar
Sarah Sharp committed
897
	int retval = 0;
898
	__le32 __iomem **port_array;
899
	int slot_id;
900
	struct xhci_bus_state *bus_state;
Andiry Xu's avatar
Andiry Xu committed
901
	u16 link_state = 0;
902
	u16 wake_mask = 0;
903
	u16 timeout = 0;
Sarah Sharp's avatar
Sarah Sharp committed
904

905
	max_ports = xhci_get_ports(hcd, &port_array);
906
	bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp's avatar
Sarah Sharp committed
907 908 909 910 911 912 913 914

	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:
915 916 917 918
		/* 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.
		 */
919
		if (hcd->speed >= HCD_USB3 &&
920 921 922 923 924 925
				(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;
		}
926 927
		xhci_hub_descriptor(hcd, xhci,
				(struct usb_hub_descriptor *) buf);
Sarah Sharp's avatar
Sarah Sharp committed
928
		break;
929 930 931 932
	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
		if ((wValue & 0xff00) != (USB_DT_BOS << 8))
			goto error;

933
		if (hcd->speed < HCD_USB3)
934 935
			goto error;

936
		retval = xhci_create_usb3_bos_desc(xhci, buf, wLength);
937
		spin_unlock_irqrestore(&xhci->lock, flags);
938
		return retval;
Sarah Sharp's avatar
Sarah Sharp committed
939
	case GetPortStatus:
940
		if (!wIndex || wIndex > max_ports)
Sarah Sharp's avatar
Sarah Sharp committed
941 942
			goto error;
		wIndex--;
943
		temp = readl(port_array[wIndex]);
944 945 946 947
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
948
		status = xhci_get_port_status(hcd, bus_state, port_array,
949
				wIndex, temp, flags);
950 951
		if (status == 0xffffffff)
			goto error;
952

953 954
		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n",
				wIndex, temp);
Sarah Sharp's avatar
Sarah Sharp committed
955
		xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
956

Sarah Sharp's avatar
Sarah Sharp committed
957
		put_unaligned(cpu_to_le32(status), (__le32 *) buf);
958 959 960 961 962 963 964 965 966 967 968 969 970
		/* if USB 3.1 extended port status return additional 4 bytes */
		if (wValue == 0x02) {
			u32 port_li;

			if (hcd->speed < HCD_USB31 || wLength != 8) {
				xhci_err(xhci, "get ext port status invalid parameter\n");
				retval = -EINVAL;
				break;
			}
			port_li = readl(port_array[wIndex] + PORTLI);
			status = xhci_get_ext_port_status(temp, port_li);
			put_unaligned_le32(cpu_to_le32(status), &buf[4]);
		}
Sarah Sharp's avatar
Sarah Sharp committed
971 972
		break;
	case SetPortFeature:
Andiry Xu's avatar
Andiry Xu committed
973 974
		if (wValue == USB_PORT_FEAT_LINK_STATE)
			link_state = (wIndex & 0xff00) >> 3;
975 976
		if (wValue == USB_PORT_FEAT_REMOTE_WAKE_MASK)
			wake_mask = wIndex & 0xff00;
977 978
		/* The MSB of wIndex is the U1/U2 timeout */
		timeout = (wIndex & 0xff00) >> 8;
Sarah Sharp's avatar
Sarah Sharp committed
979
		wIndex &= 0xff;
980
		if (!wIndex || wIndex > max_ports)
Sarah Sharp's avatar
Sarah Sharp committed
981 982
			goto error;
		wIndex--;
983
		temp = readl(port_array[wIndex]);
984 985 986 987
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
Sarah Sharp's avatar
Sarah Sharp committed
988
		temp = xhci_port_state_to_neutral(temp);
989
		/* FIXME: What new port features do we need to support? */
Sarah Sharp's avatar
Sarah Sharp committed
990
		switch (wValue) {
991
		case USB_PORT_FEAT_SUSPEND:
992
			temp = readl(port_array[wIndex]);
Andiry Xu's avatar
Andiry Xu committed
993 994 995 996 997 998 999 1000
			if ((temp & PORT_PLS_MASK) != XDEV_U0) {
				/* Resume the port to U0 first */
				xhci_set_link_state(xhci, port_array, wIndex,
							XDEV_U0);
				spin_unlock_irqrestore(&xhci->lock, flags);
				msleep(10);
				spin_lock_irqsave(&xhci->lock, flags);
			}
1001 1002 1003 1004
			/* 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.
			 */
1005
			temp = readl(port_array[wIndex]);
1006 1007 1008 1009 1010 1011 1012
			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;
			}

1013 1014
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
1015 1016 1017 1018 1019 1020 1021 1022 1023
			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);

Andiry Xu's avatar
Andiry Xu committed
1024
			xhci_set_link_state(xhci, port_array, wIndex, XDEV_U3);
1025 1026 1027 1028 1029

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

1030
			temp = readl(port_array[wIndex]);
1031
			bus_state->suspended_ports |= 1 << wIndex;
1032
			break;
Andiry Xu's avatar
Andiry Xu committed
1033
		case USB_PORT_FEAT_LINK_STATE:
1034
			temp = readl(port_array[wIndex]);
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046

			/* Disable port */
			if (link_state == USB_SS_PORT_LS_SS_DISABLED) {
				xhci_dbg(xhci, "Disable port %d\n", wIndex);
				temp = xhci_port_state_to_neutral(temp);
				/*
				 * Clear all change bits, so that we get a new
				 * connection event.
				 */
				temp |= PORT_CSC | PORT_PEC | PORT_WRC |
					PORT_OCC | PORT_RC | PORT_PLC |
					PORT_CEC;
1047
				writel(temp | PORT_PE, port_array[wIndex]);
1048
				temp = readl(port_array[wIndex]);
1049 1050 1051 1052 1053 1054 1055 1056
				break;
			}

			/* Put link in RxDetect (enable port) */
			if (link_state == USB_SS_PORT_LS_RX_DETECT) {
				xhci_dbg(xhci, "Enable port %d\n", wIndex);
				xhci_set_link_state(xhci, port_array, wIndex,
						link_state);
1057
				temp = readl(port_array[wIndex]);
1058 1059
				break;
			}
1060 1061 1062 1063 1064 1065 1066 1067 1068
			/* Port must be enabled */
			if (!(temp & PORT_PE)) {
				retval = -ENODEV;
				break;
			}
			/* Can't set port link state above '3' (U3) */
			if (link_state > USB_SS_PORT_LS_U3) {
				xhci_warn(xhci, "Cannot set port %d link state %d\n",
					 wIndex, link_state);
Andiry Xu's avatar
Andiry Xu committed
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
				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);
				}
			}

Andiry Xu's avatar
Andiry Xu committed
1084 1085
			xhci_set_link_state(xhci, port_array, wIndex,
						link_state);
Andiry Xu's avatar
Andiry Xu committed
1086 1087 1088 1089 1090

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

1091
			temp = readl(port_array[wIndex]);
Andiry Xu's avatar
Andiry Xu committed
1092 1093 1094
			if (link_state == USB_SS_PORT_LS_U3)
				bus_state->suspended_ports |= 1 << wIndex;
			break;
Sarah Sharp's avatar
Sarah Sharp committed
1095 1096 1097 1098
		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.
1099
			 * However, hub_wq will ignore the roothub events until
Sarah Sharp's avatar
Sarah Sharp committed
1100 1101
			 * the roothub is registered.
			 */
1102
			writel(temp | PORT_POWER, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
1103

1104
			temp = readl(port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
1105
			xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
1106

1107
			spin_unlock_irqrestore(&xhci->lock, flags);
1108 1109 1110 1111 1112
			temp = usb_acpi_power_manageable(hcd->self.root_hub,
					wIndex);
			if (temp)
				usb_acpi_set_power_state(hcd->self.root_hub,
						wIndex, true);
1113
			spin_lock_irqsave(&xhci->lock, flags);
Sarah Sharp's avatar
Sarah Sharp committed
1114 1115 1116
			break;
		case USB_PORT_FEAT_RESET:
			temp = (temp | PORT_RESET);
1117
			writel(temp, port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
1118

1119
			temp = readl(port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
1120 1121
			xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
			break;
1122 1123 1124
		case USB_PORT_FEAT_REMOTE_WAKE_MASK:
			xhci_set_remote_wake_mask(xhci, port_array,
					wIndex, wake_mask);
1125
			temp = readl(port_array[wIndex]);
1126 1127 1128 1129
			xhci_dbg(xhci, "set port remote wake mask, "
					"actual port %d status  = 0x%x\n",
					wIndex, temp);
			break;
Andiry Xu's avatar
Andiry Xu committed
1130 1131
		case USB_PORT_FEAT_BH_PORT_RESET:
			temp |= PORT_WR;
1132
			writel(temp, port_array[wIndex]);
Andiry Xu's avatar
Andiry Xu committed
1133

1134
			temp = readl(port_array[wIndex]);
Andiry Xu's avatar
Andiry Xu committed
1135
			break;
1136
		case USB_PORT_FEAT_U1_TIMEOUT:
1137
			if (hcd->speed < HCD_USB3)
1138
				goto error;
1139
			temp = readl(port_array[wIndex] + PORTPMSC);
1140 1141
			temp &= ~PORT_U1_TIMEOUT_MASK;
			temp |= PORT_U1_TIMEOUT(timeout);
1142
			writel(temp, port_array[wIndex] + PORTPMSC);
1143 1144
			break;
		case USB_PORT_FEAT_U2_TIMEOUT:
1145
			if (hcd->speed < HCD_USB3)
1146
				goto error;
1147
			temp = readl(port_array[wIndex] + PORTPMSC);
1148 1149
			temp &= ~PORT_U2_TIMEOUT_MASK;
			temp |= PORT_U2_TIMEOUT(timeout);
1150
			writel(temp, port_array[wIndex] + PORTPMSC);
1151
			break;
Sarah Sharp's avatar
Sarah Sharp committed
1152 1153 1154
		default:
			goto error;
		}
1155
		/* unblock any posted writes */
1156
		temp = readl(port_array[wIndex]);
Sarah Sharp's avatar
Sarah Sharp committed
1157 1158
		break;
	case ClearPortFeature:
1159
		if (!wIndex || wIndex > max_ports)
Sarah Sharp's avatar
Sarah Sharp committed
1160 1161
			goto error;
		wIndex--;
1162
		temp = readl(port_array[wIndex]);
1163 1164 1165 1166
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
1167
		/* FIXME: What new port features do we need to support? */
Sarah Sharp's avatar
Sarah Sharp committed
1168 1169
		temp = xhci_port_state_to_neutral(temp);
		switch (wValue) {
1170
		case USB_PORT_FEAT_SUSPEND:
1171
			temp = readl(port_array[wIndex]);
1172 1173 1174 1175
			xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
			xhci_dbg(xhci, "PORTSC %04x\n", temp);
			if (temp & PORT_RESET)
				goto error;
1176
			if ((temp & PORT_PLS_MASK) == XDEV_U3) {
1177 1178 1179
				if ((temp & PORT_PE) == 0)
					goto error;

1180
				set_bit(wIndex, &bus_state->resuming_ports);
Andiry Xu's avatar
Andiry Xu committed
1181 1182 1183
				xhci_set_link_state(xhci, port_array, wIndex,
							XDEV_RESUME);
				spin_unlock_irqrestore(&xhci->lock, flags);
1184
				msleep(USB_RESUME_TIMEOUT);
1185
				spin_lock_irqsave(&xhci->lock, flags);
Andiry Xu's avatar
Andiry Xu committed
1186 1187
				xhci_set_link_state(xhci, port_array, wIndex,
							XDEV_U0);
1188
				clear_bit(wIndex, &bus_state->resuming_ports);
1189
			}
1190
			bus_state->port_c_suspend |= 1 << wIndex;
1191

1192 1193
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
1194 1195 1196 1197 1198 1199 1200
			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:
1201
			bus_state->port_c_suspend &= ~(1 << wIndex);
Sarah Sharp's avatar
Sarah Sharp committed
1202
		case USB_PORT_FEAT_C_RESET:
Andiry Xu's avatar
Andiry Xu committed
1203
		case USB_PORT_FEAT_C_BH_PORT_RESET:
Sarah Sharp's avatar
Sarah Sharp committed
1204 1205
		case USB_PORT_FEAT_C_CONNECTION:
		case USB_PORT_FEAT_C_OVER_CURRENT:
1206
		case USB_PORT_FEAT_C_ENABLE:
1207
		case USB_PORT_FEAT_C_PORT_LINK_STATE:
1208
		case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
1209
			xhci_clear_port_change_bit(xhci, wValue, wIndex,
1210
					port_array[wIndex], temp);
Sarah Sharp's avatar
Sarah Sharp committed
1211
			break;
1212
		case USB_PORT_FEAT_ENABLE:
1213
			xhci_disable_port(hcd, xhci, wIndex,
1214
					port_array[wIndex], temp);
1215
			break;
1216
		case USB_PORT_FEAT_POWER:
1217
			writel(temp & ~PORT_POWER, port_array[wIndex]);
1218

1219
			spin_unlock_irqrestore(&xhci->lock, flags);
1220 1221 1222 1223 1224
			temp = usb_acpi_power_manageable(hcd->self.root_hub,
					wIndex);
			if (temp)
				usb_acpi_set_power_state(hcd->self.root_hub,
						wIndex, false);
1225
			spin_lock_irqsave(&xhci->lock, flags);
1226
			break;
Sarah Sharp's avatar
Sarah Sharp committed
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
		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;
1252
	u32 mask;
Sarah Sharp's avatar
Sarah Sharp committed
1253 1254
	int i, retval;
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
1255
	int max_ports;
1256
	__le32 __iomem **port_array;
1257
	struct xhci_bus_state *bus_state;
1258
	bool reset_change = false;
Sarah Sharp's avatar
Sarah Sharp committed
1259

1260
	max_ports = xhci_get_ports(hcd, &port_array);
1261
	bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp's avatar
Sarah Sharp committed
1262 1263

	/* Initial status is no changes */
1264
	retval = (max_ports + 8) / 8;
1265
	memset(buf, 0, retval);
1266 1267 1268 1269 1270 1271

	/*
	 * Inform the usbcore about resume-in-progress by returning
	 * a non-zero value even if there are no status changes.
	 */
	status = bus_state->resuming_ports;
Sarah Sharp's avatar
Sarah Sharp committed
1272

1273
	mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC | PORT_CEC;
1274

Sarah Sharp's avatar
Sarah Sharp committed
1275 1276
	spin_lock_irqsave(&xhci->lock, flags);
	/* For each port, did anything change?  If so, set that bit in buf. */
1277
	for (i = 0; i < max_ports; i++) {
1278
		temp = readl(port_array[i]);
1279 1280 1281 1282
		if (temp == 0xffffffff) {
			retval = -ENODEV;
			break;
		}
1283
		if ((temp & mask) != 0 ||
1284 1285 1286
			(bus_state->port_c_suspend & 1 << i) ||
			(bus_state->resume_done[i] && time_after_eq(
			    jiffies, bus_state->resume_done[i]))) {
1287
			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
Sarah Sharp's avatar
Sarah Sharp committed
1288 1289
			status = 1;
		}
1290 1291 1292 1293 1294 1295
		if ((temp & PORT_RC))
			reset_change = true;
	}
	if (!status && !reset_change) {
		xhci_dbg(xhci, "%s: stopping port polling.\n", __func__);
		clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
Sarah Sharp's avatar
Sarah Sharp committed
1296 1297 1298 1299
	}
	spin_unlock_irqrestore(&xhci->lock, flags);
	return status ? retval : 0;
}
1300 1301 1302 1303 1304 1305

#ifdef CONFIG_PM

int xhci_bus_suspend(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
1306
	int max_ports, port_index;
1307
	__le32 __iomem **port_array;
1308
	struct xhci_bus_state *bus_state;
1309
	unsigned long flags;
1310 1311
	u32 portsc_buf[USB_MAXCHILDREN];
	bool wake_enabled;
1312

1313
	max_ports = xhci_get_ports(hcd, &port_array);
1314
	bus_state = &xhci->bus_state[hcd_index(hcd)];
1315
	wake_enabled = hcd->self.root_hub->do_remote_wakeup;
1316 1317 1318

	spin_lock_irqsave(&xhci->lock, flags);

1319
	if (wake_enabled) {
1320 1321
		if (bus_state->resuming_ports ||	/* USB2 */
		    bus_state->port_remote_wakeup) {	/* USB3 */
1322
			spin_unlock_irqrestore(&xhci->lock, flags);
1323
			xhci_dbg(xhci, "suspend failed because a port is resuming\n");
1324
			return -EBUSY;
1325 1326
		}
	}
1327 1328 1329 1330
	/*
	 * Prepare ports for suspend, but don't write anything before all ports
	 * are checked and we know bus suspend can proceed
	 */
1331
	bus_state->bus_suspended = 0;
1332
	port_index = max_ports;
1333
	while (port_index--) {
1334 1335
		u32 t1, t2;

1336
		t1 = readl(port_array[port_index]);
1337
		t2 = xhci_port_state_to_neutral(t1);
1338
		portsc_buf[port_index] = 0;
1339

1340
		/* Bail out if a USB3 port has a new device in link training */
1341 1342
		if ((hcd->speed >= HCD_USB3) &&
		    (t1 & PORT_PLS_MASK) == XDEV_POLLING) {
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
			bus_state->bus_suspended = 0;
			spin_unlock_irqrestore(&xhci->lock, flags);
			xhci_dbg(xhci, "Bus suspend bailout, port in polling\n");
			return -EBUSY;
		}

		/* suspend ports in U0, or bail out for new connect changes */
		if ((t1 & PORT_PE) && (t1 & PORT_PLS_MASK) == XDEV_U0) {
			if ((t1 & PORT_CSC) && wake_enabled) {
				bus_state->bus_suspended = 0;
1353
				spin_unlock_irqrestore(&xhci->lock, flags);
1354 1355
				xhci_dbg(xhci, "Bus suspend bailout, port connect change\n");
				return -EBUSY;
1356
			}
1357
			xhci_dbg(xhci, "port %d not suspended\n", port_index);
1358 1359
			t2 &= ~PORT_PLS_MASK;
			t2 |= PORT_LINK_STROBE | XDEV_U3;
1360
			set_bit(port_index, &bus_state->bus_suspended);
1361
		}
1362
		/* USB core sets remote wake mask for USB 3.0 hubs,
1363
		 * including the USB 3.0 roothub, but only if CONFIG_PM
1364 1365
		 * is enabled, so also enable remote wake here.
		 */
1366
		if (wake_enabled) {
1367 1368 1369 1370 1371 1372 1373
			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;
			}
1374 1375
			if ((xhci->quirks & XHCI_U2_DISABLE_WAKE) && (hcd->speed < HCD_USB3))
				t2 &= ~PORT_WAKE_BITS;
1376 1377 1378 1379 1380
		} else
			t2 &= ~PORT_WAKE_BITS;

		t1 = xhci_port_state_to_neutral(t1);
		if (t1 != t2)
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
			portsc_buf[port_index] = t2;
	}

	/* write port settings, stopping and suspending ports if needed */
	port_index = max_ports;
	while (port_index--) {
		if (!portsc_buf[port_index])
			continue;
		if (test_bit(port_index, &bus_state->bus_suspended)) {
			int slot_id;

			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
							    port_index + 1);
			if (slot_id) {
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_stop_device(xhci, slot_id, 1);
				spin_lock_irqsave(&xhci->lock, flags);
			}
		}
		writel(portsc_buf[port_index], port_array[port_index]);
1401 1402
	}
	hcd->state = HC_STATE_SUSPENDED;
1403
	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
1404 1405 1406 1407
	spin_unlock_irqrestore(&xhci->lock, flags);
	return 0;
}

1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
/*
 * Workaround for missing Cold Attach Status (CAS) if device re-plugged in S3.
 * warm reset a USB3 device stuck in polling or compliance mode after resume.
 * See Intel 100/c230 series PCH specification update Doc #332692-006 Errata #8
 */
static bool xhci_port_missing_cas_quirk(int port_index,
					     __le32 __iomem **port_array)
{
	u32 portsc;

	portsc = readl(port_array[port_index]);

	/* if any of these are set we are not stuck */
	if (portsc & (PORT_CONNECT | PORT_CAS))
		return false;

	if (((portsc & PORT_PLS_MASK) != XDEV_POLLING) &&
	    ((portsc & PORT_PLS_MASK) != XDEV_COMP_MODE))
		return false;

	/* clear wakeup/change bits, and do a warm port reset */
	portsc &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
	portsc |= PORT_WR;
	writel(portsc, port_array[port_index]);
	/* flush write */
	readl(port_array[port_index]);
	return true;
}

1437 1438 1439
int xhci_bus_resume(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
1440
	int max_ports, port_index;
1441
	__le32 __iomem **port_array;
1442
	struct xhci_bus_state *bus_state;
1443 1444
	u32 temp;
	unsigned long flags;
1445 1446 1447 1448
	unsigned long port_was_suspended = 0;
	bool need_usb2_u3_exit = false;
	int slot_id;
	int sret;
1449

1450
	max_ports = xhci_get_ports(hcd, &port_array);
1451
	bus_state = &xhci->bus_state[hcd_index(hcd)];
1452

1453
	if (time_before(jiffies, bus_state->next_statechange))
1454 1455 1456 1457 1458 1459 1460 1461 1462
		msleep(5);

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

	/* delay the irqs */
1463
	temp = readl(&xhci->op_regs->command);
1464
	temp &= ~CMD_EIE;
1465
	writel(temp, &xhci->op_regs->command);
1466

1467 1468
	port_index = max_ports;
	while (port_index--) {
1469 1470 1471 1472
		/* Check whether need resume ports. If needed
		   resume port and disable remote wakeup */
		u32 temp;

1473
		temp = readl(port_array[port_index]);
1474 1475 1476 1477 1478 1479 1480 1481

		/* warm reset CAS limited ports stuck in polling/compliance */
		if ((xhci->quirks & XHCI_MISSING_CAS) &&
		    (hcd->speed >= HCD_USB3) &&
		    xhci_port_missing_cas_quirk(port_index, port_array)) {
			xhci_dbg(xhci, "reset stuck port %d\n", port_index);
			continue;
		}
1482
		if (DEV_SUPERSPEED_ANY(temp))
1483 1484 1485
			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
		else
			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
1486
		if (test_bit(port_index, &bus_state->bus_suspended) &&
1487
		    (temp & PORT_PLS_MASK)) {
1488
			set_bit(port_index, &port_was_suspended);
1489
			if (!DEV_SUPERSPEED_ANY(temp)) {
Andiry Xu's avatar
Andiry Xu committed
1490 1491
				xhci_set_link_state(xhci, port_array,
						port_index, XDEV_RESUME);
1492
				need_usb2_u3_exit = true;
1493 1494
			}
		} else
1495
			writel(temp, port_array[port_index]);
1496 1497
	}

1498 1499
	if (need_usb2_u3_exit) {
		spin_unlock_irqrestore(&xhci->lock, flags);
1500
		msleep(USB_RESUME_TIMEOUT);
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
		spin_lock_irqsave(&xhci->lock, flags);
	}

	port_index = max_ports;
	while (port_index--) {
		if (!(port_was_suspended & BIT(port_index)))
			continue;
		/* Clear PLC to poll it later after XDEV_U0 */
		xhci_test_and_clear_bit(xhci, port_array, port_index, PORT_PLC);
		xhci_set_link_state(xhci, port_array, port_index, XDEV_U0);
	}

	port_index = max_ports;
	while (port_index--) {
		if (!(port_was_suspended & BIT(port_index)))
			continue;
		/* Poll and Clear PLC */
		sret = xhci_handshake(port_array[port_index], PORT_PLC,
				      PORT_PLC, 10 * 1000);
		if (sret)
			xhci_warn(xhci, "port %d resume PLC timeout\n",
				  port_index);
		xhci_test_and_clear_bit(xhci, port_array, port_index, PORT_PLC);
		slot_id = xhci_find_slot_id_by_port(hcd, xhci, port_index + 1);
		if (slot_id)
			xhci_ring_device(xhci, slot_id);
	}

1529
	(void) readl(&xhci->op_regs->command);
1530

1531
	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
1532
	/* re-enable irqs */
1533
	temp = readl(&xhci->op_regs->command);
1534
	temp |= CMD_EIE;
1535
	writel(temp, &xhci->op_regs->command);
1536
	temp = readl(&xhci->op_regs->command);
1537 1538 1539 1540 1541

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

1542
#endif	/* CONFIG_PM */