xhci-hub.c 22.4 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
static void xhci_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
S
Sarah Sharp 已提交
32 33 34 35 36
		struct usb_hub_descriptor *desc)
{
	int ports;
	u16 temp;

37 38 39 40 41 42 43 44
	if (hcd->speed == HCD_USB3)
		ports = xhci->num_usb3_ports;
	else
		ports = xhci->num_usb2_ports;

	/* FIXME: return a USB 3.0 hub descriptor if this request was for the
	 * USB3 roothub.
	 */
S
Sarah Sharp 已提交
45 46 47 48 49 50 51 52 53 54

	/* USB 3.0 hubs have a different descriptor, but we fake this for now */
	desc->bDescriptorType = 0x29;
	desc->bPwrOn2PwrGood = 10;	/* xhci section 5.4.9 says 20ms max */
	desc->bHubContrCurrent = 0;

	desc->bNbrPorts = ports;
	temp = 1 + (ports / 8);
	desc->bDescLength = 7 + 2 * temp;

J
John Youn 已提交
55 56
	memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
	memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
S
Sarah Sharp 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

	/* 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 */
	desc->wHubCharacteristics = (__force __u16) cpu_to_le16(temp);
}

static unsigned int xhci_port_speed(unsigned int port_status)
{
	if (DEV_LOWSPEED(port_status))
77
		return USB_PORT_STAT_LOW_SPEED;
S
Sarah Sharp 已提交
78
	if (DEV_HIGHSPEED(port_status))
79
		return USB_PORT_STAT_HIGH_SPEED;
S
Sarah Sharp 已提交
80
	if (DEV_SUPERSPEED(port_status))
81
		return USB_PORT_STAT_SUPER_SPEED;
S
Sarah Sharp 已提交
82 83 84
	/*
	 * 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
85
	 * USB_PORT_STAT_*_SPEED is used).
S
Sarah Sharp 已提交
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
	 */
	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.
 */
136
u32 xhci_port_state_to_neutral(u32 state)
S
Sarah Sharp 已提交
137 138 139 140 141
{
	/* Save read-only status and port state */
	return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
}

142 143
/*
 * find slot id based on port number.
144
 * @port: The one-based port number from one of the two split roothubs.
145
 */
146 147
int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		u16 port)
148 149 150
{
	int slot_id;
	int i;
151
	enum usb_device_speed speed;
152 153 154 155 156

	slot_id = 0;
	for (i = 0; i < MAX_HC_SLOTS; i++) {
		if (!xhci->devs[i])
			continue;
157 158 159
		speed = xhci->devs[i]->udev->speed;
		if (((speed == USB_SPEED_SUPER) == (hcd->speed == HCD_USB3))
				&& xhci->devs[i]->port == port) {
160 161 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 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
			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.
 */
228
void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
229 230 231 232 233 234 235 236 237 238 239
{
	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;
}

240 241
static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
		u16 wIndex, u32 __iomem *addr, u32 port_status)
242
{
243
	/* Don't allow the USB core to disable SuperSpeed ports. */
244
	if (hcd->speed == HCD_USB3) {
245 246 247 248 249
		xhci_dbg(xhci, "Ignoring request to disable "
				"SuperSpeed port.\n");
		return;
	}

250 251 252 253 254 255 256
	/* 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);
}

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
		u16 wIndex, u32 __iomem *addr, u32 port_status)
{
	char *port_change_bit;
	u32 status;

	switch (wValue) {
	case USB_PORT_FEAT_C_RESET:
		status = PORT_RC;
		port_change_bit = "reset";
		break;
	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;
276 277 278 279
	case USB_PORT_FEAT_C_ENABLE:
		status = PORT_PEC;
		port_change_bit = "enable/disable";
		break;
280 281 282 283
	case USB_PORT_FEAT_C_SUSPEND:
		status = PORT_PLC;
		port_change_bit = "suspend/resume";
		break;
284 285 286 287 288 289 290 291 292 293 294
	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 已提交
295 296 297 298 299 300
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;
301
	u32 temp, temp1, status;
S
Sarah Sharp 已提交
302
	int retval = 0;
303
	u32 __iomem **port_array;
304
	int slot_id;
305
	struct xhci_bus_state *bus_state;
S
Sarah Sharp 已提交
306

307 308 309 310 311 312
	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;
313
	}
314
	bus_state = &xhci->bus_state[hcd_index(hcd)];
S
Sarah Sharp 已提交
315 316 317 318 319 320 321 322

	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:
323 324
		xhci_hub_descriptor(hcd, xhci,
				(struct usb_hub_descriptor *) buf);
S
Sarah Sharp 已提交
325 326 327 328 329 330
		break;
	case GetPortStatus:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
		status = 0;
331
		temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
332 333 334 335
		xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n", wIndex, temp);

		/* wPortChange bits */
		if (temp & PORT_CSC)
336
			status |= USB_PORT_STAT_C_CONNECTION << 16;
S
Sarah Sharp 已提交
337
		if (temp & PORT_PEC)
338
			status |= USB_PORT_STAT_C_ENABLE << 16;
S
Sarah Sharp 已提交
339
		if ((temp & PORT_OCC))
340
			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
S
Sarah Sharp 已提交
341
		/*
342
		 * FIXME ignoring reset and USB 2.1/3.0 specific
S
Sarah Sharp 已提交
343 344
		 * changes
		 */
345 346 347
		if ((temp & PORT_PLS_MASK) == XDEV_U3
			&& (temp & PORT_POWER))
			status |= 1 << USB_PORT_FEAT_SUSPEND;
348 349 350 351
		if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
			if ((temp & PORT_RESET) || !(temp & PORT_PE))
				goto error;
			if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
352
						bus_state->resume_done[wIndex])) {
353 354
				xhci_dbg(xhci, "Resume USB2 port %d\n",
					wIndex + 1);
355
				bus_state->resume_done[wIndex] = 0;
356 357 358
				temp1 = xhci_port_state_to_neutral(temp);
				temp1 &= ~PORT_PLS_MASK;
				temp1 |= PORT_LINK_STROBE | XDEV_U0;
359
				xhci_writel(xhci, temp1, port_array[wIndex]);
360 361 362

				xhci_dbg(xhci, "set port %d resume\n",
					wIndex + 1);
363
				slot_id = xhci_find_slot_id_by_port(hcd, xhci,
364 365 366 367 368 369
								 wIndex + 1);
				if (!slot_id) {
					xhci_dbg(xhci, "slot_id is zero\n");
					goto error;
				}
				xhci_ring_device(xhci, slot_id);
370 371
				bus_state->port_c_suspend |= 1 << wIndex;
				bus_state->suspended_ports &= ~(1 << wIndex);
372 373
			}
		}
374 375
		if ((temp & PORT_PLS_MASK) == XDEV_U0
			&& (temp & PORT_POWER)
376 377 378
			&& (bus_state->suspended_ports & (1 << wIndex))) {
			bus_state->suspended_ports &= ~(1 << wIndex);
			bus_state->port_c_suspend |= 1 << wIndex;
379
		}
S
Sarah Sharp 已提交
380
		if (temp & PORT_CONNECT) {
381
			status |= USB_PORT_STAT_CONNECTION;
S
Sarah Sharp 已提交
382 383 384
			status |= xhci_port_speed(temp);
		}
		if (temp & PORT_PE)
385
			status |= USB_PORT_STAT_ENABLE;
S
Sarah Sharp 已提交
386
		if (temp & PORT_OC)
387
			status |= USB_PORT_STAT_OVERCURRENT;
S
Sarah Sharp 已提交
388
		if (temp & PORT_RESET)
389
			status |= USB_PORT_STAT_RESET;
S
Sarah Sharp 已提交
390
		if (temp & PORT_POWER)
391
			status |= USB_PORT_STAT_POWER;
392
		if (bus_state->port_c_suspend & (1 << wIndex))
393
			status |= 1 << USB_PORT_FEAT_C_SUSPEND;
S
Sarah Sharp 已提交
394 395 396 397 398 399 400 401
		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--;
402
		temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
403 404
		temp = xhci_port_state_to_neutral(temp);
		switch (wValue) {
405
		case USB_PORT_FEAT_SUSPEND:
406
			temp = xhci_readl(xhci, port_array[wIndex]);
407 408 409 410 411 412 413 414 415 416 417
			/* 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;
			}

418 419
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
420 421 422 423 424 425 426 427 428 429 430 431
			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;
432
			xhci_writel(xhci, temp, port_array[wIndex]);
433 434 435 436 437

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

438
			temp = xhci_readl(xhci, port_array[wIndex]);
439
			bus_state->suspended_ports |= 1 << wIndex;
440
			break;
S
Sarah Sharp 已提交
441 442 443 444 445 446 447
		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.
			 */
448 449
			xhci_writel(xhci, temp | PORT_POWER,
					port_array[wIndex]);
S
Sarah Sharp 已提交
450

451
			temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
452 453 454 455
			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);
456
			xhci_writel(xhci, temp, port_array[wIndex]);
S
Sarah Sharp 已提交
457

458
			temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
459 460 461 462 463
			xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
			break;
		default:
			goto error;
		}
464 465
		/* unblock any posted writes */
		temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
466 467 468 469 470
		break;
	case ClearPortFeature:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
471
		temp = xhci_readl(xhci, port_array[wIndex]);
S
Sarah Sharp 已提交
472 473
		temp = xhci_port_state_to_neutral(temp);
		switch (wValue) {
474
		case USB_PORT_FEAT_SUSPEND:
475
			temp = xhci_readl(xhci, port_array[wIndex]);
476 477 478 479 480 481 482 483 484 485 486
			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;
487 488 489
					xhci_writel(xhci, temp,
							port_array[wIndex]);
					xhci_readl(xhci, port_array[wIndex]);
490 491 492 493
				} else {
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_RESUME;
494 495
					xhci_writel(xhci, temp,
							port_array[wIndex]);
496 497 498 499 500 501

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

502 503
					temp = xhci_readl(xhci,
							port_array[wIndex]);
504 505 506
					temp = xhci_port_state_to_neutral(temp);
					temp &= ~PORT_PLS_MASK;
					temp |= PORT_LINK_STROBE | XDEV_U0;
507 508
					xhci_writel(xhci, temp,
							port_array[wIndex]);
509
				}
510
				bus_state->port_c_suspend |= 1 << wIndex;
511 512
			}

513 514
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
					wIndex + 1);
515 516 517 518 519 520 521
			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:
522
			bus_state->port_c_suspend &= ~(1 << wIndex);
S
Sarah Sharp 已提交
523 524 525
		case USB_PORT_FEAT_C_RESET:
		case USB_PORT_FEAT_C_CONNECTION:
		case USB_PORT_FEAT_C_OVER_CURRENT:
526
		case USB_PORT_FEAT_C_ENABLE:
527
			xhci_clear_port_change_bit(xhci, wValue, wIndex,
528
					port_array[wIndex], temp);
S
Sarah Sharp 已提交
529
			break;
530
		case USB_PORT_FEAT_ENABLE:
531
			xhci_disable_port(hcd, xhci, wIndex,
532
					port_array[wIndex], temp);
533
			break;
S
Sarah Sharp 已提交
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
		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;
559
	u32 mask;
S
Sarah Sharp 已提交
560 561 562
	int i, retval;
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
	int ports;
563
	u32 __iomem **port_array;
564
	struct xhci_bus_state *bus_state;
S
Sarah Sharp 已提交
565

566 567 568 569 570 571
	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;
572
	}
573
	bus_state = &xhci->bus_state[hcd_index(hcd)];
S
Sarah Sharp 已提交
574 575

	/* Initial status is no changes */
576 577
	retval = (ports + 8) / 8;
	memset(buf, 0, retval);
S
Sarah Sharp 已提交
578 579
	status = 0;

580 581
	mask = PORT_CSC | PORT_PEC | PORT_OCC;

S
Sarah Sharp 已提交
582 583 584
	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++) {
585
		temp = xhci_readl(xhci, port_array[i]);
586
		if ((temp & mask) != 0 ||
587 588 589
			(bus_state->port_c_suspend & 1 << i) ||
			(bus_state->resume_done[i] && time_after_eq(
			    jiffies, bus_state->resume_done[i]))) {
590
			buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
S
Sarah Sharp 已提交
591 592 593 594 595 596
			status = 1;
		}
	}
	spin_unlock_irqrestore(&xhci->lock, flags);
	return status ? retval : 0;
}
597 598 599 600 601 602

#ifdef CONFIG_PM

int xhci_bus_suspend(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
603
	int max_ports, port_index;
604
	u32 __iomem **port_array;
605
	struct xhci_bus_state *bus_state;
606 607
	unsigned long flags;

608 609 610 611 612 613 614 615
	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");
616
	}
617
	bus_state = &xhci->bus_state[hcd_index(hcd)];
618 619 620 621

	spin_lock_irqsave(&xhci->lock, flags);

	if (hcd->self.root_hub->do_remote_wakeup) {
622 623
		port_index = max_ports;
		while (port_index--) {
624
			if (bus_state->resume_done[port_index] != 0) {
625 626 627
				spin_unlock_irqrestore(&xhci->lock, flags);
				xhci_dbg(xhci, "suspend failed because "
						"port %d is resuming\n",
628
						port_index + 1);
629 630 631 632 633
				return -EBUSY;
			}
		}
	}

634
	port_index = max_ports;
635
	bus_state->bus_suspended = 0;
636
	while (port_index--) {
637 638 639 640
		/* suspend the port if the port is not suspended */
		u32 t1, t2;
		int slot_id;

641
		t1 = xhci_readl(xhci, port_array[port_index]);
642 643 644
		t2 = xhci_port_state_to_neutral(t1);

		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
645
			xhci_dbg(xhci, "port %d not suspended\n", port_index);
646
			slot_id = xhci_find_slot_id_by_port(hcd, xhci,
647
					port_index + 1);
648 649 650 651 652 653 654
			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;
655
			set_bit(port_index, &bus_state->bus_suspended);
656 657 658 659 660 661 662 663 664 665 666 667 668 669
		}
		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)
670
			xhci_writel(xhci, t2, port_array[port_index]);
671 672 673 674 675 676

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

677 678 679 680
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
681 682 683 684 685 686
			tmp = xhci_readl(xhci, addr);
			tmp |= PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}
	hcd->state = HC_STATE_SUSPENDED;
687
	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
688 689 690 691 692 693 694
	spin_unlock_irqrestore(&xhci->lock, flags);
	return 0;
}

int xhci_bus_resume(struct usb_hcd *hcd)
{
	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
695
	int max_ports, port_index;
696
	u32 __iomem **port_array;
697
	struct xhci_bus_state *bus_state;
698 699 700
	u32 temp;
	unsigned long flags;

701 702 703 704 705 706 707 708
	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");
709
	}
710
	bus_state = &xhci->bus_state[hcd_index(hcd)];
711

712
	if (time_before(jiffies, bus_state->next_statechange))
713 714 715 716 717 718 719 720 721 722 723 724 725
		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);

726 727
	port_index = max_ports;
	while (port_index--) {
728 729 730 731 732
		/* Check whether need resume ports. If needed
		   resume port and disable remote wakeup */
		u32 temp;
		int slot_id;

733
		temp = xhci_readl(xhci, port_array[port_index]);
734 735 736 737
		if (DEV_SUPERSPEED(temp))
			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
		else
			temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
738
		if (test_bit(port_index, &bus_state->bus_suspended) &&
739 740 741 742 743
		    (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;
744
				xhci_writel(xhci, temp, port_array[port_index]);
745 746 747 748
			} else {
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_RESUME;
749
				xhci_writel(xhci, temp, port_array[port_index]);
750 751 752 753 754

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

755
				temp = xhci_readl(xhci, port_array[port_index]);
756 757 758
				temp = xhci_port_state_to_neutral(temp);
				temp &= ~PORT_PLS_MASK;
				temp |= PORT_LINK_STROBE | XDEV_U0;
759
				xhci_writel(xhci, temp, port_array[port_index]);
760
			}
761 762
			slot_id = xhci_find_slot_id_by_port(hcd,
					xhci, port_index + 1);
763 764 765
			if (slot_id)
				xhci_ring_device(xhci, slot_id);
		} else
766
			xhci_writel(xhci, temp, port_array[port_index]);
767 768 769 770 771 772

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

773 774 775 776
			/* Add one to the port status register address to get
			 * the port power control register address.
			 */
			addr = port_array[port_index] + 1;
777 778 779 780 781 782 783 784
			tmp = xhci_readl(xhci, addr);
			tmp &= ~PORT_RWE;
			xhci_writel(xhci, tmp, addr);
		}
	}

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

785
	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
786 787 788 789 790 791 792 793 794 795
	/* 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;
}

796
#endif	/* CONFIG_PM */