blob: 1ab7f2e2c05f61b4a34e69960375dda4369a18d1 [file] [log] [blame]
Sarah Sharp0f2a7932009-04-27 19:57:12 -07001/*
2 * xHCI host controller driver
3 *
4 * Copyright (C) 2008 Intel Corp.
5 *
6 * Author: Sarah Sharp
7 * Some code borrowed from the Linux EHCI driver.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23#include <asm/unaligned.h>
24
25#include "xhci.h"
26
Andiry Xu9777e3c2010-10-14 07:23:03 -070027#define PORT_WAKE_BITS (PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E)
28#define PORT_RWC_BITS (PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
29 PORT_RC | PORT_PLC | PORT_PE)
30
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -080031static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
32 struct usb_hub_descriptor *desc, int ports)
Sarah Sharp0f2a7932009-04-27 19:57:12 -070033{
Sarah Sharp0f2a7932009-04-27 19:57:12 -070034 u16 temp;
35
Sarah Sharp0f2a7932009-04-27 19:57:12 -070036 desc->bPwrOn2PwrGood = 10; /* xhci section 5.4.9 says 20ms max */
37 desc->bHubContrCurrent = 0;
38
39 desc->bNbrPorts = ports;
Sarah Sharp0f2a7932009-04-27 19:57:12 -070040 /* Ugh, these should be #defines, FIXME */
41 /* Using table 11-13 in USB 2.0 spec. */
42 temp = 0;
43 /* Bits 1:0 - support port power switching, or power always on */
44 if (HCC_PPC(xhci->hcc_params))
45 temp |= 0x0001;
46 else
47 temp |= 0x0002;
48 /* Bit 2 - root hubs are not part of a compound device */
49 /* Bits 4:3 - individual port over current protection */
50 temp |= 0x0008;
51 /* Bits 6:5 - no TTs in root ports */
52 /* Bit 7 - no port indicators */
Matt Evans28ccd292011-03-29 13:40:46 +110053 desc->wHubCharacteristics = cpu_to_le16(temp);
Sarah Sharp0f2a7932009-04-27 19:57:12 -070054}
55
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -080056/* Fill in the USB 2.0 roothub descriptor */
57static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
58 struct usb_hub_descriptor *desc)
59{
60 int ports;
61 u16 temp;
62 __u8 port_removable[(USB_MAXCHILDREN + 1 + 7) / 8];
63 u32 portsc;
64 unsigned int i;
65
66 ports = xhci->num_usb2_ports;
67
68 xhci_common_hub_descriptor(xhci, desc, ports);
69 desc->bDescriptorType = 0x29;
70 temp = 1 + (ports / 8);
71 desc->bDescLength = 7 + 2 * temp;
72
73 /* The Device Removable bits are reported on a byte granularity.
74 * If the port doesn't exist within that byte, the bit is set to 0.
75 */
76 memset(port_removable, 0, sizeof(port_removable));
77 for (i = 0; i < ports; i++) {
78 portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
79 /* If a device is removable, PORTSC reports a 0, same as in the
80 * hub descriptor DeviceRemovable bits.
81 */
82 if (portsc & PORT_DEV_REMOVE)
83 /* This math is hairy because bit 0 of DeviceRemovable
84 * is reserved, and bit 1 is for port 1, etc.
85 */
86 port_removable[(i + 1) / 8] |= 1 << ((i + 1) % 8);
87 }
88
89 /* ch11.h defines a hub descriptor that has room for USB_MAXCHILDREN
90 * ports on it. The USB 2.0 specification says that there are two
91 * variable length fields at the end of the hub descriptor:
92 * DeviceRemovable and PortPwrCtrlMask. But since we can have less than
93 * USB_MAXCHILDREN ports, we may need to use the DeviceRemovable array
94 * to set PortPwrCtrlMask bits. PortPwrCtrlMask must always be set to
95 * 0xFF, so we initialize the both arrays (DeviceRemovable and
96 * PortPwrCtrlMask) to 0xFF. Then we set the DeviceRemovable for each
97 * set of ports that actually exist.
98 */
99 memset(desc->u.hs.DeviceRemovable, 0xff,
100 sizeof(desc->u.hs.DeviceRemovable));
101 memset(desc->u.hs.PortPwrCtrlMask, 0xff,
102 sizeof(desc->u.hs.PortPwrCtrlMask));
103
104 for (i = 0; i < (ports + 1 + 7) / 8; i++)
105 memset(&desc->u.hs.DeviceRemovable[i], port_removable[i],
106 sizeof(__u8));
107}
108
109/* Fill in the USB 3.0 roothub descriptor */
110static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
111 struct usb_hub_descriptor *desc)
112{
113 int ports;
114 u16 port_removable;
115 u32 portsc;
116 unsigned int i;
117
118 ports = xhci->num_usb3_ports;
119 xhci_common_hub_descriptor(xhci, desc, ports);
120 desc->bDescriptorType = 0x2a;
121 desc->bDescLength = 12;
122
123 /* header decode latency should be zero for roothubs,
124 * see section 4.23.5.2.
125 */
126 desc->u.ss.bHubHdrDecLat = 0;
127 desc->u.ss.wHubDelay = 0;
128
129 port_removable = 0;
130 /* bit 0 is reserved, bit 1 is for port 1, etc. */
131 for (i = 0; i < ports; i++) {
132 portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
133 if (portsc & PORT_DEV_REMOVE)
134 port_removable |= 1 << (i + 1);
135 }
136 memset(&desc->u.ss.DeviceRemovable,
137 (__force __u16) cpu_to_le16(port_removable),
138 sizeof(__u16));
139}
140
141static void xhci_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
142 struct usb_hub_descriptor *desc)
143{
144
145 if (hcd->speed == HCD_USB3)
146 xhci_usb3_hub_descriptor(hcd, xhci, desc);
147 else
148 xhci_usb2_hub_descriptor(hcd, xhci, desc);
149
150}
151
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700152static unsigned int xhci_port_speed(unsigned int port_status)
153{
154 if (DEV_LOWSPEED(port_status))
Alan Stern288ead42010-03-04 11:32:30 -0500155 return USB_PORT_STAT_LOW_SPEED;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700156 if (DEV_HIGHSPEED(port_status))
Alan Stern288ead42010-03-04 11:32:30 -0500157 return USB_PORT_STAT_HIGH_SPEED;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700158 /*
159 * FIXME: Yes, we should check for full speed, but the core uses that as
160 * a default in portspeed() in usb/core/hub.c (which is the only place
Alan Stern288ead42010-03-04 11:32:30 -0500161 * USB_PORT_STAT_*_SPEED is used).
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700162 */
163 return 0;
164}
165
166/*
167 * These bits are Read Only (RO) and should be saved and written to the
168 * registers: 0, 3, 10:13, 30
169 * connect status, over-current status, port speed, and device removable.
170 * connect status and port speed are also sticky - meaning they're in
171 * the AUX well and they aren't changed by a hot, warm, or cold reset.
172 */
173#define XHCI_PORT_RO ((1<<0) | (1<<3) | (0xf<<10) | (1<<30))
174/*
175 * These bits are RW; writing a 0 clears the bit, writing a 1 sets the bit:
176 * bits 5:8, 9, 14:15, 25:27
177 * link state, port power, port indicator state, "wake on" enable state
178 */
179#define XHCI_PORT_RWS ((0xf<<5) | (1<<9) | (0x3<<14) | (0x7<<25))
180/*
181 * These bits are RW; writing a 1 sets the bit, writing a 0 has no effect:
182 * bit 4 (port reset)
183 */
184#define XHCI_PORT_RW1S ((1<<4))
185/*
186 * These bits are RW; writing a 1 clears the bit, writing a 0 has no effect:
187 * bits 1, 17, 18, 19, 20, 21, 22, 23
188 * port enable/disable, and
189 * change bits: connect, PED, warm port reset changed (reserved zero for USB 2.0 ports),
190 * over-current, reset, link state, and L1 change
191 */
192#define XHCI_PORT_RW1CS ((1<<1) | (0x7f<<17))
193/*
194 * Bit 16 is RW, and writing a '1' to it causes the link state control to be
195 * latched in
196 */
197#define XHCI_PORT_RW ((1<<16))
198/*
199 * These bits are Reserved Zero (RsvdZ) and zero should be written to them:
200 * bits 2, 24, 28:31
201 */
202#define XHCI_PORT_RZ ((1<<2) | (1<<24) | (0xf<<28))
203
204/*
205 * Given a port state, this function returns a value that would result in the
206 * port being in the same state, if the value was written to the port status
207 * control register.
208 * Save Read Only (RO) bits and save read/write bits where
209 * writing a 0 clears the bit and writing a 1 sets the bit (RWS).
210 * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect.
211 */
Andiry Xu56192532010-10-14 07:23:00 -0700212u32 xhci_port_state_to_neutral(u32 state)
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700213{
214 /* Save read-only status and port state */
215 return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
216}
217
Andiry Xube88fe42010-10-14 07:22:57 -0700218/*
219 * find slot id based on port number.
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800220 * @port: The one-based port number from one of the two split roothubs.
Andiry Xube88fe42010-10-14 07:22:57 -0700221 */
Sarah Sharp52336302010-12-16 10:49:09 -0800222int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
223 u16 port)
Andiry Xube88fe42010-10-14 07:22:57 -0700224{
225 int slot_id;
226 int i;
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800227 enum usb_device_speed speed;
Andiry Xube88fe42010-10-14 07:22:57 -0700228
229 slot_id = 0;
230 for (i = 0; i < MAX_HC_SLOTS; i++) {
231 if (!xhci->devs[i])
232 continue;
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800233 speed = xhci->devs[i]->udev->speed;
234 if (((speed == USB_SPEED_SUPER) == (hcd->speed == HCD_USB3))
235 && xhci->devs[i]->port == port) {
Andiry Xube88fe42010-10-14 07:22:57 -0700236 slot_id = i;
237 break;
238 }
239 }
240
241 return slot_id;
242}
243
244/*
245 * Stop device
246 * It issues stop endpoint command for EP 0 to 30. And wait the last command
247 * to complete.
248 * suspend will set to 1, if suspend bit need to set in command.
249 */
250static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
251{
252 struct xhci_virt_device *virt_dev;
253 struct xhci_command *cmd;
254 unsigned long flags;
255 int timeleft;
256 int ret;
257 int i;
258
259 ret = 0;
260 virt_dev = xhci->devs[slot_id];
261 cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
262 if (!cmd) {
263 xhci_dbg(xhci, "Couldn't allocate command structure.\n");
264 return -ENOMEM;
265 }
266
267 spin_lock_irqsave(&xhci->lock, flags);
268 for (i = LAST_EP_INDEX; i > 0; i--) {
269 if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
270 xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
271 }
272 cmd->command_trb = xhci->cmd_ring->enqueue;
273 list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
274 xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
275 xhci_ring_cmd_db(xhci);
276 spin_unlock_irqrestore(&xhci->lock, flags);
277
278 /* Wait for last stop endpoint command to finish */
279 timeleft = wait_for_completion_interruptible_timeout(
280 cmd->completion,
281 USB_CTRL_SET_TIMEOUT);
282 if (timeleft <= 0) {
283 xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
284 timeleft == 0 ? "Timeout" : "Signal");
285 spin_lock_irqsave(&xhci->lock, flags);
286 /* The timeout might have raced with the event ring handler, so
287 * only delete from the list if the item isn't poisoned.
288 */
289 if (cmd->cmd_list.next != LIST_POISON1)
290 list_del(&cmd->cmd_list);
291 spin_unlock_irqrestore(&xhci->lock, flags);
292 ret = -ETIME;
293 goto command_cleanup;
294 }
295
296command_cleanup:
297 xhci_free_command(xhci, cmd);
298 return ret;
299}
300
301/*
302 * Ring device, it rings the all doorbells unconditionally.
303 */
Andiry Xu56192532010-10-14 07:23:00 -0700304void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
Andiry Xube88fe42010-10-14 07:22:57 -0700305{
306 int i;
307
308 for (i = 0; i < LAST_EP_INDEX + 1; i++)
309 if (xhci->devs[slot_id]->eps[i].ring &&
310 xhci->devs[slot_id]->eps[i].ring->dequeue)
311 xhci_ring_ep_doorbell(xhci, slot_id, i, 0);
312
313 return;
314}
315
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800316static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
Matt Evans28ccd292011-03-29 13:40:46 +1100317 u16 wIndex, __le32 __iomem *addr, u32 port_status)
Sarah Sharp6219c0472009-12-09 15:59:11 -0800318{
Sarah Sharp6dd0a3a72010-11-16 15:58:52 -0800319 /* Don't allow the USB core to disable SuperSpeed ports. */
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800320 if (hcd->speed == HCD_USB3) {
Sarah Sharp6dd0a3a72010-11-16 15:58:52 -0800321 xhci_dbg(xhci, "Ignoring request to disable "
322 "SuperSpeed port.\n");
323 return;
324 }
325
Sarah Sharp6219c0472009-12-09 15:59:11 -0800326 /* Write 1 to disable the port */
327 xhci_writel(xhci, port_status | PORT_PE, addr);
328 port_status = xhci_readl(xhci, addr);
329 xhci_dbg(xhci, "disable port, actual port %d status = 0x%x\n",
330 wIndex, port_status);
331}
332
Sarah Sharp34fb5622009-12-09 15:59:08 -0800333static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
Matt Evans28ccd292011-03-29 13:40:46 +1100334 u16 wIndex, __le32 __iomem *addr, u32 port_status)
Sarah Sharp34fb5622009-12-09 15:59:08 -0800335{
336 char *port_change_bit;
337 u32 status;
338
339 switch (wValue) {
340 case USB_PORT_FEAT_C_RESET:
341 status = PORT_RC;
342 port_change_bit = "reset";
343 break;
Andiry Xua11496e2011-04-27 18:07:29 +0800344 case USB_PORT_FEAT_C_BH_PORT_RESET:
345 status = PORT_WRC;
346 port_change_bit = "warm(BH) reset";
347 break;
Sarah Sharp34fb5622009-12-09 15:59:08 -0800348 case USB_PORT_FEAT_C_CONNECTION:
349 status = PORT_CSC;
350 port_change_bit = "connect";
351 break;
352 case USB_PORT_FEAT_C_OVER_CURRENT:
353 status = PORT_OCC;
354 port_change_bit = "over-current";
355 break;
Sarah Sharp6219c0472009-12-09 15:59:11 -0800356 case USB_PORT_FEAT_C_ENABLE:
357 status = PORT_PEC;
358 port_change_bit = "enable/disable";
359 break;
Andiry Xube88fe42010-10-14 07:22:57 -0700360 case USB_PORT_FEAT_C_SUSPEND:
361 status = PORT_PLC;
362 port_change_bit = "suspend/resume";
363 break;
Sarah Sharp34fb5622009-12-09 15:59:08 -0800364 default:
365 /* Should never happen */
366 return;
367 }
368 /* Change bits are all write 1 to clear */
369 xhci_writel(xhci, port_status | status, addr);
370 port_status = xhci_readl(xhci, addr);
371 xhci_dbg(xhci, "clear port %s change, actual port %d status = 0x%x\n",
372 port_change_bit, wIndex, port_status);
373}
374
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700375int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
376 u16 wIndex, char *buf, u16 wLength)
377{
378 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
379 int ports;
380 unsigned long flags;
Andiry Xu56192532010-10-14 07:23:00 -0700381 u32 temp, temp1, status;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700382 int retval = 0;
Matt Evans28ccd292011-03-29 13:40:46 +1100383 __le32 __iomem **port_array;
Andiry Xube88fe42010-10-14 07:22:57 -0700384 int slot_id;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800385 struct xhci_bus_state *bus_state;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700386
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800387 if (hcd->speed == HCD_USB3) {
388 ports = xhci->num_usb3_ports;
389 port_array = xhci->usb3_ports;
390 } else {
391 ports = xhci->num_usb2_ports;
392 port_array = xhci->usb2_ports;
Sarah Sharp5308a912010-12-01 11:34:59 -0800393 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800394 bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700395
396 spin_lock_irqsave(&xhci->lock, flags);
397 switch (typeReq) {
398 case GetHubStatus:
399 /* No power source, over-current reported per port */
400 memset(buf, 0, 4);
401 break;
402 case GetHubDescriptor:
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800403 /* Check to make sure userspace is asking for the USB 3.0 hub
404 * descriptor for the USB 3.0 roothub. If not, we stall the
405 * endpoint, like external hubs do.
406 */
407 if (hcd->speed == HCD_USB3 &&
408 (wLength < USB_DT_SS_HUB_SIZE ||
409 wValue != (USB_DT_SS_HUB << 8))) {
410 xhci_dbg(xhci, "Wrong hub descriptor type for "
411 "USB 3.0 roothub.\n");
412 goto error;
413 }
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800414 xhci_hub_descriptor(hcd, xhci,
415 (struct usb_hub_descriptor *) buf);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700416 break;
417 case GetPortStatus:
418 if (!wIndex || wIndex > ports)
419 goto error;
420 wIndex--;
421 status = 0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800422 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700423 if (temp == 0xffffffff) {
424 retval = -ENODEV;
425 break;
426 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700427 xhci_dbg(xhci, "get port status, actual port %d status = 0x%x\n", wIndex, temp);
428
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800429 /* FIXME - should we return a port status value like the USB
430 * 3.0 external hubs do?
431 */
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700432 /* wPortChange bits */
433 if (temp & PORT_CSC)
Alan Stern749da5f2010-03-04 17:05:08 -0500434 status |= USB_PORT_STAT_C_CONNECTION << 16;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700435 if (temp & PORT_PEC)
Alan Stern749da5f2010-03-04 17:05:08 -0500436 status |= USB_PORT_STAT_C_ENABLE << 16;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700437 if ((temp & PORT_OCC))
Alan Stern749da5f2010-03-04 17:05:08 -0500438 status |= USB_PORT_STAT_C_OVERCURRENT << 16;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700439 /*
Andiry Xube88fe42010-10-14 07:22:57 -0700440 * FIXME ignoring reset and USB 2.1/3.0 specific
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700441 * changes
442 */
Andiry Xube88fe42010-10-14 07:22:57 -0700443 if ((temp & PORT_PLS_MASK) == XDEV_U3
444 && (temp & PORT_POWER))
445 status |= 1 << USB_PORT_FEAT_SUSPEND;
Andiry Xu56192532010-10-14 07:23:00 -0700446 if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
447 if ((temp & PORT_RESET) || !(temp & PORT_PE))
448 goto error;
449 if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800450 bus_state->resume_done[wIndex])) {
Andiry Xu56192532010-10-14 07:23:00 -0700451 xhci_dbg(xhci, "Resume USB2 port %d\n",
452 wIndex + 1);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800453 bus_state->resume_done[wIndex] = 0;
Andiry Xu56192532010-10-14 07:23:00 -0700454 temp1 = xhci_port_state_to_neutral(temp);
455 temp1 &= ~PORT_PLS_MASK;
456 temp1 |= PORT_LINK_STROBE | XDEV_U0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800457 xhci_writel(xhci, temp1, port_array[wIndex]);
Andiry Xu56192532010-10-14 07:23:00 -0700458
459 xhci_dbg(xhci, "set port %d resume\n",
460 wIndex + 1);
Sarah Sharp52336302010-12-16 10:49:09 -0800461 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
Andiry Xu56192532010-10-14 07:23:00 -0700462 wIndex + 1);
463 if (!slot_id) {
464 xhci_dbg(xhci, "slot_id is zero\n");
465 goto error;
466 }
467 xhci_ring_device(xhci, slot_id);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800468 bus_state->port_c_suspend |= 1 << wIndex;
469 bus_state->suspended_ports &= ~(1 << wIndex);
Andiry Xu56192532010-10-14 07:23:00 -0700470 }
471 }
Andiry Xube88fe42010-10-14 07:22:57 -0700472 if ((temp & PORT_PLS_MASK) == XDEV_U0
473 && (temp & PORT_POWER)
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800474 && (bus_state->suspended_ports & (1 << wIndex))) {
475 bus_state->suspended_ports &= ~(1 << wIndex);
476 bus_state->port_c_suspend |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700477 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700478 if (temp & PORT_CONNECT) {
Alan Stern749da5f2010-03-04 17:05:08 -0500479 status |= USB_PORT_STAT_CONNECTION;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700480 status |= xhci_port_speed(temp);
481 }
482 if (temp & PORT_PE)
Alan Stern749da5f2010-03-04 17:05:08 -0500483 status |= USB_PORT_STAT_ENABLE;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700484 if (temp & PORT_OC)
Alan Stern749da5f2010-03-04 17:05:08 -0500485 status |= USB_PORT_STAT_OVERCURRENT;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700486 if (temp & PORT_RESET)
Alan Stern749da5f2010-03-04 17:05:08 -0500487 status |= USB_PORT_STAT_RESET;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700488 if (temp & PORT_POWER)
Alan Stern749da5f2010-03-04 17:05:08 -0500489 status |= USB_PORT_STAT_POWER;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800490 if (bus_state->port_c_suspend & (1 << wIndex))
Andiry Xube88fe42010-10-14 07:22:57 -0700491 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700492 xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
493 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
494 break;
495 case SetPortFeature:
496 wIndex &= 0xff;
497 if (!wIndex || wIndex > ports)
498 goto error;
499 wIndex--;
Sarah Sharp5308a912010-12-01 11:34:59 -0800500 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700501 if (temp == 0xffffffff) {
502 retval = -ENODEV;
503 break;
504 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700505 temp = xhci_port_state_to_neutral(temp);
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800506 /* FIXME: What new port features do we need to support? */
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700507 switch (wValue) {
Andiry Xube88fe42010-10-14 07:22:57 -0700508 case USB_PORT_FEAT_SUSPEND:
Sarah Sharp5308a912010-12-01 11:34:59 -0800509 temp = xhci_readl(xhci, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700510 /* In spec software should not attempt to suspend
511 * a port unless the port reports that it is in the
512 * enabled (PED = ‘1’,PLS < ‘3’) state.
513 */
514 if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
515 || (temp & PORT_PLS_MASK) >= XDEV_U3) {
516 xhci_warn(xhci, "USB core suspending device "
517 "not in U0/U1/U2.\n");
518 goto error;
519 }
520
Sarah Sharp52336302010-12-16 10:49:09 -0800521 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
522 wIndex + 1);
Andiry Xube88fe42010-10-14 07:22:57 -0700523 if (!slot_id) {
524 xhci_warn(xhci, "slot_id is zero\n");
525 goto error;
526 }
527 /* unlock to execute stop endpoint commands */
528 spin_unlock_irqrestore(&xhci->lock, flags);
529 xhci_stop_device(xhci, slot_id, 1);
530 spin_lock_irqsave(&xhci->lock, flags);
531
532 temp = xhci_port_state_to_neutral(temp);
533 temp &= ~PORT_PLS_MASK;
534 temp |= PORT_LINK_STROBE | XDEV_U3;
Sarah Sharp5308a912010-12-01 11:34:59 -0800535 xhci_writel(xhci, temp, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700536
537 spin_unlock_irqrestore(&xhci->lock, flags);
538 msleep(10); /* wait device to enter */
539 spin_lock_irqsave(&xhci->lock, flags);
540
Sarah Sharp5308a912010-12-01 11:34:59 -0800541 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800542 bus_state->suspended_ports |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700543 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700544 case USB_PORT_FEAT_POWER:
545 /*
546 * Turn on ports, even if there isn't per-port switching.
547 * HC will report connect events even before this is set.
548 * However, khubd will ignore the roothub events until
549 * the roothub is registered.
550 */
Sarah Sharp5308a912010-12-01 11:34:59 -0800551 xhci_writel(xhci, temp | PORT_POWER,
552 port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700553
Sarah Sharp5308a912010-12-01 11:34:59 -0800554 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700555 xhci_dbg(xhci, "set port power, actual port %d status = 0x%x\n", wIndex, temp);
556 break;
557 case USB_PORT_FEAT_RESET:
558 temp = (temp | PORT_RESET);
Sarah Sharp5308a912010-12-01 11:34:59 -0800559 xhci_writel(xhci, temp, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700560
Sarah Sharp5308a912010-12-01 11:34:59 -0800561 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700562 xhci_dbg(xhci, "set port reset, actual port %d status = 0x%x\n", wIndex, temp);
563 break;
Andiry Xua11496e2011-04-27 18:07:29 +0800564 case USB_PORT_FEAT_BH_PORT_RESET:
565 temp |= PORT_WR;
566 xhci_writel(xhci, temp, port_array[wIndex]);
567
568 temp = xhci_readl(xhci, port_array[wIndex]);
569 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700570 default:
571 goto error;
572 }
Sarah Sharp5308a912010-12-01 11:34:59 -0800573 /* unblock any posted writes */
574 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700575 break;
576 case ClearPortFeature:
577 if (!wIndex || wIndex > ports)
578 goto error;
579 wIndex--;
Sarah Sharp5308a912010-12-01 11:34:59 -0800580 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700581 if (temp == 0xffffffff) {
582 retval = -ENODEV;
583 break;
584 }
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800585 /* FIXME: What new port features do we need to support? */
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700586 temp = xhci_port_state_to_neutral(temp);
587 switch (wValue) {
Andiry Xube88fe42010-10-14 07:22:57 -0700588 case USB_PORT_FEAT_SUSPEND:
Sarah Sharp5308a912010-12-01 11:34:59 -0800589 temp = xhci_readl(xhci, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700590 xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
591 xhci_dbg(xhci, "PORTSC %04x\n", temp);
592 if (temp & PORT_RESET)
593 goto error;
594 if (temp & XDEV_U3) {
595 if ((temp & PORT_PE) == 0)
596 goto error;
597 if (DEV_SUPERSPEED(temp)) {
598 temp = xhci_port_state_to_neutral(temp);
599 temp &= ~PORT_PLS_MASK;
600 temp |= PORT_LINK_STROBE | XDEV_U0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800601 xhci_writel(xhci, temp,
602 port_array[wIndex]);
603 xhci_readl(xhci, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700604 } else {
605 temp = xhci_port_state_to_neutral(temp);
606 temp &= ~PORT_PLS_MASK;
607 temp |= PORT_LINK_STROBE | XDEV_RESUME;
Sarah Sharp5308a912010-12-01 11:34:59 -0800608 xhci_writel(xhci, temp,
609 port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700610
611 spin_unlock_irqrestore(&xhci->lock,
612 flags);
613 msleep(20);
614 spin_lock_irqsave(&xhci->lock, flags);
615
Sarah Sharp5308a912010-12-01 11:34:59 -0800616 temp = xhci_readl(xhci,
617 port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700618 temp = xhci_port_state_to_neutral(temp);
619 temp &= ~PORT_PLS_MASK;
620 temp |= PORT_LINK_STROBE | XDEV_U0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800621 xhci_writel(xhci, temp,
622 port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700623 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800624 bus_state->port_c_suspend |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700625 }
626
Sarah Sharp52336302010-12-16 10:49:09 -0800627 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
628 wIndex + 1);
Andiry Xube88fe42010-10-14 07:22:57 -0700629 if (!slot_id) {
630 xhci_dbg(xhci, "slot_id is zero\n");
631 goto error;
632 }
633 xhci_ring_device(xhci, slot_id);
634 break;
635 case USB_PORT_FEAT_C_SUSPEND:
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800636 bus_state->port_c_suspend &= ~(1 << wIndex);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700637 case USB_PORT_FEAT_C_RESET:
Andiry Xua11496e2011-04-27 18:07:29 +0800638 case USB_PORT_FEAT_C_BH_PORT_RESET:
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700639 case USB_PORT_FEAT_C_CONNECTION:
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700640 case USB_PORT_FEAT_C_OVER_CURRENT:
Sarah Sharp6219c0472009-12-09 15:59:11 -0800641 case USB_PORT_FEAT_C_ENABLE:
Sarah Sharp34fb5622009-12-09 15:59:08 -0800642 xhci_clear_port_change_bit(xhci, wValue, wIndex,
Sarah Sharp5308a912010-12-01 11:34:59 -0800643 port_array[wIndex], temp);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700644 break;
Sarah Sharp6219c0472009-12-09 15:59:11 -0800645 case USB_PORT_FEAT_ENABLE:
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800646 xhci_disable_port(hcd, xhci, wIndex,
Sarah Sharp5308a912010-12-01 11:34:59 -0800647 port_array[wIndex], temp);
Sarah Sharp6219c0472009-12-09 15:59:11 -0800648 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700649 default:
650 goto error;
651 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700652 break;
653 default:
654error:
655 /* "stall" on error */
656 retval = -EPIPE;
657 }
658 spin_unlock_irqrestore(&xhci->lock, flags);
659 return retval;
660}
661
662/*
663 * Returns 0 if the status hasn't changed, or the number of bytes in buf.
664 * Ports are 0-indexed from the HCD point of view,
665 * and 1-indexed from the USB core pointer of view.
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700666 *
667 * Note that the status change bits will be cleared as soon as a port status
668 * change event is generated, so we use the saved status from that event.
669 */
670int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
671{
672 unsigned long flags;
673 u32 temp, status;
Andiry Xu56192532010-10-14 07:23:00 -0700674 u32 mask;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700675 int i, retval;
676 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
677 int ports;
Matt Evans28ccd292011-03-29 13:40:46 +1100678 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800679 struct xhci_bus_state *bus_state;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700680
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800681 if (hcd->speed == HCD_USB3) {
682 ports = xhci->num_usb3_ports;
683 port_array = xhci->usb3_ports;
684 } else {
685 ports = xhci->num_usb2_ports;
686 port_array = xhci->usb2_ports;
Sarah Sharp5308a912010-12-01 11:34:59 -0800687 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800688 bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700689
690 /* Initial status is no changes */
William Gulland419a8e812010-05-12 10:20:34 -0700691 retval = (ports + 8) / 8;
692 memset(buf, 0, retval);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700693 status = 0;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700694
Andiry Xu56192532010-10-14 07:23:00 -0700695 mask = PORT_CSC | PORT_PEC | PORT_OCC;
696
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700697 spin_lock_irqsave(&xhci->lock, flags);
698 /* For each port, did anything change? If so, set that bit in buf. */
699 for (i = 0; i < ports; i++) {
Sarah Sharp5308a912010-12-01 11:34:59 -0800700 temp = xhci_readl(xhci, port_array[i]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700701 if (temp == 0xffffffff) {
702 retval = -ENODEV;
703 break;
704 }
Andiry Xu56192532010-10-14 07:23:00 -0700705 if ((temp & mask) != 0 ||
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800706 (bus_state->port_c_suspend & 1 << i) ||
707 (bus_state->resume_done[i] && time_after_eq(
708 jiffies, bus_state->resume_done[i]))) {
William Gulland419a8e812010-05-12 10:20:34 -0700709 buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700710 status = 1;
711 }
712 }
713 spin_unlock_irqrestore(&xhci->lock, flags);
714 return status ? retval : 0;
715}
Andiry Xu9777e3c2010-10-14 07:23:03 -0700716
717#ifdef CONFIG_PM
718
719int xhci_bus_suspend(struct usb_hcd *hcd)
720{
721 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Sarah Sharp518e8482010-12-15 11:56:29 -0800722 int max_ports, port_index;
Matt Evans28ccd292011-03-29 13:40:46 +1100723 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800724 struct xhci_bus_state *bus_state;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700725 unsigned long flags;
726
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800727 if (hcd->speed == HCD_USB3) {
728 max_ports = xhci->num_usb3_ports;
729 port_array = xhci->usb3_ports;
730 xhci_dbg(xhci, "suspend USB 3.0 root hub\n");
731 } else {
732 max_ports = xhci->num_usb2_ports;
733 port_array = xhci->usb2_ports;
734 xhci_dbg(xhci, "suspend USB 2.0 root hub\n");
Sarah Sharp5308a912010-12-01 11:34:59 -0800735 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800736 bus_state = &xhci->bus_state[hcd_index(hcd)];
Andiry Xu9777e3c2010-10-14 07:23:03 -0700737
738 spin_lock_irqsave(&xhci->lock, flags);
739
740 if (hcd->self.root_hub->do_remote_wakeup) {
Sarah Sharp518e8482010-12-15 11:56:29 -0800741 port_index = max_ports;
742 while (port_index--) {
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800743 if (bus_state->resume_done[port_index] != 0) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700744 spin_unlock_irqrestore(&xhci->lock, flags);
745 xhci_dbg(xhci, "suspend failed because "
746 "port %d is resuming\n",
Sarah Sharp518e8482010-12-15 11:56:29 -0800747 port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700748 return -EBUSY;
749 }
750 }
751 }
752
Sarah Sharp518e8482010-12-15 11:56:29 -0800753 port_index = max_ports;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800754 bus_state->bus_suspended = 0;
Sarah Sharp518e8482010-12-15 11:56:29 -0800755 while (port_index--) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700756 /* suspend the port if the port is not suspended */
Andiry Xu9777e3c2010-10-14 07:23:03 -0700757 u32 t1, t2;
758 int slot_id;
759
Sarah Sharp5308a912010-12-01 11:34:59 -0800760 t1 = xhci_readl(xhci, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700761 t2 = xhci_port_state_to_neutral(t1);
762
763 if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
Sarah Sharp518e8482010-12-15 11:56:29 -0800764 xhci_dbg(xhci, "port %d not suspended\n", port_index);
Sarah Sharp52336302010-12-16 10:49:09 -0800765 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
Sarah Sharp518e8482010-12-15 11:56:29 -0800766 port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700767 if (slot_id) {
768 spin_unlock_irqrestore(&xhci->lock, flags);
769 xhci_stop_device(xhci, slot_id, 1);
770 spin_lock_irqsave(&xhci->lock, flags);
771 }
772 t2 &= ~PORT_PLS_MASK;
773 t2 |= PORT_LINK_STROBE | XDEV_U3;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800774 set_bit(port_index, &bus_state->bus_suspended);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700775 }
776 if (hcd->self.root_hub->do_remote_wakeup) {
777 if (t1 & PORT_CONNECT) {
778 t2 |= PORT_WKOC_E | PORT_WKDISC_E;
779 t2 &= ~PORT_WKCONN_E;
780 } else {
781 t2 |= PORT_WKOC_E | PORT_WKCONN_E;
782 t2 &= ~PORT_WKDISC_E;
783 }
784 } else
785 t2 &= ~PORT_WAKE_BITS;
786
787 t1 = xhci_port_state_to_neutral(t1);
788 if (t1 != t2)
Sarah Sharp5308a912010-12-01 11:34:59 -0800789 xhci_writel(xhci, t2, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700790
791 if (DEV_HIGHSPEED(t1)) {
792 /* enable remote wake up for USB 2.0 */
Matt Evans28ccd292011-03-29 13:40:46 +1100793 __le32 __iomem *addr;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700794 u32 tmp;
795
Sarah Sharp5308a912010-12-01 11:34:59 -0800796 /* Add one to the port status register address to get
797 * the port power control register address.
798 */
799 addr = port_array[port_index] + 1;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700800 tmp = xhci_readl(xhci, addr);
801 tmp |= PORT_RWE;
802 xhci_writel(xhci, tmp, addr);
803 }
804 }
805 hcd->state = HC_STATE_SUSPENDED;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800806 bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700807 spin_unlock_irqrestore(&xhci->lock, flags);
808 return 0;
809}
810
811int xhci_bus_resume(struct usb_hcd *hcd)
812{
813 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Sarah Sharp518e8482010-12-15 11:56:29 -0800814 int max_ports, port_index;
Matt Evans28ccd292011-03-29 13:40:46 +1100815 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800816 struct xhci_bus_state *bus_state;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700817 u32 temp;
818 unsigned long flags;
819
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800820 if (hcd->speed == HCD_USB3) {
821 max_ports = xhci->num_usb3_ports;
822 port_array = xhci->usb3_ports;
823 xhci_dbg(xhci, "resume USB 3.0 root hub\n");
824 } else {
825 max_ports = xhci->num_usb2_ports;
826 port_array = xhci->usb2_ports;
827 xhci_dbg(xhci, "resume USB 2.0 root hub\n");
Sarah Sharp5308a912010-12-01 11:34:59 -0800828 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800829 bus_state = &xhci->bus_state[hcd_index(hcd)];
Andiry Xu9777e3c2010-10-14 07:23:03 -0700830
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800831 if (time_before(jiffies, bus_state->next_statechange))
Andiry Xu9777e3c2010-10-14 07:23:03 -0700832 msleep(5);
833
834 spin_lock_irqsave(&xhci->lock, flags);
835 if (!HCD_HW_ACCESSIBLE(hcd)) {
836 spin_unlock_irqrestore(&xhci->lock, flags);
837 return -ESHUTDOWN;
838 }
839
840 /* delay the irqs */
841 temp = xhci_readl(xhci, &xhci->op_regs->command);
842 temp &= ~CMD_EIE;
843 xhci_writel(xhci, temp, &xhci->op_regs->command);
844
Sarah Sharp518e8482010-12-15 11:56:29 -0800845 port_index = max_ports;
846 while (port_index--) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700847 /* Check whether need resume ports. If needed
848 resume port and disable remote wakeup */
Andiry Xu9777e3c2010-10-14 07:23:03 -0700849 u32 temp;
850 int slot_id;
851
Sarah Sharp5308a912010-12-01 11:34:59 -0800852 temp = xhci_readl(xhci, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700853 if (DEV_SUPERSPEED(temp))
854 temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
855 else
856 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800857 if (test_bit(port_index, &bus_state->bus_suspended) &&
Andiry Xu9777e3c2010-10-14 07:23:03 -0700858 (temp & PORT_PLS_MASK)) {
859 if (DEV_SUPERSPEED(temp)) {
860 temp = xhci_port_state_to_neutral(temp);
861 temp &= ~PORT_PLS_MASK;
862 temp |= PORT_LINK_STROBE | XDEV_U0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800863 xhci_writel(xhci, temp, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700864 } else {
865 temp = xhci_port_state_to_neutral(temp);
866 temp &= ~PORT_PLS_MASK;
867 temp |= PORT_LINK_STROBE | XDEV_RESUME;
Sarah Sharp5308a912010-12-01 11:34:59 -0800868 xhci_writel(xhci, temp, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700869
870 spin_unlock_irqrestore(&xhci->lock, flags);
871 msleep(20);
872 spin_lock_irqsave(&xhci->lock, flags);
873
Sarah Sharp5308a912010-12-01 11:34:59 -0800874 temp = xhci_readl(xhci, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700875 temp = xhci_port_state_to_neutral(temp);
876 temp &= ~PORT_PLS_MASK;
877 temp |= PORT_LINK_STROBE | XDEV_U0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800878 xhci_writel(xhci, temp, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700879 }
Sarah Sharp52336302010-12-16 10:49:09 -0800880 slot_id = xhci_find_slot_id_by_port(hcd,
881 xhci, port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700882 if (slot_id)
883 xhci_ring_device(xhci, slot_id);
884 } else
Sarah Sharp5308a912010-12-01 11:34:59 -0800885 xhci_writel(xhci, temp, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700886
887 if (DEV_HIGHSPEED(temp)) {
888 /* disable remote wake up for USB 2.0 */
Matt Evans28ccd292011-03-29 13:40:46 +1100889 __le32 __iomem *addr;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700890 u32 tmp;
891
Sarah Sharp5308a912010-12-01 11:34:59 -0800892 /* Add one to the port status register address to get
893 * the port power control register address.
894 */
895 addr = port_array[port_index] + 1;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700896 tmp = xhci_readl(xhci, addr);
897 tmp &= ~PORT_RWE;
898 xhci_writel(xhci, tmp, addr);
899 }
900 }
901
902 (void) xhci_readl(xhci, &xhci->op_regs->command);
903
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800904 bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700905 /* re-enable irqs */
906 temp = xhci_readl(xhci, &xhci->op_regs->command);
907 temp |= CMD_EIE;
908 xhci_writel(xhci, temp, &xhci->op_regs->command);
909 temp = xhci_readl(xhci, &xhci->op_regs->command);
910
911 spin_unlock_irqrestore(&xhci->lock, flags);
912 return 0;
913}
914
Sarah Sharp436a3892010-10-15 14:59:15 -0700915#endif /* CONFIG_PM */