blob: ef03c18a0128b4b482f4ff897df21d6d455b45af [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))
Sarah Sharpfe301822011-09-02 11:05:41 -0700235 && xhci->devs[i]->fake_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 Sharp6219c042009-12-09 15:59:11 -0800318{
Sarah Sharp6dd0a3a2010-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 Sharp6dd0a3a2010-11-16 15:58:52 -0800321 xhci_dbg(xhci, "Ignoring request to disable "
322 "SuperSpeed port.\n");
323 return;
324 }
325
Sarah Sharp6219c042009-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 Sharp6219c042009-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;
Andiry Xu85387c02011-04-27 18:07:35 +0800364 case USB_PORT_FEAT_C_PORT_LINK_STATE:
365 status = PORT_PLC;
366 port_change_bit = "link state";
367 break;
Sarah Sharp34fb5622009-12-09 15:59:08 -0800368 default:
369 /* Should never happen */
370 return;
371 }
372 /* Change bits are all write 1 to clear */
373 xhci_writel(xhci, port_status | status, addr);
374 port_status = xhci_readl(xhci, addr);
375 xhci_dbg(xhci, "clear port %s change, actual port %d status = 0x%x\n",
376 port_change_bit, wIndex, port_status);
377}
378
huajun lia0885922011-05-03 21:11:00 +0800379static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
380{
381 int max_ports;
382 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
383
384 if (hcd->speed == HCD_USB3) {
385 max_ports = xhci->num_usb3_ports;
386 *port_array = xhci->usb3_ports;
387 } else {
388 max_ports = xhci->num_usb2_ports;
389 *port_array = xhci->usb2_ports;
390 }
391
392 return max_ports;
393}
394
Andiry Xuc9682df2011-09-23 14:19:48 -0700395void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
396 int port_id, u32 link_state)
397{
398 u32 temp;
399
400 temp = xhci_readl(xhci, port_array[port_id]);
401 temp = xhci_port_state_to_neutral(temp);
402 temp &= ~PORT_PLS_MASK;
403 temp |= PORT_LINK_STROBE | link_state;
404 xhci_writel(xhci, temp, port_array[port_id]);
405}
406
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700407int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
408 u16 wIndex, char *buf, u16 wLength)
409{
410 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
huajun lia0885922011-05-03 21:11:00 +0800411 int max_ports;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700412 unsigned long flags;
Andiry Xuc9682df2011-09-23 14:19:48 -0700413 u32 temp, status;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700414 int retval = 0;
Matt Evans28ccd292011-03-29 13:40:46 +1100415 __le32 __iomem **port_array;
Andiry Xube88fe42010-10-14 07:22:57 -0700416 int slot_id;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800417 struct xhci_bus_state *bus_state;
Andiry Xu2c441782011-04-27 18:07:39 +0800418 u16 link_state = 0;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700419
huajun lia0885922011-05-03 21:11:00 +0800420 max_ports = xhci_get_ports(hcd, &port_array);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800421 bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700422
423 spin_lock_irqsave(&xhci->lock, flags);
424 switch (typeReq) {
425 case GetHubStatus:
426 /* No power source, over-current reported per port */
427 memset(buf, 0, 4);
428 break;
429 case GetHubDescriptor:
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800430 /* Check to make sure userspace is asking for the USB 3.0 hub
431 * descriptor for the USB 3.0 roothub. If not, we stall the
432 * endpoint, like external hubs do.
433 */
434 if (hcd->speed == HCD_USB3 &&
435 (wLength < USB_DT_SS_HUB_SIZE ||
436 wValue != (USB_DT_SS_HUB << 8))) {
437 xhci_dbg(xhci, "Wrong hub descriptor type for "
438 "USB 3.0 roothub.\n");
439 goto error;
440 }
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800441 xhci_hub_descriptor(hcd, xhci,
442 (struct usb_hub_descriptor *) buf);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700443 break;
444 case GetPortStatus:
huajun lia0885922011-05-03 21:11:00 +0800445 if (!wIndex || wIndex > max_ports)
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700446 goto error;
447 wIndex--;
448 status = 0;
Sarah Sharp5308a912010-12-01 11:34:59 -0800449 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700450 if (temp == 0xffffffff) {
451 retval = -ENODEV;
452 break;
453 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700454 xhci_dbg(xhci, "get port status, actual port %d status = 0x%x\n", wIndex, temp);
455
456 /* wPortChange bits */
457 if (temp & PORT_CSC)
Alan Stern749da5f2010-03-04 17:05:08 -0500458 status |= USB_PORT_STAT_C_CONNECTION << 16;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700459 if (temp & PORT_PEC)
Alan Stern749da5f2010-03-04 17:05:08 -0500460 status |= USB_PORT_STAT_C_ENABLE << 16;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700461 if ((temp & PORT_OCC))
Alan Stern749da5f2010-03-04 17:05:08 -0500462 status |= USB_PORT_STAT_C_OVERCURRENT << 16;
Andiry Xu0ed9a572011-04-27 18:07:43 +0800463 if ((temp & PORT_RC))
464 status |= USB_PORT_STAT_C_RESET << 16;
465 /* USB3.0 only */
466 if (hcd->speed == HCD_USB3) {
467 if ((temp & PORT_PLC))
468 status |= USB_PORT_STAT_C_LINK_STATE << 16;
469 if ((temp & PORT_WRC))
470 status |= USB_PORT_STAT_C_BH_RESET << 16;
471 }
472
473 if (hcd->speed != HCD_USB3) {
474 if ((temp & PORT_PLS_MASK) == XDEV_U3
475 && (temp & PORT_POWER))
476 status |= USB_PORT_STAT_SUSPEND;
477 }
Andiry Xu8a8ff2f2011-08-03 16:46:49 +0800478 if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&
479 !DEV_SUPERSPEED(temp)) {
Andiry Xu56192532010-10-14 07:23:00 -0700480 if ((temp & PORT_RESET) || !(temp & PORT_PE))
481 goto error;
Andiry Xu8a8ff2f2011-08-03 16:46:49 +0800482 if (time_after_eq(jiffies,
483 bus_state->resume_done[wIndex])) {
Andiry Xu56192532010-10-14 07:23:00 -0700484 xhci_dbg(xhci, "Resume USB2 port %d\n",
485 wIndex + 1);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800486 bus_state->resume_done[wIndex] = 0;
Andiry Xuc9682df2011-09-23 14:19:48 -0700487 xhci_set_link_state(xhci, port_array, wIndex,
488 XDEV_U0);
Andiry Xu56192532010-10-14 07:23:00 -0700489 xhci_dbg(xhci, "set port %d resume\n",
490 wIndex + 1);
Sarah Sharp52336302010-12-16 10:49:09 -0800491 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
Andiry Xu56192532010-10-14 07:23:00 -0700492 wIndex + 1);
493 if (!slot_id) {
494 xhci_dbg(xhci, "slot_id is zero\n");
495 goto error;
496 }
497 xhci_ring_device(xhci, slot_id);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800498 bus_state->port_c_suspend |= 1 << wIndex;
499 bus_state->suspended_ports &= ~(1 << wIndex);
Andiry Xu8a8ff2f2011-08-03 16:46:49 +0800500 } else {
501 /*
502 * The resume has been signaling for less than
503 * 20ms. Report the port status as SUSPEND,
504 * let the usbcore check port status again
505 * and clear resume signaling later.
506 */
507 status |= USB_PORT_STAT_SUSPEND;
Andiry Xu56192532010-10-14 07:23:00 -0700508 }
509 }
Andiry Xube88fe42010-10-14 07:22:57 -0700510 if ((temp & PORT_PLS_MASK) == XDEV_U0
511 && (temp & PORT_POWER)
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800512 && (bus_state->suspended_ports & (1 << wIndex))) {
513 bus_state->suspended_ports &= ~(1 << wIndex);
Andiry Xua7114232011-04-27 18:07:50 +0800514 if (hcd->speed != HCD_USB3)
515 bus_state->port_c_suspend |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700516 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700517 if (temp & PORT_CONNECT) {
Alan Stern749da5f2010-03-04 17:05:08 -0500518 status |= USB_PORT_STAT_CONNECTION;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700519 status |= xhci_port_speed(temp);
520 }
521 if (temp & PORT_PE)
Alan Stern749da5f2010-03-04 17:05:08 -0500522 status |= USB_PORT_STAT_ENABLE;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700523 if (temp & PORT_OC)
Alan Stern749da5f2010-03-04 17:05:08 -0500524 status |= USB_PORT_STAT_OVERCURRENT;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700525 if (temp & PORT_RESET)
Alan Stern749da5f2010-03-04 17:05:08 -0500526 status |= USB_PORT_STAT_RESET;
Andiry Xu0ed9a572011-04-27 18:07:43 +0800527 if (temp & PORT_POWER) {
528 if (hcd->speed == HCD_USB3)
529 status |= USB_SS_PORT_STAT_POWER;
530 else
531 status |= USB_PORT_STAT_POWER;
532 }
533 /* Port Link State */
534 if (hcd->speed == HCD_USB3) {
535 /* resume state is a xHCI internal state.
536 * Do not report it to usb core.
537 */
538 if ((temp & PORT_PLS_MASK) != XDEV_RESUME)
539 status |= (temp & PORT_PLS_MASK);
540 }
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800541 if (bus_state->port_c_suspend & (1 << wIndex))
Andiry Xube88fe42010-10-14 07:22:57 -0700542 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700543 xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
544 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
545 break;
546 case SetPortFeature:
Andiry Xu2c441782011-04-27 18:07:39 +0800547 if (wValue == USB_PORT_FEAT_LINK_STATE)
548 link_state = (wIndex & 0xff00) >> 3;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700549 wIndex &= 0xff;
huajun lia0885922011-05-03 21:11:00 +0800550 if (!wIndex || wIndex > max_ports)
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700551 goto error;
552 wIndex--;
Sarah Sharp5308a912010-12-01 11:34:59 -0800553 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700554 if (temp == 0xffffffff) {
555 retval = -ENODEV;
556 break;
557 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700558 temp = xhci_port_state_to_neutral(temp);
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800559 /* FIXME: What new port features do we need to support? */
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700560 switch (wValue) {
Andiry Xube88fe42010-10-14 07:22:57 -0700561 case USB_PORT_FEAT_SUSPEND:
Sarah Sharp5308a912010-12-01 11:34:59 -0800562 temp = xhci_readl(xhci, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700563 /* In spec software should not attempt to suspend
564 * a port unless the port reports that it is in the
565 * enabled (PED = ‘1’,PLS < ‘3’) state.
566 */
567 if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
568 || (temp & PORT_PLS_MASK) >= XDEV_U3) {
569 xhci_warn(xhci, "USB core suspending device "
570 "not in U0/U1/U2.\n");
571 goto error;
572 }
573
Sarah Sharp52336302010-12-16 10:49:09 -0800574 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
575 wIndex + 1);
Andiry Xube88fe42010-10-14 07:22:57 -0700576 if (!slot_id) {
577 xhci_warn(xhci, "slot_id is zero\n");
578 goto error;
579 }
580 /* unlock to execute stop endpoint commands */
581 spin_unlock_irqrestore(&xhci->lock, flags);
582 xhci_stop_device(xhci, slot_id, 1);
583 spin_lock_irqsave(&xhci->lock, flags);
584
Andiry Xuc9682df2011-09-23 14:19:48 -0700585 xhci_set_link_state(xhci, port_array, wIndex, XDEV_U3);
Andiry Xube88fe42010-10-14 07:22:57 -0700586
587 spin_unlock_irqrestore(&xhci->lock, flags);
588 msleep(10); /* wait device to enter */
589 spin_lock_irqsave(&xhci->lock, flags);
590
Sarah Sharp5308a912010-12-01 11:34:59 -0800591 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800592 bus_state->suspended_ports |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700593 break;
Andiry Xu2c441782011-04-27 18:07:39 +0800594 case USB_PORT_FEAT_LINK_STATE:
595 temp = xhci_readl(xhci, port_array[wIndex]);
596 /* Software should not attempt to set
597 * port link state above '5' (Rx.Detect) and the port
598 * must be enabled.
599 */
600 if ((temp & PORT_PE) == 0 ||
601 (link_state > USB_SS_PORT_LS_RX_DETECT)) {
602 xhci_warn(xhci, "Cannot set link state.\n");
603 goto error;
604 }
605
606 if (link_state == USB_SS_PORT_LS_U3) {
607 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
608 wIndex + 1);
609 if (slot_id) {
610 /* unlock to execute stop endpoint
611 * commands */
612 spin_unlock_irqrestore(&xhci->lock,
613 flags);
614 xhci_stop_device(xhci, slot_id, 1);
615 spin_lock_irqsave(&xhci->lock, flags);
616 }
617 }
618
Andiry Xuc9682df2011-09-23 14:19:48 -0700619 xhci_set_link_state(xhci, port_array, wIndex,
620 link_state);
Andiry Xu2c441782011-04-27 18:07:39 +0800621
622 spin_unlock_irqrestore(&xhci->lock, flags);
623 msleep(20); /* wait device to enter */
624 spin_lock_irqsave(&xhci->lock, flags);
625
626 temp = xhci_readl(xhci, port_array[wIndex]);
627 if (link_state == USB_SS_PORT_LS_U3)
628 bus_state->suspended_ports |= 1 << wIndex;
629 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700630 case USB_PORT_FEAT_POWER:
631 /*
632 * Turn on ports, even if there isn't per-port switching.
633 * HC will report connect events even before this is set.
634 * However, khubd will ignore the roothub events until
635 * the roothub is registered.
636 */
Sarah Sharp5308a912010-12-01 11:34:59 -0800637 xhci_writel(xhci, temp | PORT_POWER,
638 port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700639
Sarah Sharp5308a912010-12-01 11:34:59 -0800640 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700641 xhci_dbg(xhci, "set port power, actual port %d status = 0x%x\n", wIndex, temp);
642 break;
643 case USB_PORT_FEAT_RESET:
644 temp = (temp | PORT_RESET);
Sarah Sharp5308a912010-12-01 11:34:59 -0800645 xhci_writel(xhci, temp, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700646
Sarah Sharp5308a912010-12-01 11:34:59 -0800647 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700648 xhci_dbg(xhci, "set port reset, actual port %d status = 0x%x\n", wIndex, temp);
649 break;
Andiry Xua11496e2011-04-27 18:07:29 +0800650 case USB_PORT_FEAT_BH_PORT_RESET:
651 temp |= PORT_WR;
652 xhci_writel(xhci, temp, port_array[wIndex]);
653
654 temp = xhci_readl(xhci, port_array[wIndex]);
655 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700656 default:
657 goto error;
658 }
Sarah Sharp5308a912010-12-01 11:34:59 -0800659 /* unblock any posted writes */
660 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700661 break;
662 case ClearPortFeature:
huajun lia0885922011-05-03 21:11:00 +0800663 if (!wIndex || wIndex > max_ports)
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700664 goto error;
665 wIndex--;
Sarah Sharp5308a912010-12-01 11:34:59 -0800666 temp = xhci_readl(xhci, port_array[wIndex]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700667 if (temp == 0xffffffff) {
668 retval = -ENODEV;
669 break;
670 }
Sarah Sharp4bbb0ac2010-11-29 16:14:37 -0800671 /* FIXME: What new port features do we need to support? */
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700672 temp = xhci_port_state_to_neutral(temp);
673 switch (wValue) {
Andiry Xube88fe42010-10-14 07:22:57 -0700674 case USB_PORT_FEAT_SUSPEND:
Sarah Sharp5308a912010-12-01 11:34:59 -0800675 temp = xhci_readl(xhci, port_array[wIndex]);
Andiry Xube88fe42010-10-14 07:22:57 -0700676 xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
677 xhci_dbg(xhci, "PORTSC %04x\n", temp);
678 if (temp & PORT_RESET)
679 goto error;
Andiry Xu5ac04bf2011-08-03 16:46:48 +0800680 if ((temp & PORT_PLS_MASK) == XDEV_U3) {
Andiry Xube88fe42010-10-14 07:22:57 -0700681 if ((temp & PORT_PE) == 0)
682 goto error;
Andiry Xube88fe42010-10-14 07:22:57 -0700683
Andiry Xuc9682df2011-09-23 14:19:48 -0700684 xhci_set_link_state(xhci, port_array, wIndex,
685 XDEV_RESUME);
686 spin_unlock_irqrestore(&xhci->lock, flags);
Andiry Xua7114232011-04-27 18:07:50 +0800687 msleep(20);
688 spin_lock_irqsave(&xhci->lock, flags);
Andiry Xuc9682df2011-09-23 14:19:48 -0700689 xhci_set_link_state(xhci, port_array, wIndex,
690 XDEV_U0);
Andiry Xube88fe42010-10-14 07:22:57 -0700691 }
Andiry Xua7114232011-04-27 18:07:50 +0800692 bus_state->port_c_suspend |= 1 << wIndex;
Andiry Xube88fe42010-10-14 07:22:57 -0700693
Sarah Sharp52336302010-12-16 10:49:09 -0800694 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
695 wIndex + 1);
Andiry Xube88fe42010-10-14 07:22:57 -0700696 if (!slot_id) {
697 xhci_dbg(xhci, "slot_id is zero\n");
698 goto error;
699 }
700 xhci_ring_device(xhci, slot_id);
701 break;
702 case USB_PORT_FEAT_C_SUSPEND:
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800703 bus_state->port_c_suspend &= ~(1 << wIndex);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700704 case USB_PORT_FEAT_C_RESET:
Andiry Xua11496e2011-04-27 18:07:29 +0800705 case USB_PORT_FEAT_C_BH_PORT_RESET:
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700706 case USB_PORT_FEAT_C_CONNECTION:
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700707 case USB_PORT_FEAT_C_OVER_CURRENT:
Sarah Sharp6219c042009-12-09 15:59:11 -0800708 case USB_PORT_FEAT_C_ENABLE:
Andiry Xu85387c02011-04-27 18:07:35 +0800709 case USB_PORT_FEAT_C_PORT_LINK_STATE:
Sarah Sharp34fb5622009-12-09 15:59:08 -0800710 xhci_clear_port_change_bit(xhci, wValue, wIndex,
Sarah Sharp5308a912010-12-01 11:34:59 -0800711 port_array[wIndex], temp);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700712 break;
Sarah Sharp6219c042009-12-09 15:59:11 -0800713 case USB_PORT_FEAT_ENABLE:
Sarah Sharpf6ff0ac2010-12-16 11:21:10 -0800714 xhci_disable_port(hcd, xhci, wIndex,
Sarah Sharp5308a912010-12-01 11:34:59 -0800715 port_array[wIndex], temp);
Sarah Sharp6219c042009-12-09 15:59:11 -0800716 break;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700717 default:
718 goto error;
719 }
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700720 break;
721 default:
722error:
723 /* "stall" on error */
724 retval = -EPIPE;
725 }
726 spin_unlock_irqrestore(&xhci->lock, flags);
727 return retval;
728}
729
730/*
731 * Returns 0 if the status hasn't changed, or the number of bytes in buf.
732 * Ports are 0-indexed from the HCD point of view,
733 * and 1-indexed from the USB core pointer of view.
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700734 *
735 * Note that the status change bits will be cleared as soon as a port status
736 * change event is generated, so we use the saved status from that event.
737 */
738int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
739{
740 unsigned long flags;
741 u32 temp, status;
Andiry Xu56192532010-10-14 07:23:00 -0700742 u32 mask;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700743 int i, retval;
744 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
huajun lia0885922011-05-03 21:11:00 +0800745 int max_ports;
Matt Evans28ccd292011-03-29 13:40:46 +1100746 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800747 struct xhci_bus_state *bus_state;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700748
huajun lia0885922011-05-03 21:11:00 +0800749 max_ports = xhci_get_ports(hcd, &port_array);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800750 bus_state = &xhci->bus_state[hcd_index(hcd)];
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700751
752 /* Initial status is no changes */
huajun lia0885922011-05-03 21:11:00 +0800753 retval = (max_ports + 8) / 8;
William Gulland419a8e812010-05-12 10:20:34 -0700754 memset(buf, 0, retval);
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700755 status = 0;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700756
Andiry Xua7114232011-04-27 18:07:50 +0800757 mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
Andiry Xu56192532010-10-14 07:23:00 -0700758
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700759 spin_lock_irqsave(&xhci->lock, flags);
760 /* For each port, did anything change? If so, set that bit in buf. */
huajun lia0885922011-05-03 21:11:00 +0800761 for (i = 0; i < max_ports; i++) {
Sarah Sharp5308a912010-12-01 11:34:59 -0800762 temp = xhci_readl(xhci, port_array[i]);
Sarah Sharpf9de8152010-10-29 14:37:23 -0700763 if (temp == 0xffffffff) {
764 retval = -ENODEV;
765 break;
766 }
Andiry Xu56192532010-10-14 07:23:00 -0700767 if ((temp & mask) != 0 ||
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800768 (bus_state->port_c_suspend & 1 << i) ||
769 (bus_state->resume_done[i] && time_after_eq(
770 jiffies, bus_state->resume_done[i]))) {
William Gulland419a8e812010-05-12 10:20:34 -0700771 buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
Sarah Sharp0f2a7932009-04-27 19:57:12 -0700772 status = 1;
773 }
774 }
775 spin_unlock_irqrestore(&xhci->lock, flags);
776 return status ? retval : 0;
777}
Andiry Xu9777e3c2010-10-14 07:23:03 -0700778
779#ifdef CONFIG_PM
780
781int xhci_bus_suspend(struct usb_hcd *hcd)
782{
783 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Sarah Sharp518e8482010-12-15 11:56:29 -0800784 int max_ports, port_index;
Matt Evans28ccd292011-03-29 13:40:46 +1100785 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800786 struct xhci_bus_state *bus_state;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700787 unsigned long flags;
788
huajun lia0885922011-05-03 21:11:00 +0800789 max_ports = xhci_get_ports(hcd, &port_array);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800790 bus_state = &xhci->bus_state[hcd_index(hcd)];
Andiry Xu9777e3c2010-10-14 07:23:03 -0700791
792 spin_lock_irqsave(&xhci->lock, flags);
793
794 if (hcd->self.root_hub->do_remote_wakeup) {
Sarah Sharp518e8482010-12-15 11:56:29 -0800795 port_index = max_ports;
796 while (port_index--) {
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800797 if (bus_state->resume_done[port_index] != 0) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700798 spin_unlock_irqrestore(&xhci->lock, flags);
799 xhci_dbg(xhci, "suspend failed because "
800 "port %d is resuming\n",
Sarah Sharp518e8482010-12-15 11:56:29 -0800801 port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700802 return -EBUSY;
803 }
804 }
805 }
806
Sarah Sharp518e8482010-12-15 11:56:29 -0800807 port_index = max_ports;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800808 bus_state->bus_suspended = 0;
Sarah Sharp518e8482010-12-15 11:56:29 -0800809 while (port_index--) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700810 /* suspend the port if the port is not suspended */
Andiry Xu9777e3c2010-10-14 07:23:03 -0700811 u32 t1, t2;
812 int slot_id;
813
Sarah Sharp5308a912010-12-01 11:34:59 -0800814 t1 = xhci_readl(xhci, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700815 t2 = xhci_port_state_to_neutral(t1);
816
817 if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
Sarah Sharp518e8482010-12-15 11:56:29 -0800818 xhci_dbg(xhci, "port %d not suspended\n", port_index);
Sarah Sharp52336302010-12-16 10:49:09 -0800819 slot_id = xhci_find_slot_id_by_port(hcd, xhci,
Sarah Sharp518e8482010-12-15 11:56:29 -0800820 port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700821 if (slot_id) {
822 spin_unlock_irqrestore(&xhci->lock, flags);
823 xhci_stop_device(xhci, slot_id, 1);
824 spin_lock_irqsave(&xhci->lock, flags);
825 }
826 t2 &= ~PORT_PLS_MASK;
827 t2 |= PORT_LINK_STROBE | XDEV_U3;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800828 set_bit(port_index, &bus_state->bus_suspended);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700829 }
830 if (hcd->self.root_hub->do_remote_wakeup) {
831 if (t1 & PORT_CONNECT) {
832 t2 |= PORT_WKOC_E | PORT_WKDISC_E;
833 t2 &= ~PORT_WKCONN_E;
834 } else {
835 t2 |= PORT_WKOC_E | PORT_WKCONN_E;
836 t2 &= ~PORT_WKDISC_E;
837 }
838 } else
839 t2 &= ~PORT_WAKE_BITS;
840
841 t1 = xhci_port_state_to_neutral(t1);
842 if (t1 != t2)
Sarah Sharp5308a912010-12-01 11:34:59 -0800843 xhci_writel(xhci, t2, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700844
Andiry Xu4f0871a2011-04-19 17:17:39 +0800845 if (hcd->speed != HCD_USB3) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700846 /* enable remote wake up for USB 2.0 */
Matt Evans28ccd292011-03-29 13:40:46 +1100847 __le32 __iomem *addr;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700848 u32 tmp;
849
Sarah Sharp5308a912010-12-01 11:34:59 -0800850 /* Add one to the port status register address to get
851 * the port power control register address.
852 */
853 addr = port_array[port_index] + 1;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700854 tmp = xhci_readl(xhci, addr);
855 tmp |= PORT_RWE;
856 xhci_writel(xhci, tmp, addr);
857 }
858 }
859 hcd->state = HC_STATE_SUSPENDED;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800860 bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700861 spin_unlock_irqrestore(&xhci->lock, flags);
862 return 0;
863}
864
865int xhci_bus_resume(struct usb_hcd *hcd)
866{
867 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Sarah Sharp518e8482010-12-15 11:56:29 -0800868 int max_ports, port_index;
Matt Evans28ccd292011-03-29 13:40:46 +1100869 __le32 __iomem **port_array;
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800870 struct xhci_bus_state *bus_state;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700871 u32 temp;
872 unsigned long flags;
873
huajun lia0885922011-05-03 21:11:00 +0800874 max_ports = xhci_get_ports(hcd, &port_array);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800875 bus_state = &xhci->bus_state[hcd_index(hcd)];
Andiry Xu9777e3c2010-10-14 07:23:03 -0700876
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800877 if (time_before(jiffies, bus_state->next_statechange))
Andiry Xu9777e3c2010-10-14 07:23:03 -0700878 msleep(5);
879
880 spin_lock_irqsave(&xhci->lock, flags);
881 if (!HCD_HW_ACCESSIBLE(hcd)) {
882 spin_unlock_irqrestore(&xhci->lock, flags);
883 return -ESHUTDOWN;
884 }
885
886 /* delay the irqs */
887 temp = xhci_readl(xhci, &xhci->op_regs->command);
888 temp &= ~CMD_EIE;
889 xhci_writel(xhci, temp, &xhci->op_regs->command);
890
Sarah Sharp518e8482010-12-15 11:56:29 -0800891 port_index = max_ports;
892 while (port_index--) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700893 /* Check whether need resume ports. If needed
894 resume port and disable remote wakeup */
Andiry Xu9777e3c2010-10-14 07:23:03 -0700895 u32 temp;
896 int slot_id;
897
Sarah Sharp5308a912010-12-01 11:34:59 -0800898 temp = xhci_readl(xhci, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700899 if (DEV_SUPERSPEED(temp))
900 temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
901 else
902 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800903 if (test_bit(port_index, &bus_state->bus_suspended) &&
Andiry Xu9777e3c2010-10-14 07:23:03 -0700904 (temp & PORT_PLS_MASK)) {
905 if (DEV_SUPERSPEED(temp)) {
Andiry Xuc9682df2011-09-23 14:19:48 -0700906 xhci_set_link_state(xhci, port_array,
907 port_index, XDEV_U0);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700908 } else {
Andiry Xuc9682df2011-09-23 14:19:48 -0700909 xhci_set_link_state(xhci, port_array,
910 port_index, XDEV_RESUME);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700911
912 spin_unlock_irqrestore(&xhci->lock, flags);
913 msleep(20);
914 spin_lock_irqsave(&xhci->lock, flags);
915
Andiry Xuc9682df2011-09-23 14:19:48 -0700916 xhci_set_link_state(xhci, port_array,
917 port_index, XDEV_U0);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700918 }
Andiry Xu4f0871a2011-04-19 17:17:39 +0800919 /* wait for the port to enter U0 and report port link
920 * state change.
921 */
922 spin_unlock_irqrestore(&xhci->lock, flags);
923 msleep(20);
924 spin_lock_irqsave(&xhci->lock, flags);
925
926 /* Clear PLC */
927 temp = xhci_readl(xhci, port_array[port_index]);
928 if (temp & PORT_PLC) {
929 temp = xhci_port_state_to_neutral(temp);
930 temp |= PORT_PLC;
931 xhci_writel(xhci, temp, port_array[port_index]);
932 }
933
Sarah Sharp52336302010-12-16 10:49:09 -0800934 slot_id = xhci_find_slot_id_by_port(hcd,
935 xhci, port_index + 1);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700936 if (slot_id)
937 xhci_ring_device(xhci, slot_id);
938 } else
Sarah Sharp5308a912010-12-01 11:34:59 -0800939 xhci_writel(xhci, temp, port_array[port_index]);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700940
Andiry Xu4f0871a2011-04-19 17:17:39 +0800941 if (hcd->speed != HCD_USB3) {
Andiry Xu9777e3c2010-10-14 07:23:03 -0700942 /* disable remote wake up for USB 2.0 */
Matt Evans28ccd292011-03-29 13:40:46 +1100943 __le32 __iomem *addr;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700944 u32 tmp;
945
Sarah Sharp5308a912010-12-01 11:34:59 -0800946 /* Add one to the port status register address to get
947 * the port power control register address.
948 */
949 addr = port_array[port_index] + 1;
Andiry Xu9777e3c2010-10-14 07:23:03 -0700950 tmp = xhci_readl(xhci, addr);
951 tmp &= ~PORT_RWE;
952 xhci_writel(xhci, tmp, addr);
953 }
954 }
955
956 (void) xhci_readl(xhci, &xhci->op_regs->command);
957
Sarah Sharp20b67cf2010-12-15 12:47:14 -0800958 bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
Andiry Xu9777e3c2010-10-14 07:23:03 -0700959 /* re-enable irqs */
960 temp = xhci_readl(xhci, &xhci->op_regs->command);
961 temp |= CMD_EIE;
962 xhci_writel(xhci, temp, &xhci->op_regs->command);
963 temp = xhci_readl(xhci, &xhci->op_regs->command);
964
965 spin_unlock_irqrestore(&xhci->lock, flags);
966 return 0;
967}
968
Sarah Sharp436a3892010-10-15 14:59:15 -0700969#endif /* CONFIG_PM */