Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 74c68741 authored by Sarah Sharp's avatar Sarah Sharp Committed by Greg Kroah-Hartman
Browse files

USB: xhci: Support xHCI host controllers and USB 3.0 devices. 

This is the first of many patches to add support for USB 3.0 devices and
the hardware that implements the eXtensible Host Controller Interface
(xHCI) 0.95 specification.  This specification is not yet publicly
available, but companies can receive a copy by becoming an xHCI
Contributor (see http://www.intel.com/technology/usb/xhcispec.htm

).

No xHCI hardware has made it onto the market yet, but these patches have
been tested under the Fresco Logic host controller prototype.

This patch adds the xHCI register sets, which are grouped into five sets:
 - Generic PCI registers
 - Host controller "capabilities" registers (cap_regs) short
 - Host controller "operational" registers (op_regs)
 - Host controller "runtime" registers (run_regs)
 - Host controller "doorbell" registers

These some of these registers may be virtualized if the Linux driver is
running under a VM.  Virtualization has not been tested for this patch.

Signed-off-by: default avatarSarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent a92b63e7

drivers/usb/host/xhci-dbg.c

0 → 100644
+229 −0
Original line number Diff line number Diff line 
/*

 * 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 "xhci.h"



#define XHCI_INIT_VALUE 0x0



/* Add verbose debugging later, just print everything for now */



void xhci_dbg_regs(struct xhci_hcd *xhci)

{

	u32 temp;



	xhci_dbg(xhci, "// xHCI capability registers at 0x%x:\n",

			(unsigned int) xhci->cap_regs);

	temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);

	xhci_dbg(xhci, "// @%x = 0x%x (CAPLENGTH AND HCIVERSION)\n",

			(unsigned int) &xhci->cap_regs->hc_capbase,

			(unsigned int) temp);

	xhci_dbg(xhci, "//   CAPLENGTH: 0x%x\n",

			(unsigned int) HC_LENGTH(temp));

#if 0

	xhci_dbg(xhci, "//   HCIVERSION: 0x%x\n",

			(unsigned int) HC_VERSION(temp));

#endif



	xhci_dbg(xhci, "// xHCI operational registers at 0x%x:\n",

			(unsigned int) xhci->op_regs);



	temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);

	xhci_dbg(xhci, "// @%x = 0x%x RTSOFF\n",

			(unsigned int) &xhci->cap_regs->run_regs_off,

			(unsigned int) temp & RTSOFF_MASK);

	xhci_dbg(xhci, "// xHCI runtime registers at 0x%x:\n",

			(unsigned int) xhci->run_regs);



	temp = xhci_readl(xhci, &xhci->cap_regs->db_off);

	xhci_dbg(xhci, "// @%x = 0x%x DBOFF\n",

			(unsigned int) &xhci->cap_regs->db_off, temp);

}



void xhci_print_cap_regs(struct xhci_hcd *xhci)

{

	u32 temp;



	xhci_dbg(xhci, "xHCI capability registers at 0x%x:\n",

			(unsigned int) xhci->cap_regs);



	temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);

	xhci_dbg(xhci, "CAPLENGTH AND HCIVERSION 0x%x:\n",

			(unsigned int) temp);

	xhci_dbg(xhci, "CAPLENGTH: 0x%x\n",

			(unsigned int) HC_LENGTH(temp));

	xhci_dbg(xhci, "HCIVERSION: 0x%x\n",

			(unsigned int) HC_VERSION(temp));



	temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);

	xhci_dbg(xhci, "HCSPARAMS 1: 0x%x\n",

			(unsigned int) temp);

	xhci_dbg(xhci, "  Max device slots: %u\n",

			(unsigned int) HCS_MAX_SLOTS(temp));

	xhci_dbg(xhci, "  Max interrupters: %u\n",

			(unsigned int) HCS_MAX_INTRS(temp));

	xhci_dbg(xhci, "  Max ports: %u\n",

			(unsigned int) HCS_MAX_PORTS(temp));



	temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);

	xhci_dbg(xhci, "HCSPARAMS 2: 0x%x\n",

			(unsigned int) temp);

	xhci_dbg(xhci, "  Isoc scheduling threshold: %u\n",

			(unsigned int) HCS_IST(temp));

	xhci_dbg(xhci, "  Maximum allowed segments in event ring: %u\n",

			(unsigned int) HCS_ERST_MAX(temp));



	temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);

	xhci_dbg(xhci, "HCSPARAMS 3 0x%x:\n",

			(unsigned int) temp);

	xhci_dbg(xhci, "  Worst case U1 device exit latency: %u\n",

			(unsigned int) HCS_U1_LATENCY(temp));

	xhci_dbg(xhci, "  Worst case U2 device exit latency: %u\n",

			(unsigned int) HCS_U2_LATENCY(temp));



	temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);

	xhci_dbg(xhci, "HCC PARAMS 0x%x:\n", (unsigned int) temp);

	xhci_dbg(xhci, "  HC generates %s bit addresses\n",

			HCC_64BIT_ADDR(temp) ? "64" : "32");

	/* FIXME */

	xhci_dbg(xhci, "  FIXME: more HCCPARAMS debugging\n");



	temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);

	xhci_dbg(xhci, "RTSOFF 0x%x:\n", temp & RTSOFF_MASK);

}



void xhci_print_command_reg(struct xhci_hcd *xhci)

{

	u32 temp;



	temp = xhci_readl(xhci, &xhci->op_regs->command);

	xhci_dbg(xhci, "USBCMD 0x%x:\n", temp);

	xhci_dbg(xhci, "  HC is %s\n",

			(temp & CMD_RUN) ? "running" : "being stopped");

	xhci_dbg(xhci, "  HC has %sfinished hard reset\n",

			(temp & CMD_RESET) ? "not " : "");

	xhci_dbg(xhci, "  Event Interrupts %s\n",

			(temp & CMD_EIE) ? "enabled " : "disabled");

	xhci_dbg(xhci, "  Host System Error Interrupts %s\n",

			(temp & CMD_EIE) ? "enabled " : "disabled");

	xhci_dbg(xhci, "  HC has %sfinished light reset\n",

			(temp & CMD_LRESET) ? "not " : "");

}



void xhci_print_status(struct xhci_hcd *xhci)

{

	u32 temp;



	temp = xhci_readl(xhci, &xhci->op_regs->status);

	xhci_dbg(xhci, "USBSTS 0x%x:\n", temp);

	xhci_dbg(xhci, "  Event ring is %sempty\n",

			(temp & STS_EINT) ? "not " : "");

	xhci_dbg(xhci, "  %sHost System Error\n",

			(temp & STS_FATAL) ? "WARNING: " : "No ");

	xhci_dbg(xhci, "  HC is %s\n",

			(temp & STS_HALT) ? "halted" : "running");

}



void xhci_print_op_regs(struct xhci_hcd *xhci)

{

	xhci_dbg(xhci, "xHCI operational registers at 0x%x:\n",

			(unsigned int) xhci->op_regs);

	xhci_print_command_reg(xhci);

	xhci_print_status(xhci);

}



void xhci_print_ir_set(struct xhci_hcd *xhci, struct intr_reg *ir_set, int set_num)

{

	void *addr;

	u32 temp;



	addr = &ir_set->irq_pending;

	temp = xhci_readl(xhci, addr);

	if (temp == XHCI_INIT_VALUE)

		return;



	xhci_dbg(xhci, "  0x%x: ir_set[%i]\n", (unsigned int) ir_set, set_num);



	xhci_dbg(xhci, "  0x%x: ir_set.pending = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->irq_control;

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.control = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->erst_size;

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.erst_size = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->rsvd;

	temp = xhci_readl(xhci, addr);

	if (temp != XHCI_INIT_VALUE)

		xhci_dbg(xhci, "  WARN: 0x%x: ir_set.rsvd = 0x%x\n",

				(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->erst_base[0];

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.erst_base[0] = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->erst_base[1];

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.erst_base[1] = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->erst_dequeue[0];

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.erst_dequeue[0] = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);



	addr = &ir_set->erst_dequeue[1];

	temp = xhci_readl(xhci, addr);

	xhci_dbg(xhci, "  0x%x: ir_set.erst_dequeue[1] = 0x%x\n",

			(unsigned int) addr, (unsigned int) temp);

}



void xhci_print_run_regs(struct xhci_hcd *xhci)

{

	u32 temp;

	int i;



	xhci_dbg(xhci, "xHCI runtime registers at 0x%x:\n",

			(unsigned int) xhci->run_regs);

	temp = xhci_readl(xhci, &xhci->run_regs->microframe_index);

	xhci_dbg(xhci, "  0x%x: Microframe index = 0x%x\n",

			(unsigned int) &xhci->run_regs->microframe_index,

			(unsigned int) temp);

	for (i = 0; i < 7; ++i) {

		temp = xhci_readl(xhci, &xhci->run_regs->rsvd[i]);

		if (temp != XHCI_INIT_VALUE)

			xhci_dbg(xhci, "  WARN: 0x%x: Rsvd[%i] = 0x%x\n",

					(unsigned int) &xhci->run_regs->rsvd[i],

					i, (unsigned int) temp);

	}

}



void xhci_print_registers(struct xhci_hcd *xhci)

{

	xhci_print_cap_regs(xhci);

	xhci_print_op_regs(xhci);

}

drivers/usb/host/xhci-ext-caps.h

0 → 100644
+145 −0
Original line number Diff line number Diff line 
/*

 * 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.

 */

/* Up to 16 microframes to halt an HC - one microframe is 125 microsectonds */

#define XHCI_MAX_HALT_USEC	(16*125)

/* HC not running - set to 1 when run/stop bit is cleared. */

#define XHCI_STS_HALT		(1<<0)



/* HCCPARAMS offset from PCI base address */

#define XHCI_HCC_PARAMS_OFFSET	0x10

/* HCCPARAMS contains the first extended capability pointer */

#define XHCI_HCC_EXT_CAPS(p)	(((p)>>16)&0xffff)



/* Command and Status registers offset from the Operational Registers address */

#define XHCI_CMD_OFFSET		0x00

#define XHCI_STS_OFFSET		0x04



#define XHCI_MAX_EXT_CAPS		50



/* Capability Register */

/* bits 7:0 - how long is the Capabilities register */

#define XHCI_HC_LENGTH(p)	(((p)>>00)&0x00ff)



/* Extended capability register fields */

#define XHCI_EXT_CAPS_ID(p)	(((p)>>0)&0xff)

#define XHCI_EXT_CAPS_NEXT(p)	(((p)>>8)&0xff)

#define	XHCI_EXT_CAPS_VAL(p)	((p)>>16)

/* Extended capability IDs - ID 0 reserved */

#define XHCI_EXT_CAPS_LEGACY	1

#define XHCI_EXT_CAPS_PROTOCOL	2

#define XHCI_EXT_CAPS_PM	3

#define XHCI_EXT_CAPS_VIRT	4

#define XHCI_EXT_CAPS_ROUTE	5

/* IDs 6-9 reserved */

#define XHCI_EXT_CAPS_DEBUG	10

/* USB Legacy Support Capability - section 7.1.1 */

#define XHCI_HC_BIOS_OWNED	(1 << 16)

#define XHCI_HC_OS_OWNED	(1 << 24)



/* USB Legacy Support Capability - section 7.1.1 */

/* Add this offset, plus the value of xECP in HCCPARAMS to the base address */

#define XHCI_LEGACY_SUPPORT_OFFSET	(0x00)



/* USB Legacy Support Control and Status Register  - section 7.1.2 */

/* Add this offset, plus the value of xECP in HCCPARAMS to the base address */

#define XHCI_LEGACY_CONTROL_OFFSET	(0x04)

/* bits 1:2, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */

#define	XHCI_LEGACY_DISABLE_SMI		((0x3 << 1) + (0xff << 5) + (0x7 << 17))



/* command register values to disable interrupts and halt the HC */

/* start/stop HC execution - do not write unless HC is halted*/

#define XHCI_CMD_RUN		(1 << 0)

/* Event Interrupt Enable - get irq when EINT bit is set in USBSTS register */

#define XHCI_CMD_EIE		(1 << 2)

/* Host System Error Interrupt Enable - get irq when HSEIE bit set in USBSTS */

#define XHCI_CMD_HSEIE		(1 << 3)

/* Enable Wrap Event - '1' means xHC generates an event when MFINDEX wraps. */

#define XHCI_CMD_EWE		(1 << 10)



#define XHCI_IRQS		(XHCI_CMD_EIE | XHCI_CMD_HSEIE | XHCI_CMD_EWE)



/* true: Controller Not Ready to accept doorbell or op reg writes after reset */

#define XHCI_STS_CNR		(1 << 11)



#include <linux/io.h>



/**

 * Return the next extended capability pointer register.

 *

 * @base	PCI register base address.

 *

 * @ext_offset	Offset of the 32-bit register that contains the extended

 * capabilites pointer.  If searching for the first extended capability, pass

 * in XHCI_HCC_PARAMS_OFFSET.  If searching for the next extended capability,

 * pass in the offset of the current extended capability register.

 *

 * Returns 0 if there is no next extended capability register or returns the register offset

 * from the PCI registers base address.

 */

static inline int xhci_find_next_cap_offset(void __iomem *base, int ext_offset)

{

	u32 next;



	next = readl(base + ext_offset);



	if (ext_offset == XHCI_HCC_PARAMS_OFFSET)

		/* Find the first extended capability */

		next = XHCI_HCC_EXT_CAPS(next);

	else

		/* Find the next extended capability */

		next = XHCI_EXT_CAPS_NEXT(next);

	if (!next)

		return 0;

	/*

	 * Address calculation from offset of extended capabilities

	 * (or HCCPARAMS) register - see section 5.3.6 and section 7.

	 */

	return ext_offset + (next << 2);

}



/**

 * Find the offset of the extended capabilities with capability ID id.

 *

 * @base PCI MMIO registers base address.

 * @ext_offset Offset from base of the first extended capability to look at,

 * 		or the address of HCCPARAMS.

 * @id Extended capability ID to search for.

 *

 * This uses an arbitrary limit of XHCI_MAX_EXT_CAPS extended capabilities

 * to make sure that the list doesn't contain a loop.

 */

static inline int xhci_find_ext_cap_by_id(void __iomem *base, int ext_offset, int id)

{

	u32 val;

	int limit = XHCI_MAX_EXT_CAPS;



	while (ext_offset && limit > 0) {

		val = readl(base + ext_offset);

		if (XHCI_EXT_CAPS_ID(val) == id)

			break;

		ext_offset = xhci_find_next_cap_offset(base, ext_offset);

		limit--;

	}

	if (limit > 0)

		return ext_offset;

	return 0;

}

drivers/usb/host/xhci.h

0 → 100644
+452 −0

File added.

Preview size limit exceeded, changes collapsed.