Commit b0ba9720 authored by Xenia Ragiadakou's avatar Xenia Ragiadakou Committed by Sarah Sharp
Browse files

xhci: replace xhci_readl() with readl() 



Function xhci_readl() is used to read 32bit xHC registers residing in MMIO
address space. It takes as first argument a pointer to the xhci_hcd although
it does not use it. xhci_readl() internally simply calls readl(). This creates
an illusion that xhci_readl() is an xhci specific function that has to be
called in a context where a pointer to xhci_hcd is available.

Remove the unnecessary xhci_readl() wrapper function and replace its calls to
with calls to readl() to make the code more straightforward.

Signed-off-by: default avatarXenia Ragiadakou <burzalodowa@gmail.com>
Signed-off-by: default avatarSarah Sharp <sarah.a.sharp@linux.intel.com>
parent 2a100047

drivers/usb/host/xhci-dbg.c

+18 −18
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ void xhci_dbg_regs(struct xhci_hcd *xhci) 


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

			xhci->cap_regs);

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

	temp = readl(&xhci->cap_regs->hc_capbase);

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

			&xhci->cap_regs->hc_capbase, temp);

	xhci_dbg(xhci, "//   CAPLENGTH: 0x%x\n",
@@ -44,13 +44,13 @@ void xhci_dbg_regs(struct xhci_hcd *xhci) 


	xhci_dbg(xhci, "// xHCI operational registers at %p:\n", xhci->op_regs);



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

	temp = readl(&xhci->cap_regs->run_regs_off);

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

			&xhci->cap_regs->run_regs_off,

			(unsigned int) temp & RTSOFF_MASK);

	xhci_dbg(xhci, "// xHCI runtime registers at %p:\n", xhci->run_regs);



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

	temp = readl(&xhci->cap_regs->db_off);

	xhci_dbg(xhci, "// @%p = 0x%x DBOFF\n", &xhci->cap_regs->db_off, temp);

	xhci_dbg(xhci, "// Doorbell array at %p:\n", xhci->dba);

}
@@ -61,7 +61,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci) 


	xhci_dbg(xhci, "xHCI capability registers at %p:\n", xhci->cap_regs);



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

	temp = readl(&xhci->cap_regs->hc_capbase);

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

			(unsigned int) temp);

	xhci_dbg(xhci, "CAPLENGTH: 0x%x\n",
@@ -69,7 +69,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci) 
	xhci_dbg(xhci, "HCIVERSION: 0x%x\n",

			(unsigned int) HC_VERSION(temp));



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

	temp = readl(&xhci->cap_regs->hcs_params1);

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

			(unsigned int) temp);

	xhci_dbg(xhci, "  Max device slots: %u\n",
@@ -79,7 +79,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci) 
	xhci_dbg(xhci, "  Max ports: %u\n",

			(unsigned int) HCS_MAX_PORTS(temp));



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

	temp = readl(&xhci->cap_regs->hcs_params2);

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

			(unsigned int) temp);

	xhci_dbg(xhci, "  Isoc scheduling threshold: %u\n",
@@ -87,7 +87,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci) 
	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);

	temp = readl(&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",
@@ -95,14 +95,14 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci) 
	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);

	temp = readl(&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);

	temp = readl(&xhci->cap_regs->run_regs_off);

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

}
@@ -110,7 +110,7 @@ static void xhci_print_command_reg(struct xhci_hcd *xhci) 
{

	u32 temp;



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

	temp = readl(&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");
@@ -128,7 +128,7 @@ static void xhci_print_status(struct xhci_hcd *xhci) 
{

	u32 temp;



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

	temp = readl(&xhci->op_regs->status);

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

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

			(temp & STS_EINT) ? "not " : "");
@@ -163,7 +163,7 @@ static void xhci_print_ports(struct xhci_hcd *xhci) 
		for (j = 0; j < NUM_PORT_REGS; ++j) {

			xhci_dbg(xhci, "%p port %s reg = 0x%x\n",

					addr, names[j],

					(unsigned int) xhci_readl(xhci, addr));

					(unsigned int) readl(addr));

			addr++;

		}

	}
@@ -177,7 +177,7 @@ void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num) 
	u64 temp_64;



	addr = &ir_set->irq_pending;

	temp = xhci_readl(xhci, addr);

	temp = readl(addr);

	if (temp == XHCI_INIT_VALUE)

		return;
@@ -187,17 +187,17 @@ void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num) 
			(unsigned int)temp);



	addr = &ir_set->irq_control;

	temp = xhci_readl(xhci, addr);

	temp = readl(addr);

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

			(unsigned int)temp);



	addr = &ir_set->erst_size;

	temp = xhci_readl(xhci, addr);

	temp = readl(addr);

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

			(unsigned int)temp);



	addr = &ir_set->rsvd;

	temp = xhci_readl(xhci, addr);

	temp = readl(addr);

	if (temp != XHCI_INIT_VALUE)

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

				addr, (unsigned int)temp);
@@ -219,12 +219,12 @@ void xhci_print_run_regs(struct xhci_hcd *xhci) 
	int i;



	xhci_dbg(xhci, "xHCI runtime registers at %p:\n", xhci->run_regs);

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

	temp = readl(&xhci->run_regs->microframe_index);

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

			&xhci->run_regs->microframe_index,

			(unsigned int) temp);

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

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

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

		if (temp != XHCI_INIT_VALUE)

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

					&xhci->run_regs->rsvd[i],

drivers/usb/host/xhci-hub.c

+35 −36
Original line number Diff line number Diff line
@@ -94,7 +94,7 @@ static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci, 
	 */

	memset(port_removable, 0, sizeof(port_removable));

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

		portsc = xhci_readl(xhci, xhci->usb2_ports[i]);

		portsc = readl(xhci->usb2_ports[i]);

		/* If a device is removable, PORTSC reports a 0, same as in the

		 * hub descriptor DeviceRemovable bits.

		 */
@@ -148,7 +148,7 @@ static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci, 
	port_removable = 0;

	/* bit 0 is reserved, bit 1 is for port 1, etc. */

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

		portsc = xhci_readl(xhci, xhci->usb3_ports[i]);

		portsc = readl(xhci->usb3_ports[i]);

		if (portsc & PORT_DEV_REMOVE)

			port_removable |= 1 << (i + 1);

	}
@@ -343,7 +343,7 @@ static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci, 


	/* Write 1 to disable the port */

	xhci_writel(xhci, port_status | PORT_PE, addr);

	port_status = xhci_readl(xhci, addr);

	port_status = readl(addr);

	xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",

			wIndex, port_status);

}
@@ -389,7 +389,7 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue, 
	}

	/* Change bits are all write 1 to clear */

	xhci_writel(xhci, port_status | status, addr);

	port_status = xhci_readl(xhci, addr);

	port_status = readl(addr);

	xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",

			port_change_bit, wIndex, port_status);

}
@@ -415,7 +415,7 @@ void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array, 
{

	u32 temp;



	temp = xhci_readl(xhci, port_array[port_id]);

	temp = readl(port_array[port_id]);

	temp = xhci_port_state_to_neutral(temp);

	temp &= ~PORT_PLS_MASK;

	temp |= PORT_LINK_STROBE | link_state;
@@ -427,7 +427,7 @@ static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci, 
{

	u32 temp;



	temp = xhci_readl(xhci, port_array[port_id]);

	temp = readl(port_array[port_id]);

	temp = xhci_port_state_to_neutral(temp);



	if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_CONNECT)
@@ -454,7 +454,7 @@ void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array, 
{

	u32 temp;



	temp = xhci_readl(xhci, port_array[port_id]);

	temp = readl(port_array[port_id]);

	if (temp & port_bit) {

		temp = xhci_port_state_to_neutral(temp);

		temp |= port_bit;
@@ -623,8 +623,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd, 
				}

				xhci_ring_device(xhci, slot_id);

			} else {

				int port_status = xhci_readl(xhci,

						port_array[wIndex]);

				int port_status = readl(port_array[wIndex]);

				xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",

						XHCI_MAX_REXIT_TIMEOUT,

						port_status);
@@ -733,12 +732,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		/* Set the U1 and U2 exit latencies. */

		memcpy(buf, &usb_bos_descriptor,

				USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);

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

		temp = readl(&xhci->cap_regs->hcs_params3);

		buf[12] = HCS_U1_LATENCY(temp);

		put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);



		/* Indicate whether the host has LTM support. */

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

		temp = readl(&xhci->cap_regs->hcc_params);

		if (HCC_LTC(temp))

			buf[8] |= USB_LTM_SUPPORT;
@@ -748,7 +747,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		if (!wIndex || wIndex > max_ports)

			goto error;

		wIndex--;

		temp = xhci_readl(xhci, port_array[wIndex]);

		temp = readl(port_array[wIndex]);

		if (temp == 0xffffffff) {

			retval = -ENODEV;

			break;
@@ -775,7 +774,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		if (!wIndex || wIndex > max_ports)

			goto error;

		wIndex--;

		temp = xhci_readl(xhci, port_array[wIndex]);

		temp = readl(port_array[wIndex]);

		if (temp == 0xffffffff) {

			retval = -ENODEV;

			break;
@@ -784,7 +783,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		/* FIXME: What new port features do we need to support? */

		switch (wValue) {

		case USB_PORT_FEAT_SUSPEND:

			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			if ((temp & PORT_PLS_MASK) != XDEV_U0) {

				/* Resume the port to U0 first */

				xhci_set_link_state(xhci, port_array, wIndex,
@@ -797,7 +796,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			 * a port unless the port reports that it is in the

			 * enabled (PED = ‘1’,PLS < ‘3’) state.

			 */

			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)

				|| (temp & PORT_PLS_MASK) >= XDEV_U3) {

				xhci_warn(xhci, "USB core suspending device "
@@ -822,11 +821,11 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			msleep(10); /* wait device to enter */

			spin_lock_irqsave(&xhci->lock, flags);



			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			bus_state->suspended_ports |= 1 << wIndex;

			break;

		case USB_PORT_FEAT_LINK_STATE:

			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);



			/* Disable port */

			if (link_state == USB_SS_PORT_LS_SS_DISABLED) {
@@ -841,7 +840,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
					PORT_CEC;

				xhci_writel(xhci, temp | PORT_PE,

					port_array[wIndex]);

				temp = xhci_readl(xhci, port_array[wIndex]);

				temp = readl(port_array[wIndex]);

				break;

			}
@@ -850,7 +849,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
				xhci_dbg(xhci, "Enable port %d\n", wIndex);

				xhci_set_link_state(xhci, port_array, wIndex,

						link_state);

				temp = xhci_readl(xhci, port_array[wIndex]);

				temp = readl(port_array[wIndex]);

				break;

			}
@@ -884,7 +883,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			msleep(20); /* wait device to enter */

			spin_lock_irqsave(&xhci->lock, flags);



			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			if (link_state == USB_SS_PORT_LS_U3)

				bus_state->suspended_ports |= 1 << wIndex;

			break;
@@ -898,7 +897,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			xhci_writel(xhci, temp | PORT_POWER,

					port_array[wIndex]);



			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);



			spin_unlock_irqrestore(&xhci->lock, flags);
@@ -913,13 +912,13 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			temp = (temp | PORT_RESET);

			xhci_writel(xhci, temp, port_array[wIndex]);



			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);

			break;

		case USB_PORT_FEAT_REMOTE_WAKE_MASK:

			xhci_set_remote_wake_mask(xhci, port_array,

					wIndex, wake_mask);

			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			xhci_dbg(xhci, "set port remote wake mask, "

					"actual port %d status  = 0x%x\n",

					wIndex, temp);
@@ -928,12 +927,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			temp |= PORT_WR;

			xhci_writel(xhci, temp, port_array[wIndex]);



			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			break;

		case USB_PORT_FEAT_U1_TIMEOUT:

			if (hcd->speed != HCD_USB3)

				goto error;

			temp = xhci_readl(xhci, port_array[wIndex] + PORTPMSC);

			temp = readl(port_array[wIndex] + PORTPMSC);

			temp &= ~PORT_U1_TIMEOUT_MASK;

			temp |= PORT_U1_TIMEOUT(timeout);

			xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
@@ -941,7 +940,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		case USB_PORT_FEAT_U2_TIMEOUT:

			if (hcd->speed != HCD_USB3)

				goto error;

			temp = xhci_readl(xhci, port_array[wIndex] + PORTPMSC);

			temp = readl(port_array[wIndex] + PORTPMSC);

			temp &= ~PORT_U2_TIMEOUT_MASK;

			temp |= PORT_U2_TIMEOUT(timeout);

			xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
@@ -950,13 +949,13 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
			goto error;

		}

		/* unblock any posted writes */

		temp = xhci_readl(xhci, port_array[wIndex]);

		temp = readl(port_array[wIndex]);

		break;

	case ClearPortFeature:

		if (!wIndex || wIndex > max_ports)

			goto error;

		wIndex--;

		temp = xhci_readl(xhci, port_array[wIndex]);

		temp = readl(port_array[wIndex]);

		if (temp == 0xffffffff) {

			retval = -ENODEV;

			break;
@@ -965,7 +964,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 
		temp = xhci_port_state_to_neutral(temp);

		switch (wValue) {

		case USB_PORT_FEAT_SUSPEND:

			temp = xhci_readl(xhci, port_array[wIndex]);

			temp = readl(port_array[wIndex]);

			xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");

			xhci_dbg(xhci, "PORTSC %04x\n", temp);

			if (temp & PORT_RESET)
@@ -1070,7 +1069,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf) 
	spin_lock_irqsave(&xhci->lock, flags);

	/* For each port, did anything change?  If so, set that bit in buf. */

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

		temp = xhci_readl(xhci, port_array[i]);

		temp = readl(port_array[i]);

		if (temp == 0xffffffff) {

			retval = -ENODEV;

			break;
@@ -1124,7 +1123,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd) 
		u32 t1, t2;

		int slot_id;



		t1 = xhci_readl(xhci, port_array[port_index]);

		t1 = readl(port_array[port_index]);

		t2 = xhci_port_state_to_neutral(t1);



		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
@@ -1187,7 +1186,7 @@ int xhci_bus_resume(struct usb_hcd *hcd) 
	}



	/* delay the irqs */

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

	temp = readl(&xhci->op_regs->command);

	temp &= ~CMD_EIE;

	xhci_writel(xhci, temp, &xhci->op_regs->command);
@@ -1198,7 +1197,7 @@ int xhci_bus_resume(struct usb_hcd *hcd) 
		u32 temp;

		int slot_id;



		temp = xhci_readl(xhci, port_array[port_index]);

		temp = readl(port_array[port_index]);

		if (DEV_SUPERSPEED(temp))

			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);

		else
@@ -1238,14 +1237,14 @@ int xhci_bus_resume(struct usb_hcd *hcd) 
			xhci_writel(xhci, temp, port_array[port_index]);

	}



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

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



	bus_state->next_statechange = jiffies + msecs_to_jiffies(5);

	/* re-enable irqs */

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

	temp = readl(&xhci->op_regs->command);

	temp |= CMD_EIE;

	xhci_writel(xhci, temp, &xhci->op_regs->command);

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

	temp = readl(&xhci->op_regs->command);



	spin_unlock_irqrestore(&xhci->lock, flags);

	return 0;

drivers/usb/host/xhci-mem.c

+10 −10
Original line number Diff line number Diff line
@@ -1986,7 +1986,7 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports, 
	}



	/* Port offset and count in the third dword, see section 7.2 */

	temp = xhci_readl(xhci, addr + 2);

	temp = readl(addr + 2);

	port_offset = XHCI_EXT_PORT_OFF(temp);

	port_count = XHCI_EXT_PORT_COUNT(temp);

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
@@ -2069,7 +2069,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags) 
	int cap_count = 0;



	addr = &xhci->cap_regs->hcc_params;

	offset = XHCI_HCC_EXT_CAPS(xhci_readl(xhci, addr));

	offset = XHCI_HCC_EXT_CAPS(readl(addr));

	if (offset == 0) {

		xhci_err(xhci, "No Extended Capability registers, "

				"unable to set up roothub.\n");
@@ -2106,7 +2106,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags) 
	/* count extended protocol capability entries for later caching */

	do {

		u32 cap_id;

		cap_id = xhci_readl(xhci, tmp_addr);

		cap_id = readl(tmp_addr);

		if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)

			cap_count++;

		tmp_offset = XHCI_EXT_CAPS_NEXT(cap_id);
@@ -2120,7 +2120,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags) 
	while (1) {

		u32 cap_id;



		cap_id = xhci_readl(xhci, addr);

		cap_id = readl(addr);

		if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)

			xhci_add_in_port(xhci, num_ports, addr,

					(u8) XHCI_EXT_PORT_MAJOR(cap_id),
@@ -2224,7 +2224,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 


	INIT_LIST_HEAD(&xhci->cancel_cmd_list);



	page_size = xhci_readl(xhci, &xhci->op_regs->page_size);

	page_size = readl(&xhci->op_regs->page_size);

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,

			"Supported page size register = 0x%x", page_size);

	for (i = 0; i < 16; i++) {
@@ -2247,10 +2247,10 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 
	 * Program the Number of Device Slots Enabled field in the CONFIG

	 * register with the max value of slots the HC can handle.

	 */

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

	val = HCS_MAX_SLOTS(readl(&xhci->cap_regs->hcs_params1));

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,

			"// xHC can handle at most %d device slots.", val);

	val2 = xhci_readl(xhci, &xhci->op_regs->config_reg);

	val2 = readl(&xhci->op_regs->config_reg);

	val |= (val2 & ~HCS_SLOTS_MASK);

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,

			"// Setting Max device slots reg = 0x%x.", val);
@@ -2331,7 +2331,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 
	 */

	xhci->cmd_ring_reserved_trbs++;



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

	val = readl(&xhci->cap_regs->db_off);

	val &= DBOFF_MASK;

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,

			"// Doorbell array is located at offset 0x%x"
@@ -2382,7 +2382,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 
	}



	/* set ERST count with the number of entries in the segment table */

	val = xhci_readl(xhci, &xhci->ir_set->erst_size);

	val = readl(&xhci->ir_set->erst_size);

	val &= ERST_SIZE_MASK;

	val |= ERST_NUM_SEGS;

	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
@@ -2431,7 +2431,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 
	 * is necessary for allowing USB 3.0 devices to do remote wakeup from

	 * U3 (device suspend).

	 */

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

	temp = readl(&xhci->op_regs->dev_notification);

	temp &= ~DEV_NOTE_MASK;

	temp |= DEV_NOTE_FWAKE;

	xhci_writel(xhci, temp, &xhci->op_regs->dev_notification);

drivers/usb/host/xhci-ring.c

+6 −6
Original line number Diff line number Diff line
@@ -297,7 +297,7 @@ void xhci_ring_cmd_db(struct xhci_hcd *xhci) 
	xhci_dbg(xhci, "// Ding dong!\n");

	xhci_writel(xhci, DB_VALUE_HOST, &xhci->dba->doorbell[0]);

	/* Flush PCI posted writes */

	xhci_readl(xhci, &xhci->dba->doorbell[0]);

	readl(&xhci->dba->doorbell[0]);

}



static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
@@ -1739,7 +1739,7 @@ static void handle_port_status(struct xhci_hcd *xhci, 
	faked_port_index = find_faked_portnum_from_hw_portnum(hcd, xhci,

			port_id);



	temp = xhci_readl(xhci, port_array[faked_port_index]);

	temp = readl(port_array[faked_port_index]);

	if (hcd->state == HC_STATE_SUSPENDED) {

		xhci_dbg(xhci, "resume root hub\n");

		usb_hcd_resume_root_hub(hcd);
@@ -1748,7 +1748,7 @@ static void handle_port_status(struct xhci_hcd *xhci, 
	if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_RESUME) {

		xhci_dbg(xhci, "port resume event for port %d\n", port_id);



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

		temp1 = readl(&xhci->op_regs->command);

		if (!(temp1 & CMD_RUN)) {

			xhci_warn(xhci, "xHC is not running.\n");

			goto cleanup;
@@ -2831,7 +2831,7 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd) 


	spin_lock(&xhci->lock);

	/* Check if the xHC generated the interrupt, or the irq is shared */

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

	status = readl(&xhci->op_regs->status);

	if (status == 0xffffffff)

		goto hw_died;
@@ -2860,7 +2860,7 @@ hw_died: 
	if (hcd->irq) {

		u32 irq_pending;

		/* Acknowledge the PCI interrupt */

		irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);

		irq_pending = readl(&xhci->ir_set->irq_pending);

		irq_pending |= IMAN_IP;

		xhci_writel(xhci, irq_pending, &xhci->ir_set->irq_pending);

	}
@@ -3931,7 +3931,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags, 
	if (ret)

		return ret;



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

	start_frame = readl(&xhci->run_regs->microframe_index);

	start_frame &= 0x3fff;



	urb->start_frame = start_frame;

drivers/usb/host/xhci.c

+43 −43

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE