Re: [PATCH v4:No Change] xHCI:Fixing xhci_readl definition and function call

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Kumar,

I was waiting until after the 3.12 merge window to queue this patch, but
Xenia noticed that the xhci_readl functions can completely go away and
be replaced by standard readl/writel operations.  She's posted a
patchset to do that:

http://marc.info/?l=linux-usb&m=137874983529708&w=2

I hate to do this to you, but her patch is a better improvement, so I'll
be taking that series instead of your patch.  I hope you can still find
other clean up work to do in the xHCI driver and USB core. :)

Sarah Sharp

On Wed, Sep 04, 2013 at 11:42:33AM +0530, Kumar Gaurav wrote:
> On Tuesday 03 September 2013 09:34 PM, Sarah Sharp wrote:
> >I'm confused.  I said the last version of this patch didn't apply
> >against usb-next, and you should rebase it.  Why did you put "No Change"
> >in the subject prefix?
> I miss understood what Dan said. he said me to add no change if
> there's no change from previous patch, but he didn't meant in
> subject (my bad).
> >
> >On Sat, Aug 31, 2013 at 11:02:45PM +0530, Kumar Gaurav wrote:
> >>This patch redefine function xhci_readl. xhci_readl function doesn't use xhci_hcd argument.
> >>Hence there is no need of keeping it in the function arguments.
> >>
> >>Redefining this function breaks other functions which calls this function.
> >>This phatch also correct those calls in xhci driver.
> >>
> >>Signed-off-by: Kumar Gaurav <kumargauravgupta3@xxxxxxxxx>
> >>---
> >You didn't describe why you're resending this, or what changed.  If you
> >did rebase this against usb-next, you should have left the subject
> >prefix as "PATCH v4" and said here:
> >
> >v4:
> >  - rebased against usb-next
> >
> >You can do this by generating the patch with `git format-patch`, edit
> >the patch manually (in whatever directory it was created it), and then
> >send it by passing the file to `git send-email`.
> >
> >Sarah Sharp
> I rebased it against linux-next and i'll send the same patch as you
> discribed but please do let me know if i need to mark that as "patch
> v5"
> as this patch won't have any change in changelog
> >>  drivers/usb/host/xhci-dbg.c  |   36 ++++++++---------
> >>  drivers/usb/host/xhci-hub.c  |   72 ++++++++++++++++-----------------
> >>  drivers/usb/host/xhci-mem.c  |   20 ++++-----
> >>  drivers/usb/host/xhci-ring.c |   12 +++---
> >>  drivers/usb/host/xhci.c      |   92 +++++++++++++++++++++---------------------
> >>  drivers/usb/host/xhci.h      |    3 +-
> >>  6 files changed, 117 insertions(+), 118 deletions(-)
> >>
> >>diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
> >>index 73503a8..229e312 100644
> >>--- a/drivers/usb/host/xhci-dbg.c
> >>+++ b/drivers/usb/host/xhci-dbg.c
> >>@@ -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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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) xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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],
> >>diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
> >>index fae697e..22758e7 100644
> >>--- a/drivers/usb/host/xhci-hub.c
> >>+++ b/drivers/usb/host/xhci-hub.c
> >>@@ -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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_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 = xhci_readl(port_array[port_id]);
> >>  	if (temp & port_bit) {
> >>  		temp = xhci_port_state_to_neutral(temp);
> >>  		temp |= port_bit;
> >>@@ -707,12 +707,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 = xhci_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 = xhci_readl(&xhci->cap_regs->hcc_params);
> >>  		if (HCC_LTC(temp))
> >>  			buf[8] |= USB_LTM_SUPPORT;
> >>@@ -722,7 +722,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 = xhci_readl(port_array[wIndex]);
> >>  		if (temp == 0xffffffff) {
> >>  			retval = -ENODEV;
> >>  			break;
> >>@@ -749,7 +749,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 = xhci_readl(port_array[wIndex]);
> >>  		if (temp == 0xffffffff) {
> >>  			retval = -ENODEV;
> >>  			break;
> >>@@ -758,7 +758,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 = xhci_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,
> >>@@ -771,7 +771,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 = xhci_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 "
> >>@@ -796,11 +796,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 = xhci_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 = xhci_readl(port_array[wIndex]);
> >>  			/* Disable port */
> >>  			if (link_state == USB_SS_PORT_LS_SS_DISABLED) {
> >>@@ -815,7 +815,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 = xhci_readl(port_array[wIndex]);
> >>  				break;
> >>  			}
> >>@@ -824,7 +824,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 = xhci_readl(port_array[wIndex]);
> >>  				break;
> >>  			}
> >>@@ -858,7 +858,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 = xhci_readl(port_array[wIndex]);
> >>  			if (link_state == USB_SS_PORT_LS_U3)
> >>  				bus_state->suspended_ports |= 1 << wIndex;
> >>  			break;
> >>@@ -872,7 +872,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 = xhci_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);
> >>@@ -887,13 +887,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 = xhci_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 = xhci_readl(port_array[wIndex]);
> >>  			xhci_dbg(xhci, "set port remote wake mask, "
> >>  					"actual port %d status  = 0x%x\n",
> >>  					wIndex, temp);
> >>@@ -902,12 +902,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 = xhci_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 = xhci_readl(port_array[wIndex] + PORTPMSC);
> >>  			temp &= ~PORT_U1_TIMEOUT_MASK;
> >>  			temp |= PORT_U1_TIMEOUT(timeout);
> >>  			xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
> >>@@ -915,7 +915,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 = xhci_readl(port_array[wIndex] + PORTPMSC);
> >>  			temp &= ~PORT_U2_TIMEOUT_MASK;
> >>  			temp |= PORT_U2_TIMEOUT(timeout);
> >>  			xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
> >>@@ -924,13 +924,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 = xhci_readl(port_array[wIndex]);
> >>  		break;
> >>  	case ClearPortFeature:
> >>  		if (!wIndex || wIndex > max_ports)
> >>  			goto error;
> >>  		wIndex--;
> >>-		temp = xhci_readl(xhci, port_array[wIndex]);
> >>+		temp = xhci_readl(port_array[wIndex]);
> >>  		if (temp == 0xffffffff) {
> >>  			retval = -ENODEV;
> >>  			break;
> >>@@ -939,7 +939,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 = xhci_readl(port_array[wIndex]);
> >>  			xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
> >>  			xhci_dbg(xhci, "PORTSC %04x\n", temp);
> >>  			if (temp & PORT_RESET)
> >>@@ -1044,7 +1044,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 = xhci_readl(port_array[i]);
> >>  		if (temp == 0xffffffff) {
> >>  			retval = -ENODEV;
> >>  			break;
> >>@@ -1098,7 +1098,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
> >>  		u32 t1, t2;
> >>  		int slot_id;
> >>-		t1 = xhci_readl(xhci, port_array[port_index]);
> >>+		t1 = xhci_readl(port_array[port_index]);
> >>  		t2 = xhci_port_state_to_neutral(t1);
> >>  		if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
> >>@@ -1140,7 +1140,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
> >>  			/* Get the port power control register address. */
> >>  			addr = port_array[port_index] + PORTPMSC;
> >>-			tmp = xhci_readl(xhci, addr);
> >>+			tmp = xhci_readl(addr);
> >>  			tmp |= PORT_RWE;
> >>  			xhci_writel(xhci, tmp, addr);
> >>  		}
> >>@@ -1173,7 +1173,7 @@ int xhci_bus_resume(struct usb_hcd *hcd)
> >>  	}
> >>  	/* delay the irqs */
> >>-	temp = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	temp = xhci_readl(&xhci->op_regs->command);
> >>  	temp &= ~CMD_EIE;
> >>  	xhci_writel(xhci, temp, &xhci->op_regs->command);
> >>@@ -1184,7 +1184,7 @@ int xhci_bus_resume(struct usb_hcd *hcd)
> >>  		u32 temp;
> >>  		int slot_id;
> >>-		temp = xhci_readl(xhci, port_array[port_index]);
> >>+		temp = xhci_readl(port_array[port_index]);
> >>  		if (DEV_SUPERSPEED(temp))
> >>  			temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
> >>  		else
> >>@@ -1232,20 +1232,20 @@ int xhci_bus_resume(struct usb_hcd *hcd)
> >>  			 * the port power control register address.
> >>  			 */
> >>  			addr = port_array[port_index] + PORTPMSC;
> >>-			tmp = xhci_readl(xhci, addr);
> >>+			tmp = xhci_readl(addr);
> >>  			tmp &= ~PORT_RWE;
> >>  			xhci_writel(xhci, tmp, addr);
> >>  		}
> >>  	}
> >>-	(void) xhci_readl(xhci, &xhci->op_regs->command);
> >>+	(void) xhci_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 = xhci_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 = xhci_readl(&xhci->op_regs->command);
> >>  	spin_unlock_irqrestore(&xhci->lock, flags);
> >>  	return 0;
> >>diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
> >>index 53b972c..e7a974b 100644
> >>--- a/drivers/usb/host/xhci-mem.c
> >>+++ b/drivers/usb/host/xhci-mem.c
> >>@@ -1995,7 +1995,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 = xhci_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,
> >>@@ -2078,7 +2078,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(xhci_readl(addr));
> >>  	if (offset == 0) {
> >>  		xhci_err(xhci, "No Extended Capability registers, "
> >>  				"unable to set up roothub.\n");
> >>@@ -2115,7 +2115,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 = xhci_readl(tmp_addr);
> >>  		if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
> >>  			cap_count++;
> >>  		tmp_offset = XHCI_EXT_CAPS_NEXT(cap_id);
> >>@@ -2129,7 +2129,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 = xhci_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),
> >>@@ -2234,7 +2234,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
> >>  	INIT_LIST_HEAD(&xhci->lpm_failed_devs);
> >>  	INIT_LIST_HEAD(&xhci->cancel_cmd_list);
> >>-	page_size = xhci_readl(xhci, &xhci->op_regs->page_size);
> >>+	page_size = xhci_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++) {
> >>@@ -2257,10 +2257,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(xhci_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 = xhci_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);
> >>@@ -2341,7 +2341,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 = xhci_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"
> >>@@ -2392,7 +2392,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 = xhci_readl(&xhci->ir_set->erst_size);
> >>  	val &= ERST_SIZE_MASK;
> >>  	val |= ERST_NUM_SEGS;
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>@@ -2439,7 +2439,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 = xhci_readl(&xhci->op_regs->dev_notification);
> >>  	temp &= ~DEV_NOTE_MASK;
> >>  	temp |= DEV_NOTE_FWAKE;
> >>  	xhci_writel(xhci, temp, &xhci->op_regs->dev_notification);
> >>diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
> >>index 411da1f..32da035 100644
> >>--- a/drivers/usb/host/xhci-ring.c
> >>+++ b/drivers/usb/host/xhci-ring.c
> >>@@ -287,7 +287,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]);
> >>+	xhci_readl(&xhci->dba->doorbell[0]);
> >>  }
> >>  static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
> >>@@ -1675,7 +1675,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 = xhci_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);
> >>@@ -1684,7 +1684,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 = xhci_readl(&xhci->op_regs->command);
> >>  		if (!(temp1 & CMD_RUN)) {
> >>  			xhci_warn(xhci, "xHC is not running.\n");
> >>  			goto cleanup;
> >>@@ -2754,7 +2754,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 = xhci_readl(&xhci->op_regs->status);
> >>  	if (status == 0xffffffff)
> >>  		goto hw_died;
> >>@@ -2783,7 +2783,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 = xhci_readl(&xhci->ir_set->irq_pending);
> >>  		irq_pending |= IMAN_IP;
> >>  		xhci_writel(xhci, irq_pending, &xhci->ir_set->irq_pending);
> >>  	}
> >>@@ -3854,7 +3854,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 = xhci_readl(&xhci->run_regs->microframe_index);
> >>  	start_frame &= 0x3fff;
> >>  	urb->start_frame = start_frame;
> >>diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
> >>index 49b6edb..8da2fd5 100644
> >>--- a/drivers/usb/host/xhci.c
> >>+++ b/drivers/usb/host/xhci.c
> >>@@ -60,7 +60,7 @@ int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
> >>  	u32	result;
> >>  	do {
> >>-		result = xhci_readl(xhci, ptr);
> >>+		result = xhci_readl(ptr);
> >>  		if (result == ~(u32)0)		/* card removed */
> >>  			return -ENODEV;
> >>  		result &= mask;
> >>@@ -82,11 +82,11 @@ void xhci_quiesce(struct xhci_hcd *xhci)
> >>  	u32 mask;
> >>  	mask = ~(XHCI_IRQS);
> >>-	halted = xhci_readl(xhci, &xhci->op_regs->status) & STS_HALT;
> >>+	halted = xhci_readl(&xhci->op_regs->status) & STS_HALT;
> >>  	if (!halted)
> >>  		mask &= ~CMD_RUN;
> >>-	cmd = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	cmd = xhci_readl(&xhci->op_regs->command);
> >>  	cmd &= mask;
> >>  	xhci_writel(xhci, cmd, &xhci->op_regs->command);
> >>  }
> >>@@ -124,7 +124,7 @@ static int xhci_start(struct xhci_hcd *xhci)
> >>  	u32 temp;
> >>  	int ret;
> >>-	temp = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	temp = xhci_readl(&xhci->op_regs->command);
> >>  	temp |= (CMD_RUN);
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Turn on HC, cmd = 0x%x.",
> >>  			temp);
> >>@@ -158,14 +158,14 @@ int xhci_reset(struct xhci_hcd *xhci)
> >>  	u32 state;
> >>  	int ret, i;
> >>-	state = xhci_readl(xhci, &xhci->op_regs->status);
> >>+	state = xhci_readl(&xhci->op_regs->status);
> >>  	if ((state & STS_HALT) == 0) {
> >>  		xhci_warn(xhci, "Host controller not halted, aborting reset.\n");
> >>  		return 0;
> >>  	}
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Reset the HC");
> >>-	command = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	command = xhci_readl(&xhci->op_regs->command);
> >>  	command |= CMD_RESET;
> >>  	xhci_writel(xhci, command, &xhci->op_regs->command);
> >>@@ -422,7 +422,7 @@ static void compliance_mode_recovery(unsigned long arg)
> >>  	xhci = (struct xhci_hcd *)arg;
> >>  	for (i = 0; i < xhci->num_usb3_ports; i++) {
> >>-		temp = xhci_readl(xhci, xhci->usb3_ports[i]);
> >>+		temp = xhci_readl(xhci->usb3_ports[i]);
> >>  		if ((temp & PORT_PLS_MASK) == USB_SS_PORT_LS_COMP_MOD) {
> >>  			/*
> >>  			 * Compliance Mode Detected. Letting USB Core
> >>@@ -611,19 +611,19 @@ int xhci_run(struct usb_hcd *hcd)
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"// Set the interrupt modulation register");
> >>-	temp = xhci_readl(xhci, &xhci->ir_set->irq_control);
> >>+	temp = xhci_readl(&xhci->ir_set->irq_control);
> >>  	temp &= ~ER_IRQ_INTERVAL_MASK;
> >>  	temp |= (u32) 160;
> >>  	xhci_writel(xhci, temp, &xhci->ir_set->irq_control);
> >>  	/* Set the HCD state before we enable the irqs */
> >>-	temp = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	temp = xhci_readl(&xhci->op_regs->command);
> >>  	temp |= (CMD_EIE);
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"// Enable interrupts, cmd = 0x%x.", temp);
> >>  	xhci_writel(xhci, temp, &xhci->op_regs->command);
> >>-	temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
> >>+	temp = xhci_readl(&xhci->ir_set->irq_pending);
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"// Enabling event ring interrupter %p by writing 0x%x to irq_pending",
> >>  			xhci->ir_set, (unsigned int) ER_IRQ_ENABLE(temp));
> >>@@ -698,9 +698,9 @@ void xhci_stop(struct usb_hcd *hcd)
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"// Disabling event ring interrupts");
> >>-	temp = xhci_readl(xhci, &xhci->op_regs->status);
> >>+	temp = xhci_readl(&xhci->op_regs->status);
> >>  	xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
> >>-	temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
> >>+	temp = xhci_readl(&xhci->ir_set->irq_pending);
> >>  	xhci_writel(xhci, ER_IRQ_DISABLE(temp),
> >>  			&xhci->ir_set->irq_pending);
> >>  	xhci_print_ir_set(xhci, 0);
> >>@@ -709,7 +709,7 @@ void xhci_stop(struct usb_hcd *hcd)
> >>  	xhci_mem_cleanup(xhci);
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"xhci_stop completed - status = %x",
> >>-			xhci_readl(xhci, &xhci->op_regs->status));
> >>+			xhci_readl(&xhci->op_regs->status));
> >>  }
> >>  /*
> >>@@ -736,21 +736,21 @@ void xhci_shutdown(struct usb_hcd *hcd)
> >>  	xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> >>  			"xhci_shutdown completed - status = %x",
> >>-			xhci_readl(xhci, &xhci->op_regs->status));
> >>+			xhci_readl(&xhci->op_regs->status));
> >>  }
> >>  #ifdef CONFIG_PM
> >>  static void xhci_save_registers(struct xhci_hcd *xhci)
> >>  {
> >>-	xhci->s3.command = xhci_readl(xhci, &xhci->op_regs->command);
> >>-	xhci->s3.dev_nt = xhci_readl(xhci, &xhci->op_regs->dev_notification);
> >>+	xhci->s3.command = xhci_readl(&xhci->op_regs->command);
> >>+	xhci->s3.dev_nt = xhci_readl(&xhci->op_regs->dev_notification);
> >>  	xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
> >>-	xhci->s3.config_reg = xhci_readl(xhci, &xhci->op_regs->config_reg);
> >>-	xhci->s3.erst_size = xhci_readl(xhci, &xhci->ir_set->erst_size);
> >>+	xhci->s3.config_reg = xhci_readl(&xhci->op_regs->config_reg);
> >>+	xhci->s3.erst_size = xhci_readl(&xhci->ir_set->erst_size);
> >>  	xhci->s3.erst_base = xhci_read_64(xhci, &xhci->ir_set->erst_base);
> >>  	xhci->s3.erst_dequeue = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
> >>-	xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
> >>-	xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control);
> >>+	xhci->s3.irq_pending = xhci_readl(&xhci->ir_set->irq_pending);
> >>+	xhci->s3.irq_control = xhci_readl(&xhci->ir_set->irq_control);
> >>  }
> >>  static void xhci_restore_registers(struct xhci_hcd *xhci)
> >>@@ -858,7 +858,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
> >>  	/* skipped assuming that port suspend has done */
> >>  	/* step 2: clear Run/Stop bit */
> >>-	command = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	command = xhci_readl(&xhci->op_regs->command);
> >>  	command &= ~CMD_RUN;
> >>  	xhci_writel(xhci, command, &xhci->op_regs->command);
> >>  	if (xhci_handshake(xhci, &xhci->op_regs->status,
> >>@@ -873,7 +873,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
> >>  	xhci_save_registers(xhci);
> >>  	/* step 4: set CSS flag */
> >>-	command = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	command = xhci_readl(&xhci->op_regs->command);
> >>  	command |= CMD_CSS;
> >>  	xhci_writel(xhci, command, &xhci->op_regs->command);
> >>  	if (xhci_handshake(xhci, &xhci->op_regs->status,
> >>@@ -939,7 +939,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
> >>  		xhci_set_cmd_ring_deq(xhci);
> >>  		/* step 3: restore state and start state*/
> >>  		/* step 3: set CRS flag */
> >>-		command = xhci_readl(xhci, &xhci->op_regs->command);
> >>+		command = xhci_readl(&xhci->op_regs->command);
> >>  		command |= CMD_CRS;
> >>  		xhci_writel(xhci, command, &xhci->op_regs->command);
> >>  		if (xhci_handshake(xhci, &xhci->op_regs->status,
> >>@@ -948,7 +948,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
> >>  			spin_unlock_irq(&xhci->lock);
> >>  			return -ETIMEDOUT;
> >>  		}
> >>-		temp = xhci_readl(xhci, &xhci->op_regs->status);
> >>+		temp = xhci_readl(&xhci->op_regs->status);
> >>  	}
> >>  	/* If restore operation fails, re-initialize the HC during resume */
> >>@@ -972,9 +972,9 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
> >>  		xhci_cleanup_msix(xhci);
> >>  		xhci_dbg(xhci, "// Disabling event ring interrupts\n");
> >>-		temp = xhci_readl(xhci, &xhci->op_regs->status);
> >>+		temp = xhci_readl(&xhci->op_regs->status);
> >>  		xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
> >>-		temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
> >>+		temp = xhci_readl(&xhci->ir_set->irq_pending);
> >>  		xhci_writel(xhci, ER_IRQ_DISABLE(temp),
> >>  				&xhci->ir_set->irq_pending);
> >>  		xhci_print_ir_set(xhci, 0);
> >>@@ -982,7 +982,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
> >>  		xhci_dbg(xhci, "cleaning up memory\n");
> >>  		xhci_mem_cleanup(xhci);
> >>  		xhci_dbg(xhci, "xhci_stop completed - status = %x\n",
> >>-			    xhci_readl(xhci, &xhci->op_regs->status));
> >>+			    xhci_readl(&xhci->op_regs->status));
> >>  		/* USB core calls the PCI reinit and start functions twice:
> >>  		 * first with the primary HCD, and then with the secondary HCD.
> >>@@ -1011,7 +1011,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
> >>  	}
> >>  	/* step 4: set Run/Stop bit */
> >>-	command = xhci_readl(xhci, &xhci->op_regs->command);
> >>+	command = xhci_readl(&xhci->op_regs->command);
> >>  	command |= CMD_RUN;
> >>  	xhci_writel(xhci, command, &xhci->op_regs->command);
> >>  	xhci_handshake(xhci, &xhci->op_regs->status, STS_HALT,
> >>@@ -1452,7 +1452,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
> >>  	ret = usb_hcd_check_unlink_urb(hcd, urb, status);
> >>  	if (ret || !urb->hcpriv)
> >>  		goto done;
> >>-	temp = xhci_readl(xhci, &xhci->op_regs->status);
> >>+	temp = xhci_readl(&xhci->op_regs->status);
> >>  	if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
> >>  		xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
> >>  				"HW died, freeing TD.");
> >>@@ -3593,7 +3593,7 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
> >>  	spin_lock_irqsave(&xhci->lock, flags);
> >>  	/* Don't disable the slot if the host controller is dead. */
> >>-	state = xhci_readl(xhci, &xhci->op_regs->status);
> >>+	state = xhci_readl(&xhci->op_regs->status);
> >>  	if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
> >>  			(xhci->xhc_state & XHCI_STATE_HALTED)) {
> >>  		xhci_free_virt_device(xhci, udev->slot_id);
> >>@@ -4102,12 +4102,12 @@ static int xhci_usb2_software_lpm_test(struct usb_hcd *hcd,
> >>  			PORT_L1S_MASK, PORT_L1S_SUCCESS, 125);
> >>  	if (ret != -ETIMEDOUT) {
> >>  		/* enter L1 successfully */
> >>-		temp = xhci_readl(xhci, addr);
> >>+		temp = xhci_readl(addr);
> >>  		xhci_dbg(xhci, "port %d entered L1 state, port status 0x%x\n",
> >>  				port_num, temp);
> >>  		ret = 0;
> >>  	} else {
> >>-		temp = xhci_readl(xhci, pm_addr);
> >>+		temp = xhci_readl(pm_addr);
> >>  		xhci_dbg(xhci, "port %d software lpm failed, L1 status %d\n",
> >>  				port_num, temp & PORT_L1S_MASK);
> >>  		ret = -EINVAL;
> >>@@ -4125,7 +4125,7 @@ static int xhci_usb2_software_lpm_test(struct usb_hcd *hcd,
> >>  	/* Check PORTSC to make sure the device is in the right state */
> >>  	if (!ret) {
> >>-		temp = xhci_readl(xhci, addr);
> >>+		temp = xhci_readl(addr);
> >>  		xhci_dbg(xhci, "resumed port %d status 0x%x\n",	port_num, temp);
> >>  		if (!(temp & PORT_CONNECT) || !(temp & PORT_PE) ||
> >>  				(temp & PORT_PLS_MASK) != XDEV_U0) {
> >>@@ -4183,7 +4183,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
> >>  	port_array = xhci->usb2_ports;
> >>  	port_num = udev->portnum - 1;
> >>  	pm_addr = port_array[port_num] + PORTPMSC;
> >>-	pm_val = xhci_readl(xhci, pm_addr);
> >>+	pm_val = xhci_readl(pm_addr);
> >>  	hlpm_addr = port_array[port_num] + PORTHLPMC;
> >>  	field = le32_to_cpu(udev->bos->ext_cap->bmAttributes);
> >>@@ -4225,7 +4225,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
> >>  			hlpm_val = xhci_calculate_usb2_hw_lpm_params(udev);
> >>  			xhci_writel(xhci, hlpm_val, hlpm_addr);
> >>  			/* flush write */
> >>-			xhci_readl(xhci, hlpm_addr);
> >>+			xhci_readl(hlpm_addr);
> >>  		} else {
> >>  			hird = xhci_calculate_hird_besl(xhci, udev);
> >>  		}
> >>@@ -4233,16 +4233,16 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
> >>  		pm_val &= ~PORT_HIRD_MASK;
> >>  		pm_val |= PORT_HIRD(hird) | PORT_RWE;
> >>  		xhci_writel(xhci, pm_val, pm_addr);
> >>-		pm_val = xhci_readl(xhci, pm_addr);
> >>+		pm_val = xhci_readl(pm_addr);
> >>  		pm_val |= PORT_HLE;
> >>  		xhci_writel(xhci, pm_val, pm_addr);
> >>  		/* flush write */
> >>-		xhci_readl(xhci, pm_addr);
> >>+		xhci_readl(pm_addr);
> >>  	} else {
> >>  		pm_val &= ~(PORT_HLE | PORT_RWE | PORT_HIRD_MASK);
> >>  		xhci_writel(xhci, pm_val, pm_addr);
> >>  		/* flush write */
> >>-		xhci_readl(xhci, pm_addr);
> >>+		xhci_readl(pm_addr);
> >>  		if (udev->usb2_hw_lpm_besl_capable) {
> >>  			spin_unlock_irqrestore(&xhci->lock, flags);
> >>  			mutex_lock(hcd->bandwidth_mutex);
> >>@@ -4843,7 +4843,7 @@ int xhci_get_frame(struct usb_hcd *hcd)
> >>  {
> >>  	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
> >>  	/* EHCI mods by the periodic size.  Why? */
> >>-	return xhci_readl(xhci, &xhci->run_regs->microframe_index) >> 3;
> >>+	return xhci_readl(&xhci->run_regs->microframe_index) >> 3;
> >>  }
> >>  int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
> >>@@ -4887,16 +4887,16 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
> >>  	xhci->cap_regs = hcd->regs;
> >>  	xhci->op_regs = hcd->regs +
> >>-		HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
> >>+		HC_LENGTH(xhci_readl(&xhci->cap_regs->hc_capbase));
> >>  	xhci->run_regs = hcd->regs +
> >>-		(xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
> >>+		(xhci_readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
> >>  	/* Cache read-only capability registers */
> >>-	xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
> >>-	xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
> >>-	xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
> >>-	xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
> >>+	xhci->hcs_params1 = xhci_readl(&xhci->cap_regs->hcs_params1);
> >>+	xhci->hcs_params2 = xhci_readl(&xhci->cap_regs->hcs_params2);
> >>+	xhci->hcs_params3 = xhci_readl(&xhci->cap_regs->hcs_params3);
> >>+	xhci->hcc_params = xhci_readl(&xhci->cap_regs->hc_capbase);
> >>  	xhci->hci_version = HC_VERSION(xhci->hcc_params);
> >>-	xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
> >>+	xhci->hcc_params = xhci_readl(&xhci->cap_regs->hcc_params);
> >>  	xhci_print_registers(xhci);
> >>  	get_quirks(dev, xhci);
> >>diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
> >>index 46aa148..3acb044 100644
> >>--- a/drivers/usb/host/xhci.h
> >>+++ b/drivers/usb/host/xhci.h
> >>@@ -1586,8 +1586,7 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
> >>  /* TODO: copied from ehci.h - can be refactored? */
> >>  /* xHCI spec says all registers are little endian */
> >>-static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
> >>-		__le32 __iomem *regs)
> >>+static inline unsigned int xhci_readl(__le32 __iomem *regs)
> >>  {
> >>  	return readl(regs);
> >>  }
> >>-- 
> >>1.7.9.5
> >>
> 
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux