source: src/linux/universal/linux-4.9/drivers/usb/host/xhci-hub.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 3 months ago

kernel update

File size: 43.9 KB
Line 
1/*
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
24#include <linux/slab.h>
25#include <asm/unaligned.h>
26
27#include "xhci.h"
28#include "xhci-trace.h"
29
30#ifdef CONFIG_BCM47XX
31extern int usb2mode;
32#endif
33
34#define PORT_WAKE_BITS  (PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E)
35#define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
36                         PORT_RC | PORT_PLC | PORT_PE)
37
38/* USB 3 BOS descriptor and a capability descriptors, combined.
39 * Fields will be adjusted and added later in xhci_create_usb3_bos_desc()
40 */
41static u8 usb_bos_descriptor [] = {
42        USB_DT_BOS_SIZE,                /*  __u8 bLength, 5 bytes */
43        USB_DT_BOS,                     /*  __u8 bDescriptorType */
44        0x0F, 0x00,                     /*  __le16 wTotalLength, 15 bytes */
45        0x1,                            /*  __u8 bNumDeviceCaps */
46        /* First device capability, SuperSpeed */
47        USB_DT_USB_SS_CAP_SIZE,         /*  __u8 bLength, 10 bytes */
48        USB_DT_DEVICE_CAPABILITY,       /* Device Capability */
49        USB_SS_CAP_TYPE,                /* bDevCapabilityType, SUPERSPEED_USB */
50        0x00,                           /* bmAttributes, LTM off by default */
51        USB_5GBPS_OPERATION, 0x00,      /* wSpeedsSupported, 5Gbps only */
52        0x03,                           /* bFunctionalitySupport,
53                                           USB 3.0 speed only */
54        0x00,                           /* bU1DevExitLat, set later. */
55        0x00, 0x00,                     /* __le16 bU2DevExitLat, set later. */
56        /* Second device capability, SuperSpeedPlus */
57        0x1c,                           /* bLength 28, will be adjusted later */
58        USB_DT_DEVICE_CAPABILITY,       /* Device Capability */
59        USB_SSP_CAP_TYPE,               /* bDevCapabilityType SUPERSPEED_PLUS */
60        0x00,                           /* bReserved 0 */
61        0x23, 0x00, 0x00, 0x00,         /* bmAttributes, SSAC=3 SSIC=1 */
62        0x01, 0x00,                     /* wFunctionalitySupport */
63        0x00, 0x00,                     /* wReserved 0 */
64        /* Default Sublink Speed Attributes, overwrite if custom PSI exists */
65        0x34, 0x00, 0x05, 0x00,         /* 5Gbps, symmetric, rx, ID = 4 */
66        0xb4, 0x00, 0x05, 0x00,         /* 5Gbps, symmetric, tx, ID = 4 */
67        0x35, 0x40, 0x0a, 0x00,         /* 10Gbps, SSP, symmetric, rx, ID = 5 */
68        0xb5, 0x40, 0x0a, 0x00,         /* 10Gbps, SSP, symmetric, tx, ID = 5 */
69};
70
71static int xhci_create_usb3_bos_desc(struct xhci_hcd *xhci, char *buf,
72                                     u16 wLength)
73{
74        int i, ssa_count;
75        u32 temp;
76        u16 desc_size, ssp_cap_size, ssa_size = 0;
77        bool usb3_1 = false;
78
79        desc_size = USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;
80        ssp_cap_size = sizeof(usb_bos_descriptor) - desc_size;
81
82        /* does xhci support USB 3.1 Enhanced SuperSpeed */
83        if (xhci->usb3_rhub.min_rev >= 0x01) {
84                /* does xhci provide a PSI table for SSA speed attributes? */
85                if (xhci->usb3_rhub.psi_count) {
86                        /* two SSA entries for each unique PSI ID, RX and TX */
87                        ssa_count = xhci->usb3_rhub.psi_uid_count * 2;
88                        ssa_size = ssa_count * sizeof(u32);
89                        ssp_cap_size -= 16; /* skip copying the default SSA */
90                }
91                desc_size += ssp_cap_size;
92                usb3_1 = true;
93        }
94        memcpy(buf, &usb_bos_descriptor, min(desc_size, wLength));
95
96        if (usb3_1) {
97                /* modify bos descriptor bNumDeviceCaps and wTotalLength */
98                buf[4] += 1;
99                put_unaligned_le16(desc_size + ssa_size, &buf[2]);
100        }
101
102        if (wLength < USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE)
103                return wLength;
104
105        /* Indicate whether the host has LTM support. */
106        temp = readl(&xhci->cap_regs->hcc_params);
107        if (HCC_LTC(temp))
108                buf[8] |= USB_LTM_SUPPORT;
109
110        /* Set the U1 and U2 exit latencies. */
111        if ((xhci->quirks & XHCI_LPM_SUPPORT)) {
112                temp = readl(&xhci->cap_regs->hcs_params3);
113                buf[12] = HCS_U1_LATENCY(temp);
114                put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
115        }
116
117        /* If PSI table exists, add the custom speed attributes from it */
118        if (usb3_1 && xhci->usb3_rhub.psi_count) {
119                u32 ssp_cap_base, bm_attrib, psi;
120                int offset;
121
122                ssp_cap_base = USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE;
123
124                if (wLength < desc_size)
125                        return wLength;
126                buf[ssp_cap_base] = ssp_cap_size + ssa_size;
127
128                /* attribute count SSAC bits 4:0 and ID count SSIC bits 8:5 */
129                bm_attrib = (ssa_count - 1) & 0x1f;
130                bm_attrib |= (xhci->usb3_rhub.psi_uid_count - 1) << 5;
131                put_unaligned_le32(bm_attrib, &buf[ssp_cap_base + 4]);
132
133                if (wLength < desc_size + ssa_size)
134                        return wLength;
135                /*
136                 * Create the Sublink Speed Attributes (SSA) array.
137                 * The xhci PSI field and USB 3.1 SSA fields are very similar,
138                 * but link type bits 7:6 differ for values 01b and 10b.
139                 * xhci has also only one PSI entry for a symmetric link when
140                 * USB 3.1 requires two SSA entries (RX and TX) for every link
141                 */
142                offset = desc_size;
143                for (i = 0; i < xhci->usb3_rhub.psi_count; i++) {
144                        psi = xhci->usb3_rhub.psi[i];
145                        psi &= ~USB_SSP_SUBLINK_SPEED_RSVD;
146                        if ((psi & PLT_MASK) == PLT_SYM) {
147                        /* Symmetric, create SSA RX and TX from one PSI entry */
148                                put_unaligned_le32(psi, &buf[offset]);
149                                psi |= 1 << 7;  /* turn entry to TX */
150                                offset += 4;
151                                if (offset >= desc_size + ssa_size)
152                                        return desc_size + ssa_size;
153                        } else if ((psi & PLT_MASK) == PLT_ASYM_RX) {
154                                /* Asymetric RX, flip bits 7:6 for SSA */
155                                psi ^= PLT_MASK;
156                        }
157                        put_unaligned_le32(psi, &buf[offset]);
158                        offset += 4;
159                        if (offset >= desc_size + ssa_size)
160                                return desc_size + ssa_size;
161                }
162        }
163        /* ssa_size is 0 for other than usb 3.1 hosts */
164        return desc_size + ssa_size;
165}
166
167static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
168                struct usb_hub_descriptor *desc, int ports)
169{
170        u16 temp;
171
172        desc->bPwrOn2PwrGood = 10;      /* xhci section 5.4.9 says 20ms max */
173        desc->bHubContrCurrent = 0;
174
175        desc->bNbrPorts = ports;
176        temp = 0;
177        /* Bits 1:0 - support per-port power switching, or power always on */
178        if (HCC_PPC(xhci->hcc_params))
179                temp |= HUB_CHAR_INDV_PORT_LPSM;
180        else
181                temp |= HUB_CHAR_NO_LPSM;
182        /* Bit  2 - root hubs are not part of a compound device */
183        /* Bits 4:3 - individual port over current protection */
184        temp |= HUB_CHAR_INDV_PORT_OCPM;
185        /* Bits 6:5 - no TTs in root ports */
186        /* Bit  7 - no port indicators */
187        desc->wHubCharacteristics = cpu_to_le16(temp);
188}
189
190/* Fill in the USB 2.0 roothub descriptor */
191static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
192                struct usb_hub_descriptor *desc)
193{
194        int ports;
195        u16 temp;
196        __u8 port_removable[(USB_MAXCHILDREN + 1 + 7) / 8];
197        u32 portsc;
198        unsigned int i;
199
200        ports = xhci->num_usb2_ports;
201
202        xhci_common_hub_descriptor(xhci, desc, ports);
203        desc->bDescriptorType = USB_DT_HUB;
204        temp = 1 + (ports / 8);
205        desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * temp;
206
207        /* The Device Removable bits are reported on a byte granularity.
208         * If the port doesn't exist within that byte, the bit is set to 0.
209         */
210        memset(port_removable, 0, sizeof(port_removable));
211        for (i = 0; i < ports; i++) {
212                portsc = readl(xhci->usb2_ports[i]);
213                /* If a device is removable, PORTSC reports a 0, same as in the
214                 * hub descriptor DeviceRemovable bits.
215                 */
216                if (portsc & PORT_DEV_REMOVE)
217                        /* This math is hairy because bit 0 of DeviceRemovable
218                         * is reserved, and bit 1 is for port 1, etc.
219                         */
220                        port_removable[(i + 1) / 8] |= 1 << ((i + 1) % 8);
221        }
222
223        /* ch11.h defines a hub descriptor that has room for USB_MAXCHILDREN
224         * ports on it.  The USB 2.0 specification says that there are two
225         * variable length fields at the end of the hub descriptor:
226         * DeviceRemovable and PortPwrCtrlMask.  But since we can have less than
227         * USB_MAXCHILDREN ports, we may need to use the DeviceRemovable array
228         * to set PortPwrCtrlMask bits.  PortPwrCtrlMask must always be set to
229         * 0xFF, so we initialize the both arrays (DeviceRemovable and
230         * PortPwrCtrlMask) to 0xFF.  Then we set the DeviceRemovable for each
231         * set of ports that actually exist.
232         */
233        memset(desc->u.hs.DeviceRemovable, 0xff,
234                        sizeof(desc->u.hs.DeviceRemovable));
235        memset(desc->u.hs.PortPwrCtrlMask, 0xff,
236                        sizeof(desc->u.hs.PortPwrCtrlMask));
237
238        for (i = 0; i < (ports + 1 + 7) / 8; i++)
239                memset(&desc->u.hs.DeviceRemovable[i], port_removable[i],
240                                sizeof(__u8));
241}
242
243/* Fill in the USB 3.0 roothub descriptor */
244static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
245                struct usb_hub_descriptor *desc)
246{
247        int ports;
248        u16 port_removable;
249        u32 portsc;
250        unsigned int i;
251
252        ports = xhci->num_usb3_ports;
253        xhci_common_hub_descriptor(xhci, desc, ports);
254        desc->bDescriptorType = USB_DT_SS_HUB;
255        desc->bDescLength = USB_DT_SS_HUB_SIZE;
256
257        /* header decode latency should be zero for roothubs,
258         * see section 4.23.5.2.
259         */
260        desc->u.ss.bHubHdrDecLat = 0;
261        desc->u.ss.wHubDelay = 0;
262
263        port_removable = 0;
264        /* bit 0 is reserved, bit 1 is for port 1, etc. */
265        for (i = 0; i < ports; i++) {
266                portsc = readl(xhci->usb3_ports[i]);
267                if (portsc & PORT_DEV_REMOVE)
268                        port_removable |= 1 << (i + 1);
269        }
270
271        desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
272}
273
274static void xhci_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
275                struct usb_hub_descriptor *desc)
276{
277
278        if (hcd->speed >= HCD_USB3)
279                xhci_usb3_hub_descriptor(hcd, xhci, desc);
280        else
281                xhci_usb2_hub_descriptor(hcd, xhci, desc);
282
283}
284
285static unsigned int xhci_port_speed(unsigned int port_status)
286{
287        if (DEV_LOWSPEED(port_status))
288                return USB_PORT_STAT_LOW_SPEED;
289        if (DEV_HIGHSPEED(port_status))
290                return USB_PORT_STAT_HIGH_SPEED;
291        /*
292         * FIXME: Yes, we should check for full speed, but the core uses that as
293         * a default in portspeed() in usb/core/hub.c (which is the only place
294         * USB_PORT_STAT_*_SPEED is used).
295         */
296        return 0;
297}
298
299/*
300 * These bits are Read Only (RO) and should be saved and written to the
301 * registers: 0, 3, 10:13, 30
302 * connect status, over-current status, port speed, and device removable.
303 * connect status and port speed are also sticky - meaning they're in
304 * the AUX well and they aren't changed by a hot, warm, or cold reset.
305 */
306#define XHCI_PORT_RO    ((1<<0) | (1<<3) | (0xf<<10) | (1<<30))
307/*
308 * These bits are RW; writing a 0 clears the bit, writing a 1 sets the bit:
309 * bits 5:8, 9, 14:15, 25:27
310 * link state, port power, port indicator state, "wake on" enable state
311 */
312#define XHCI_PORT_RWS   ((0xf<<5) | (1<<9) | (0x3<<14) | (0x7<<25))
313/*
314 * These bits are RW; writing a 1 sets the bit, writing a 0 has no effect:
315 * bit 4 (port reset)
316 */
317#define XHCI_PORT_RW1S  ((1<<4))
318/*
319 * These bits are RW; writing a 1 clears the bit, writing a 0 has no effect:
320 * bits 1, 17, 18, 19, 20, 21, 22, 23
321 * port enable/disable, and
322 * change bits: connect, PED, warm port reset changed (reserved zero for USB 2.0 ports),
323 * over-current, reset, link state, and L1 change
324 */
325#define XHCI_PORT_RW1CS ((1<<1) | (0x7f<<17))
326/*
327 * Bit 16 is RW, and writing a '1' to it causes the link state control to be
328 * latched in
329 */
330#define XHCI_PORT_RW    ((1<<16))
331/*
332 * These bits are Reserved Zero (RsvdZ) and zero should be written to them:
333 * bits 2, 24, 28:31
334 */
335#define XHCI_PORT_RZ    ((1<<2) | (1<<24) | (0xf<<28))
336
337/*
338 * Given a port state, this function returns a value that would result in the
339 * port being in the same state, if the value was written to the port status
340 * control register.
341 * Save Read Only (RO) bits and save read/write bits where
342 * writing a 0 clears the bit and writing a 1 sets the bit (RWS).
343 * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect.
344 */
345u32 xhci_port_state_to_neutral(u32 state)
346{
347        /* Save read-only status and port state */
348        return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
349}
350
351/*
352 * find slot id based on port number.
353 * @port: The one-based port number from one of the two split roothubs.
354 */
355int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
356                u16 port)
357{
358        int slot_id;
359        int i;
360        enum usb_device_speed speed;
361
362        slot_id = 0;
363        for (i = 0; i < MAX_HC_SLOTS; i++) {
364                if (!xhci->devs[i])
365                        continue;
366                speed = xhci->devs[i]->udev->speed;
367                if (((speed >= USB_SPEED_SUPER) == (hcd->speed >= HCD_USB3))
368                                && xhci->devs[i]->fake_port == port) {
369                        slot_id = i;
370                        break;
371                }
372        }
373
374        return slot_id;
375}
376
377/*
378 * Stop device
379 * It issues stop endpoint command for EP 0 to 30. And wait the last command
380 * to complete.
381 * suspend will set to 1, if suspend bit need to set in command.
382 */
383static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
384{
385        struct xhci_virt_device *virt_dev;
386        struct xhci_command *cmd;
387        unsigned long flags;
388        int ret;
389        int i;
390
391        ret = 0;
392        virt_dev = xhci->devs[slot_id];
393        if (!virt_dev)
394                return -ENODEV;
395
396        cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
397        if (!cmd) {
398                xhci_dbg(xhci, "Couldn't allocate command structure.\n");
399                return -ENOMEM;
400        }
401
402        spin_lock_irqsave(&xhci->lock, flags);
403        for (i = LAST_EP_INDEX; i > 0; i--) {
404                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue) {
405                        struct xhci_command *command;
406                        command = xhci_alloc_command(xhci, false, false,
407                                                     GFP_NOWAIT);
408                        if (!command) {
409                                spin_unlock_irqrestore(&xhci->lock, flags);
410                                xhci_free_command(xhci, cmd);
411                                return -ENOMEM;
412
413                        }
414                        xhci_queue_stop_endpoint(xhci, command, slot_id, i,
415                                                 suspend);
416                }
417        }
418        xhci_queue_stop_endpoint(xhci, cmd, slot_id, 0, suspend);
419        xhci_ring_cmd_db(xhci);
420        spin_unlock_irqrestore(&xhci->lock, flags);
421
422        /* Wait for last stop endpoint command to finish */
423        wait_for_completion(cmd->completion);
424
425        if (cmd->status == COMP_CMD_ABORT || cmd->status == COMP_CMD_STOP) {
426                xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
427                ret = -ETIME;
428        }
429        xhci_free_command(xhci, cmd);
430        return ret;
431}
432
433/*
434 * Ring device, it rings the all doorbells unconditionally.
435 */
436void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
437{
438        int i, s;
439        struct xhci_virt_ep *ep;
440
441        for (i = 0; i < LAST_EP_INDEX + 1; i++) {
442                ep = &xhci->devs[slot_id]->eps[i];
443
444                if (ep->ep_state & EP_HAS_STREAMS) {
445                        for (s = 1; s < ep->stream_info->num_streams; s++)
446                                xhci_ring_ep_doorbell(xhci, slot_id, i, s);
447                } else if (ep->ring && ep->ring->dequeue) {
448                        xhci_ring_ep_doorbell(xhci, slot_id, i, 0);
449                }
450        }
451
452        return;
453}
454
455static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
456                u16 wIndex, __le32 __iomem *addr, u32 port_status)
457{
458        /* Don't allow the USB core to disable SuperSpeed ports. */
459        if (hcd->speed >= HCD_USB3) {
460                xhci_dbg(xhci, "Ignoring request to disable "
461                                "SuperSpeed port.\n");
462                return;
463        }
464
465        if (xhci->quirks & XHCI_BROKEN_PORT_PED) {
466                xhci_dbg(xhci,
467                         "Broken Port Enabled/Disabled, ignoring port disable request.\n");
468                return;
469        }
470
471        /* Write 1 to disable the port */
472        writel(port_status | PORT_PE, addr);
473        port_status = readl(addr);
474        xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",
475                        wIndex, port_status);
476}
477
478static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
479                u16 wIndex, __le32 __iomem *addr, u32 port_status)
480{
481        char *port_change_bit;
482        u32 status;
483
484        switch (wValue) {
485        case USB_PORT_FEAT_C_RESET:
486                status = PORT_RC;
487                port_change_bit = "reset";
488                break;
489        case USB_PORT_FEAT_C_BH_PORT_RESET:
490                status = PORT_WRC;
491                port_change_bit = "warm(BH) reset";
492                break;
493        case USB_PORT_FEAT_C_CONNECTION:
494                status = PORT_CSC;
495                port_change_bit = "connect";
496                break;
497        case USB_PORT_FEAT_C_OVER_CURRENT:
498                status = PORT_OCC;
499                port_change_bit = "over-current";
500                break;
501        case USB_PORT_FEAT_C_ENABLE:
502                status = PORT_PEC;
503                port_change_bit = "enable/disable";
504                break;
505        case USB_PORT_FEAT_C_SUSPEND:
506                status = PORT_PLC;
507                port_change_bit = "suspend/resume";
508                break;
509        case USB_PORT_FEAT_C_PORT_LINK_STATE:
510                status = PORT_PLC;
511                port_change_bit = "link state";
512                break;
513        case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
514                status = PORT_CEC;
515                port_change_bit = "config error";
516                break;
517        default:
518                /* Should never happen */
519                return;
520        }
521        /* Change bits are all write 1 to clear */
522        writel(port_status | status, addr);
523        port_status = readl(addr);
524        xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
525                        port_change_bit, wIndex, port_status);
526}
527
528static int xhci_get_ports(struct usb_hcd *hcd, __le32 __iomem ***port_array)
529{
530        int max_ports;
531        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
532
533        if (hcd->speed >= HCD_USB3) {
534                max_ports = xhci->num_usb3_ports;
535                *port_array = xhci->usb3_ports;
536        } else {
537                max_ports = xhci->num_usb2_ports;
538                *port_array = xhci->usb2_ports;
539        }
540
541        return max_ports;
542}
543
544void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
545                                int port_id, u32 link_state)
546{
547        u32 temp;
548
549        temp = readl(port_array[port_id]);
550        temp = xhci_port_state_to_neutral(temp);
551        temp &= ~PORT_PLS_MASK;
552        temp |= PORT_LINK_STROBE | link_state;
553        writel(temp, port_array[port_id]);
554}
555
556static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
557                __le32 __iomem **port_array, int port_id, u16 wake_mask)
558{
559        u32 temp;
560
561        temp = readl(port_array[port_id]);
562        temp = xhci_port_state_to_neutral(temp);
563
564        if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_CONNECT)
565                temp |= PORT_WKCONN_E;
566        else
567                temp &= ~PORT_WKCONN_E;
568
569        if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT)
570                temp |= PORT_WKDISC_E;
571        else
572                temp &= ~PORT_WKDISC_E;
573
574        if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT)
575                temp |= PORT_WKOC_E;
576        else
577                temp &= ~PORT_WKOC_E;
578
579        writel(temp, port_array[port_id]);
580}
581
582/* Test and clear port RWC bit */
583void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
584                                int port_id, u32 port_bit)
585{
586        u32 temp;
587
588        temp = readl(port_array[port_id]);
589        if (temp & port_bit) {
590                temp = xhci_port_state_to_neutral(temp);
591                temp |= port_bit;
592                writel(temp, port_array[port_id]);
593        }
594}
595
596/* Updates Link Status for USB 2.1 port */
597static void xhci_hub_report_usb2_link_state(u32 *status, u32 status_reg)
598{
599        if ((status_reg & PORT_PLS_MASK) == XDEV_U2)
600                *status |= USB_PORT_STAT_L1;
601}
602
603/* Updates Link Status for super Speed port */
604static void xhci_hub_report_usb3_link_state(struct xhci_hcd *xhci,
605                u32 *status, u32 status_reg)
606{
607        u32 pls = status_reg & PORT_PLS_MASK;
608
609        /* resume state is a xHCI internal state.
610         * Do not report it to usb core, instead, pretend to be U3,
611         * thus usb core knows it's not ready for transfer
612         */
613        if (pls == XDEV_RESUME) {
614                *status |= USB_SS_PORT_LS_U3;
615                return;
616        }
617
618        /* When the CAS bit is set then warm reset
619         * should be performed on port
620         */
621        if (status_reg & PORT_CAS) {
622                /* The CAS bit can be set while the port is
623                 * in any link state.
624                 * Only roothubs have CAS bit, so we
625                 * pretend to be in compliance mode
626                 * unless we're already in compliance
627                 * or the inactive state.
628                 */
629                if (pls != USB_SS_PORT_LS_COMP_MOD &&
630                    pls != USB_SS_PORT_LS_SS_INACTIVE) {
631                        pls = USB_SS_PORT_LS_COMP_MOD;
632                }
633                /* Return also connection bit -
634                 * hub state machine resets port
635                 * when this bit is set.
636                 */
637                pls |= USB_PORT_STAT_CONNECTION;
638        } else {
639                /*
640                 * If CAS bit isn't set but the Port is already at
641                 * Compliance Mode, fake a connection so the USB core
642                 * notices the Compliance state and resets the port.
643                 * This resolves an issue generated by the SN65LVPE502CP
644                 * in which sometimes the port enters compliance mode
645                 * caused by a delay on the host-device negotiation.
646                 */
647                if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
648                                (pls == USB_SS_PORT_LS_COMP_MOD))
649                        pls |= USB_PORT_STAT_CONNECTION;
650        }
651
652        /* update status field */
653        *status |= pls;
654}
655
656/*
657 * Function for Compliance Mode Quirk.
658 *
659 * This Function verifies if all xhc USB3 ports have entered U0, if so,
660 * the compliance mode timer is deleted. A port won't enter
661 * compliance mode if it has previously entered U0.
662 */
663static void xhci_del_comp_mod_timer(struct xhci_hcd *xhci, u32 status,
664                                    u16 wIndex)
665{
666        u32 all_ports_seen_u0 = ((1 << xhci->num_usb3_ports)-1);
667        bool port_in_u0 = ((status & PORT_PLS_MASK) == XDEV_U0);
668
669        if (!(xhci->quirks & XHCI_COMP_MODE_QUIRK))
670                return;
671
672        if ((xhci->port_status_u0 != all_ports_seen_u0) && port_in_u0) {
673                xhci->port_status_u0 |= 1 << wIndex;
674                if (xhci->port_status_u0 == all_ports_seen_u0) {
675                        del_timer_sync(&xhci->comp_mode_recovery_timer);
676                        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
677                                "All USB3 ports have entered U0 already!");
678                        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
679                                "Compliance Mode Recovery Timer Deleted.");
680                }
681        }
682}
683
684static u32 xhci_get_ext_port_status(u32 raw_port_status, u32 port_li)
685{
686        u32 ext_stat = 0;
687        int speed_id;
688
689        /* only support rx and tx lane counts of 1 in usb3.1 spec */
690        speed_id = DEV_PORT_SPEED(raw_port_status);
691        ext_stat |= speed_id;           /* bits 3:0, RX speed id */
692        ext_stat |= speed_id << 4;      /* bits 7:4, TX speed id */
693
694        ext_stat |= PORT_RX_LANES(port_li) << 8;  /* bits 11:8 Rx lane count */
695        ext_stat |= PORT_TX_LANES(port_li) << 12; /* bits 15:12 Tx lane count */
696
697        return ext_stat;
698}
699
700/*
701 * Converts a raw xHCI port status into the format that external USB 2.0 or USB
702 * 3.0 hubs use.
703 *
704 * Possible side effects:
705 *  - Mark a port as being done with device resume,
706 *    and ring the endpoint doorbells.
707 *  - Stop the Synopsys redriver Compliance Mode polling.
708 *  - Drop and reacquire the xHCI lock, in order to wait for port resume.
709 */
710static u32 xhci_get_port_status(struct usb_hcd *hcd,
711                struct xhci_bus_state *bus_state,
712                __le32 __iomem **port_array,
713                u16 wIndex, u32 raw_port_status,
714                unsigned long flags)
715        __releases(&xhci->lock)
716        __acquires(&xhci->lock)
717{
718        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
719        u32 status = 0;
720        int slot_id;
721
722        /* wPortChange bits */
723        if (raw_port_status & PORT_CSC)
724                status |= USB_PORT_STAT_C_CONNECTION << 16;
725        if (raw_port_status & PORT_PEC)
726                status |= USB_PORT_STAT_C_ENABLE << 16;
727        if ((raw_port_status & PORT_OCC))
728                status |= USB_PORT_STAT_C_OVERCURRENT << 16;
729        if ((raw_port_status & PORT_RC))
730                status |= USB_PORT_STAT_C_RESET << 16;
731        /* USB3.0 only */
732        if (hcd->speed >= HCD_USB3) {
733                /* Port link change with port in resume state should not be
734                 * reported to usbcore, as this is an internal state to be
735                 * handled by xhci driver. Reporting PLC to usbcore may
736                 * cause usbcore clearing PLC first and port change event
737                 * irq won't be generated.
738                 */
739                if ((raw_port_status & PORT_PLC) &&
740                        (raw_port_status & PORT_PLS_MASK) != XDEV_RESUME)
741                        status |= USB_PORT_STAT_C_LINK_STATE << 16;
742                if ((raw_port_status & PORT_WRC))
743                        status |= USB_PORT_STAT_C_BH_RESET << 16;
744                if ((raw_port_status & PORT_CEC))
745                        status |= USB_PORT_STAT_C_CONFIG_ERROR << 16;
746        }
747
748        if (hcd->speed < HCD_USB3) {
749                if ((raw_port_status & PORT_PLS_MASK) == XDEV_U3
750                                && (raw_port_status & PORT_POWER))
751                        status |= USB_PORT_STAT_SUSPEND;
752        }
753        if ((raw_port_status & PORT_PLS_MASK) == XDEV_RESUME &&
754                !DEV_SUPERSPEED_ANY(raw_port_status)) {
755                if ((raw_port_status & PORT_RESET) ||
756                                !(raw_port_status & PORT_PE))
757                        return 0xffffffff;
758                /* did port event handler already start resume timing? */
759                if (!bus_state->resume_done[wIndex]) {
760                        /* If not, maybe we are in a host initated resume? */
761                        if (test_bit(wIndex, &bus_state->resuming_ports)) {
762                                /* Host initated resume doesn't time the resume
763                                 * signalling using resume_done[].
764                                 * It manually sets RESUME state, sleeps 20ms
765                                 * and sets U0 state. This should probably be
766                                 * changed, but not right now.
767                                 */
768                        } else {
769                                /* port resume was discovered now and here,
770                                 * start resume timing
771                                 */
772                                unsigned long timeout = jiffies +
773                                        msecs_to_jiffies(USB_RESUME_TIMEOUT);
774
775                                set_bit(wIndex, &bus_state->resuming_ports);
776                                bus_state->resume_done[wIndex] = timeout;
777                                mod_timer(&hcd->rh_timer, timeout);
778                        }
779                /* Has resume been signalled for USB_RESUME_TIME yet? */
780                } else if (time_after_eq(jiffies,
781                                         bus_state->resume_done[wIndex])) {
782                        int time_left;
783
784                        xhci_dbg(xhci, "Resume USB2 port %d\n",
785                                        wIndex + 1);
786                        bus_state->resume_done[wIndex] = 0;
787                        clear_bit(wIndex, &bus_state->resuming_ports);
788
789                        set_bit(wIndex, &bus_state->rexit_ports);
790                        xhci_set_link_state(xhci, port_array, wIndex,
791                                        XDEV_U0);
792
793                        spin_unlock_irqrestore(&xhci->lock, flags);
794                        time_left = wait_for_completion_timeout(
795                                        &bus_state->rexit_done[wIndex],
796                                        msecs_to_jiffies(
797                                                XHCI_MAX_REXIT_TIMEOUT));
798                        spin_lock_irqsave(&xhci->lock, flags);
799
800                        if (time_left) {
801                                slot_id = xhci_find_slot_id_by_port(hcd,
802                                                xhci, wIndex + 1);
803                                if (!slot_id) {
804                                        xhci_dbg(xhci, "slot_id is zero\n");
805                                        return 0xffffffff;
806                                }
807                                xhci_ring_device(xhci, slot_id);
808                        } else {
809                                int port_status = readl(port_array[wIndex]);
810                                xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",
811                                                XHCI_MAX_REXIT_TIMEOUT,
812                                                port_status);
813                                status |= USB_PORT_STAT_SUSPEND;
814                                clear_bit(wIndex, &bus_state->rexit_ports);
815                        }
816
817                        bus_state->port_c_suspend |= 1 << wIndex;
818                        bus_state->suspended_ports &= ~(1 << wIndex);
819                } else {
820                        /*
821                         * The resume has been signaling for less than
822                         * USB_RESUME_TIME. Report the port status as SUSPEND,
823                         * let the usbcore check port status again and clear
824                         * resume signaling later.
825                         */
826                        status |= USB_PORT_STAT_SUSPEND;
827                }
828        }
829        /*
830         * Clear stale usb2 resume signalling variables in case port changed
831         * state during resume signalling. For example on error
832         */
833        if ((bus_state->resume_done[wIndex] ||
834             test_bit(wIndex, &bus_state->resuming_ports)) &&
835            (raw_port_status & PORT_PLS_MASK) != XDEV_U3 &&
836            (raw_port_status & PORT_PLS_MASK) != XDEV_RESUME) {
837                bus_state->resume_done[wIndex] = 0;
838                clear_bit(wIndex, &bus_state->resuming_ports);
839        }
840
841
842        if ((raw_port_status & PORT_PLS_MASK) == XDEV_U0 &&
843            (raw_port_status & PORT_POWER)) {
844                if (bus_state->suspended_ports & (1 << wIndex)) {
845                        bus_state->suspended_ports &= ~(1 << wIndex);
846                        if (hcd->speed < HCD_USB3)
847                                bus_state->port_c_suspend |= 1 << wIndex;
848                }
849                bus_state->resume_done[wIndex] = 0;
850                clear_bit(wIndex, &bus_state->resuming_ports);
851        }
852        if (raw_port_status & PORT_CONNECT) {
853                status |= USB_PORT_STAT_CONNECTION;
854                status |= xhci_port_speed(raw_port_status);
855        }
856        if (raw_port_status & PORT_PE)
857                status |= USB_PORT_STAT_ENABLE;
858        if (raw_port_status & PORT_OC)
859                status |= USB_PORT_STAT_OVERCURRENT;
860        if (raw_port_status & PORT_RESET)
861                status |= USB_PORT_STAT_RESET;
862        if (raw_port_status & PORT_POWER) {
863                if (hcd->speed >= HCD_USB3)
864                        status |= USB_SS_PORT_STAT_POWER;
865                else
866                        status |= USB_PORT_STAT_POWER;
867        }
868        /* Update Port Link State */
869        if (hcd->speed >= HCD_USB3) {
870                xhci_hub_report_usb3_link_state(xhci, &status, raw_port_status);
871                /*
872                 * Verify if all USB3 Ports Have entered U0 already.
873                 * Delete Compliance Mode Timer if so.
874                 */
875                xhci_del_comp_mod_timer(xhci, raw_port_status, wIndex);
876        } else {
877                xhci_hub_report_usb2_link_state(&status, raw_port_status);
878        }
879        if (bus_state->port_c_suspend & (1 << wIndex))
880                status |= USB_PORT_STAT_C_SUSPEND << 16;
881
882        return status;
883}
884
885int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
886                u16 wIndex, char *buf, u16 wLength)
887{
888        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
889        int max_ports;
890        unsigned long flags;
891        u32 temp, status;
892        int retval = 0;
893        __le32 __iomem **port_array;
894        int slot_id;
895        struct xhci_bus_state *bus_state;
896        u16 link_state = 0;
897        u16 wake_mask = 0;
898        u16 timeout = 0;
899
900        max_ports = xhci_get_ports(hcd, &port_array);
901        bus_state = &xhci->bus_state[hcd_index(hcd)];
902
903        spin_lock_irqsave(&xhci->lock, flags);
904        switch (typeReq) {
905        case GetHubStatus:
906                /* No power source, over-current reported per port */
907                memset(buf, 0, 4);
908                break;
909        case GetHubDescriptor:
910                /* Check to make sure userspace is asking for the USB 3.0 hub
911                 * descriptor for the USB 3.0 roothub.  If not, we stall the
912                 * endpoint, like external hubs do.
913                 */
914                if (hcd->speed >= HCD_USB3 &&
915                                (wLength < USB_DT_SS_HUB_SIZE ||
916                                 wValue != (USB_DT_SS_HUB << 8))) {
917                        xhci_dbg(xhci, "Wrong hub descriptor type for "
918                                        "USB 3.0 roothub.\n");
919                        goto error;
920                }
921                xhci_hub_descriptor(hcd, xhci,
922                                (struct usb_hub_descriptor *) buf);
923                break;
924        case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
925                if ((wValue & 0xff00) != (USB_DT_BOS << 8))
926                        goto error;
927
928                if (hcd->speed < HCD_USB3)
929                        goto error;
930
931                retval = xhci_create_usb3_bos_desc(xhci, buf, wLength);
932                spin_unlock_irqrestore(&xhci->lock, flags);
933                return retval;
934        case GetPortStatus:
935                if (!wIndex || wIndex > max_ports)
936                        goto error;
937                wIndex--;
938                temp = readl(port_array[wIndex]);
939                if (temp == 0xffffffff) {
940                        retval = -ENODEV;
941                        break;
942                }
943                status = xhci_get_port_status(hcd, bus_state, port_array,
944                                wIndex, temp, flags);
945                if (status == 0xffffffff)
946                        goto error;
947
948                xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n",
949                                wIndex, temp);
950                xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
951
952                put_unaligned(cpu_to_le32(status), (__le32 *) buf);
953                /* if USB 3.1 extended port status return additional 4 bytes */
954                if (wValue == 0x02) {
955                        u32 port_li;
956
957                        if (hcd->speed < HCD_USB31 || wLength != 8) {
958                                xhci_err(xhci, "get ext port status invalid parameter\n");
959                                retval = -EINVAL;
960                                break;
961                        }
962                        port_li = readl(port_array[wIndex] + PORTLI);
963                        status = xhci_get_ext_port_status(temp, port_li);
964                        put_unaligned_le32(cpu_to_le32(status), &buf[4]);
965                }
966                break;
967        case SetPortFeature:
968                if (wValue == USB_PORT_FEAT_LINK_STATE)
969                        link_state = (wIndex & 0xff00) >> 3;
970                if (wValue == USB_PORT_FEAT_REMOTE_WAKE_MASK)
971                        wake_mask = wIndex & 0xff00;
972                /* The MSB of wIndex is the U1/U2 timeout */
973                timeout = (wIndex & 0xff00) >> 8;
974                wIndex &= 0xff;
975                if (!wIndex || wIndex > max_ports)
976                        goto error;
977                wIndex--;
978                temp = readl(port_array[wIndex]);
979                if (temp == 0xffffffff) {
980                        retval = -ENODEV;
981                        break;
982                }
983                temp = xhci_port_state_to_neutral(temp);
984                /* FIXME: What new port features do we need to support? */
985                switch (wValue) {
986                case USB_PORT_FEAT_SUSPEND:
987                        temp = readl(port_array[wIndex]);
988                        if ((temp & PORT_PLS_MASK) != XDEV_U0) {
989                                /* Resume the port to U0 first */
990                                xhci_set_link_state(xhci, port_array, wIndex,
991                                                        XDEV_U0);
992                                spin_unlock_irqrestore(&xhci->lock, flags);
993                                msleep(10);
994                                spin_lock_irqsave(&xhci->lock, flags);
995                        }
996                        /* In spec software should not attempt to suspend
997                         * a port unless the port reports that it is in the
998                         * enabled (PED = ‘1’,PLS < ‘3’) state.
999                         */
1000                        temp = readl(port_array[wIndex]);
1001                        if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
1002                                || (temp & PORT_PLS_MASK) >= XDEV_U3) {
1003                                xhci_warn(xhci, "USB core suspending device "
1004                                          "not in U0/U1/U2.\n");
1005                                goto error;
1006                        }
1007
1008                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
1009                                        wIndex + 1);
1010                        if (!slot_id) {
1011                                xhci_warn(xhci, "slot_id is zero\n");
1012                                goto error;
1013                        }
1014                        /* unlock to execute stop endpoint commands */
1015                        spin_unlock_irqrestore(&xhci->lock, flags);
1016                        xhci_stop_device(xhci, slot_id, 1);
1017                        spin_lock_irqsave(&xhci->lock, flags);
1018
1019                        xhci_set_link_state(xhci, port_array, wIndex, XDEV_U3);
1020
1021                        spin_unlock_irqrestore(&xhci->lock, flags);
1022                        msleep(10); /* wait device to enter */
1023                        spin_lock_irqsave(&xhci->lock, flags);
1024
1025                        temp = readl(port_array[wIndex]);
1026                        bus_state->suspended_ports |= 1 << wIndex;
1027                        break;
1028                case USB_PORT_FEAT_LINK_STATE:
1029                        temp = readl(port_array[wIndex]);
1030
1031                        /* Disable port */
1032                        if (link_state == USB_SS_PORT_LS_SS_DISABLED) {
1033                                xhci_dbg(xhci, "Disable port %d\n", wIndex);
1034                                temp = xhci_port_state_to_neutral(temp);
1035                                /*
1036                                 * Clear all change bits, so that we get a new
1037                                 * connection event.
1038                                 */
1039                                temp |= PORT_CSC | PORT_PEC | PORT_WRC |
1040                                        PORT_OCC | PORT_RC | PORT_PLC |
1041                                        PORT_CEC;
1042                                writel(temp | PORT_PE, port_array[wIndex]);
1043                                temp = readl(port_array[wIndex]);
1044                                break;
1045                        }
1046
1047                        /* Put link in RxDetect (enable port) */
1048                        if (link_state == USB_SS_PORT_LS_RX_DETECT) {
1049                                xhci_dbg(xhci, "Enable port %d\n", wIndex);
1050                                xhci_set_link_state(xhci, port_array, wIndex,
1051                                                link_state);
1052                                temp = readl(port_array[wIndex]);
1053                                break;
1054                        }
1055
1056                        /* Software should not attempt to set
1057                         * port link state above '3' (U3) and the port
1058                         * must be enabled.
1059                         */
1060                        if ((temp & PORT_PE) == 0 ||
1061                                (link_state > USB_SS_PORT_LS_U3)) {
1062                                xhci_warn(xhci, "Cannot set link state.\n");
1063                                goto error;
1064                        }
1065
1066                        if (link_state == USB_SS_PORT_LS_U3) {
1067                                slot_id = xhci_find_slot_id_by_port(hcd, xhci,
1068                                                wIndex + 1);
1069                                if (slot_id) {
1070                                        /* unlock to execute stop endpoint
1071                                         * commands */
1072                                        spin_unlock_irqrestore(&xhci->lock,
1073                                                                flags);
1074                                        xhci_stop_device(xhci, slot_id, 1);
1075                                        spin_lock_irqsave(&xhci->lock, flags);
1076                                }
1077                        }
1078
1079                        xhci_set_link_state(xhci, port_array, wIndex,
1080                                                link_state);
1081
1082                        spin_unlock_irqrestore(&xhci->lock, flags);
1083                        msleep(20); /* wait device to enter */
1084                        spin_lock_irqsave(&xhci->lock, flags);
1085
1086                        temp = readl(port_array[wIndex]);
1087                        if (link_state == USB_SS_PORT_LS_U3)
1088                                bus_state->suspended_ports |= 1 << wIndex;
1089                        break;
1090                case USB_PORT_FEAT_POWER:
1091                        /*
1092                         * Turn on ports, even if there isn't per-port switching.
1093                         * HC will report connect events even before this is set.
1094                         * However, hub_wq will ignore the roothub events until
1095                         * the roothub is registered.
1096                         */
1097
1098#ifdef CONFIG_BCM47XX
1099                        if(usb2mode != 0){
1100                                writel(0x0, port_array[wIndex]);
1101
1102                                if(usb2mode == 1){ // 0bc2:a0a1
1103                                        writel(0x0 & ~PORT_PE | PORT_POWER | PORT_LINK_STROBE & ~PORT_PLS_MASK, port_array[wIndex]);
1104                                }
1105                        }
1106                        else{
1107                                writel(temp | PORT_POWER, port_array[wIndex]);
1108                        }
1109#else
1110                        writel(temp | PORT_POWER, port_array[wIndex]);
1111#endif
1112                        temp = readl(port_array[wIndex]);
1113                        xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
1114
1115                        spin_unlock_irqrestore(&xhci->lock, flags);
1116                        temp = usb_acpi_power_manageable(hcd->self.root_hub,
1117                                        wIndex);
1118                        if (temp)
1119                                usb_acpi_set_power_state(hcd->self.root_hub,
1120                                                wIndex, true);
1121                        spin_lock_irqsave(&xhci->lock, flags);
1122                        break;
1123                case USB_PORT_FEAT_RESET:
1124                        temp = (temp | PORT_RESET);
1125                        writel(temp, port_array[wIndex]);
1126
1127                        temp = readl(port_array[wIndex]);
1128                        xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
1129                        break;
1130                case USB_PORT_FEAT_REMOTE_WAKE_MASK:
1131                        xhci_set_remote_wake_mask(xhci, port_array,
1132                                        wIndex, wake_mask);
1133                        temp = readl(port_array[wIndex]);
1134                        xhci_dbg(xhci, "set port remote wake mask, "
1135                                        "actual port %d status  = 0x%x\n",
1136                                        wIndex, temp);
1137                        break;
1138                case USB_PORT_FEAT_BH_PORT_RESET:
1139                        temp |= PORT_WR;
1140                        writel(temp, port_array[wIndex]);
1141
1142                        temp = readl(port_array[wIndex]);
1143                        break;
1144                case USB_PORT_FEAT_U1_TIMEOUT:
1145                        if (hcd->speed < HCD_USB3)
1146                                goto error;
1147                        temp = readl(port_array[wIndex] + PORTPMSC);
1148                        temp &= ~PORT_U1_TIMEOUT_MASK;
1149                        temp |= PORT_U1_TIMEOUT(timeout);
1150                        writel(temp, port_array[wIndex] + PORTPMSC);
1151                        break;
1152                case USB_PORT_FEAT_U2_TIMEOUT:
1153                        if (hcd->speed < HCD_USB3)
1154                                goto error;
1155                        temp = readl(port_array[wIndex] + PORTPMSC);
1156                        temp &= ~PORT_U2_TIMEOUT_MASK;
1157                        temp |= PORT_U2_TIMEOUT(timeout);
1158                        writel(temp, port_array[wIndex] + PORTPMSC);
1159                        break;
1160                default:
1161                        goto error;
1162                }
1163                /* unblock any posted writes */
1164                temp = readl(port_array[wIndex]);
1165                break;
1166        case ClearPortFeature:
1167                if (!wIndex || wIndex > max_ports)
1168                        goto error;
1169                wIndex--;
1170                temp = readl(port_array[wIndex]);
1171                if (temp == 0xffffffff) {
1172                        retval = -ENODEV;
1173                        break;
1174                }
1175                /* FIXME: What new port features do we need to support? */
1176                temp = xhci_port_state_to_neutral(temp);
1177                switch (wValue) {
1178                case USB_PORT_FEAT_SUSPEND:
1179                        temp = readl(port_array[wIndex]);
1180                        xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
1181                        xhci_dbg(xhci, "PORTSC %04x\n", temp);
1182                        if (temp & PORT_RESET)
1183                                goto error;
1184                        if ((temp & PORT_PLS_MASK) == XDEV_U3) {
1185                                if ((temp & PORT_PE) == 0)
1186                                        goto error;
1187
1188                                set_bit(wIndex, &bus_state->resuming_ports);
1189                                xhci_set_link_state(xhci, port_array, wIndex,
1190                                                        XDEV_RESUME);
1191                                spin_unlock_irqrestore(&xhci->lock, flags);
1192                                msleep(USB_RESUME_TIMEOUT);
1193                                spin_lock_irqsave(&xhci->lock, flags);
1194                                xhci_set_link_state(xhci, port_array, wIndex,
1195                                                        XDEV_U0);
1196                                clear_bit(wIndex, &bus_state->resuming_ports);
1197                        }
1198                        bus_state->port_c_suspend |= 1 << wIndex;
1199
1200                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
1201                                        wIndex + 1);
1202                        if (!slot_id) {
1203                                xhci_dbg(xhci, "slot_id is zero\n");
1204                                goto error;
1205                        }
1206                        xhci_ring_device(xhci, slot_id);
1207                        break;
1208                case USB_PORT_FEAT_C_SUSPEND:
1209                        bus_state->port_c_suspend &= ~(1 << wIndex);
1210                case USB_PORT_FEAT_C_RESET:
1211                case USB_PORT_FEAT_C_BH_PORT_RESET:
1212                case USB_PORT_FEAT_C_CONNECTION:
1213                case USB_PORT_FEAT_C_OVER_CURRENT:
1214                case USB_PORT_FEAT_C_ENABLE:
1215                case USB_PORT_FEAT_C_PORT_LINK_STATE:
1216                case USB_PORT_FEAT_C_PORT_CONFIG_ERROR:
1217                        xhci_clear_port_change_bit(xhci, wValue, wIndex,
1218                                        port_array[wIndex], temp);
1219                        break;
1220                case USB_PORT_FEAT_ENABLE:
1221                        xhci_disable_port(hcd, xhci, wIndex,
1222                                        port_array[wIndex], temp);
1223                        break;
1224                case USB_PORT_FEAT_POWER:
1225                        writel(temp & ~PORT_POWER, port_array[wIndex]);
1226
1227                        spin_unlock_irqrestore(&xhci->lock, flags);
1228                        temp = usb_acpi_power_manageable(hcd->self.root_hub,
1229                                        wIndex);
1230                        if (temp)
1231                                usb_acpi_set_power_state(hcd->self.root_hub,
1232                                                wIndex, false);
1233                        spin_lock_irqsave(&xhci->lock, flags);
1234                        break;
1235                default:
1236                        goto error;
1237                }
1238                break;
1239        default:
1240error:
1241                /* "stall" on error */
1242                retval = -EPIPE;
1243        }
1244        spin_unlock_irqrestore(&xhci->lock, flags);
1245        return retval;
1246}
1247
1248/*
1249 * Returns 0 if the status hasn't changed, or the number of bytes in buf.
1250 * Ports are 0-indexed from the HCD point of view,
1251 * and 1-indexed from the USB core pointer of view.
1252 *
1253 * Note that the status change bits will be cleared as soon as a port status
1254 * change event is generated, so we use the saved status from that event.
1255 */
1256int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
1257{
1258        unsigned long flags;
1259        u32 temp, status;
1260        u32 mask;
1261        int i, retval;
1262        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
1263        int max_ports;
1264        __le32 __iomem **port_array;
1265        struct xhci_bus_state *bus_state;
1266        bool reset_change = false;
1267
1268        max_ports = xhci_get_ports(hcd, &port_array);
1269        bus_state = &xhci->bus_state[hcd_index(hcd)];
1270
1271        /* Initial status is no changes */
1272        retval = (max_ports + 8) / 8;
1273        memset(buf, 0, retval);
1274
1275        /*
1276         * Inform the usbcore about resume-in-progress by returning
1277         * a non-zero value even if there are no status changes.
1278         */
1279        status = bus_state->resuming_ports;
1280
1281        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC | PORT_CEC;
1282
1283        spin_lock_irqsave(&xhci->lock, flags);
1284        /* For each port, did anything change?  If so, set that bit in buf. */
1285        for (i = 0; i < max_ports; i++) {
1286                temp = readl(port_array[i]);
1287                if (temp == 0xffffffff) {
1288                        retval = -ENODEV;
1289                        break;
1290                }
1291                if ((temp & mask) != 0 ||
1292                        (bus_state->port_c_suspend & 1 << i) ||
1293                        (bus_state->resume_done[i] && time_after_eq(
1294                            jiffies, bus_state->resume_done[i]))) {
1295                        buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
1296                        status = 1;
1297                }
1298                if ((temp & PORT_RC))
1299                        reset_change = true;
1300        }
1301        if (!status && !reset_change) {
1302                xhci_dbg(xhci, "%s: stopping port polling.\n", __func__);
1303                clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1304        }
1305        spin_unlock_irqrestore(&xhci->lock, flags);
1306        return status ? retval : 0;
1307}
1308
1309#ifdef CONFIG_PM
1310
1311int xhci_bus_suspend(struct usb_hcd *hcd)
1312{
1313        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
1314        int max_ports, port_index;
1315        __le32 __iomem **port_array;
1316        struct xhci_bus_state *bus_state;
1317        unsigned long flags;
1318
1319        max_ports = xhci_get_ports(hcd, &port_array);
1320        bus_state = &xhci->bus_state[hcd_index(hcd)];
1321
1322        spin_lock_irqsave(&xhci->lock, flags);
1323
1324        if (hcd->self.root_hub->do_remote_wakeup) {
1325                if (bus_state->resuming_ports ||        /* USB2 */
1326                    bus_state->port_remote_wakeup) {    /* USB3 */
1327                        spin_unlock_irqrestore(&xhci->lock, flags);
1328                        xhci_dbg(xhci, "suspend failed because a port is resuming\n");
1329                        return -EBUSY;
1330                }
1331        }
1332
1333        port_index = max_ports;
1334        bus_state->bus_suspended = 0;
1335        while (port_index--) {
1336                /* suspend the port if the port is not suspended */
1337                u32 t1, t2;
1338                int slot_id;
1339
1340                t1 = readl(port_array[port_index]);
1341                t2 = xhci_port_state_to_neutral(t1);
1342
1343                if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
1344                        xhci_dbg(xhci, "port %d not suspended\n", port_index);
1345                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
1346                                        port_index + 1);
1347                        if (slot_id) {
1348                                spin_unlock_irqrestore(&xhci->lock, flags);
1349                                xhci_stop_device(xhci, slot_id, 1);
1350                                spin_lock_irqsave(&xhci->lock, flags);
1351                        }
1352                        t2 &= ~PORT_PLS_MASK;
1353                        t2 |= PORT_LINK_STROBE | XDEV_U3;
1354                        set_bit(port_index, &bus_state->bus_suspended);
1355                }
1356                /* USB core sets remote wake mask for USB 3.0 hubs,
1357                 * including the USB 3.0 roothub, but only if CONFIG_PM
1358                 * is enabled, so also enable remote wake here.
1359                 */
1360                if (hcd->self.root_hub->do_remote_wakeup) {
1361                        if (t1 & PORT_CONNECT) {
1362                                t2 |= PORT_WKOC_E | PORT_WKDISC_E;
1363                                t2 &= ~PORT_WKCONN_E;
1364                        } else {
1365                                t2 |= PORT_WKOC_E | PORT_WKCONN_E;
1366                                t2 &= ~PORT_WKDISC_E;
1367                        }
1368                } else
1369                        t2 &= ~PORT_WAKE_BITS;
1370
1371                t1 = xhci_port_state_to_neutral(t1);
1372                if (t1 != t2)
1373                        writel(t2, port_array[port_index]);
1374        }
1375        hcd->state = HC_STATE_SUSPENDED;
1376        bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
1377        spin_unlock_irqrestore(&xhci->lock, flags);
1378        return 0;
1379}
1380
1381/*
1382 * Workaround for missing Cold Attach Status (CAS) if device re-plugged in S3.
1383 * warm reset a USB3 device stuck in polling or compliance mode after resume.
1384 * See Intel 100/c230 series PCH specification update Doc #332692-006 Errata #8
1385 */
1386static bool xhci_port_missing_cas_quirk(int port_index,
1387                                             __le32 __iomem **port_array)
1388{
1389        u32 portsc;
1390
1391        portsc = readl(port_array[port_index]);
1392
1393        /* if any of these are set we are not stuck */
1394        if (portsc & (PORT_CONNECT | PORT_CAS))
1395                return false;
1396
1397        if (((portsc & PORT_PLS_MASK) != XDEV_POLLING) &&
1398            ((portsc & PORT_PLS_MASK) != XDEV_COMP_MODE))
1399                return false;
1400
1401        /* clear wakeup/change bits, and do a warm port reset */
1402        portsc &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
1403        portsc |= PORT_WR;
1404        writel(portsc, port_array[port_index]);
1405        /* flush write */
1406        readl(port_array[port_index]);
1407        return true;
1408}
1409
1410int xhci_bus_resume(struct usb_hcd *hcd)
1411{
1412        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
1413        int max_ports, port_index;
1414        __le32 __iomem **port_array;
1415        struct xhci_bus_state *bus_state;
1416        u32 temp;
1417        unsigned long flags;
1418        unsigned long port_was_suspended = 0;
1419        bool need_usb2_u3_exit = false;
1420        int slot_id;
1421        int sret;
1422
1423        max_ports = xhci_get_ports(hcd, &port_array);
1424        bus_state = &xhci->bus_state[hcd_index(hcd)];
1425
1426        if (time_before(jiffies, bus_state->next_statechange))
1427                msleep(5);
1428
1429        spin_lock_irqsave(&xhci->lock, flags);
1430        if (!HCD_HW_ACCESSIBLE(hcd)) {
1431                spin_unlock_irqrestore(&xhci->lock, flags);
1432                return -ESHUTDOWN;
1433        }
1434
1435        /* delay the irqs */
1436        temp = readl(&xhci->op_regs->command);
1437        temp &= ~CMD_EIE;
1438        writel(temp, &xhci->op_regs->command);
1439
1440        port_index = max_ports;
1441        while (port_index--) {
1442                /* Check whether need resume ports. If needed
1443                   resume port and disable remote wakeup */
1444                u32 temp;
1445
1446                temp = readl(port_array[port_index]);
1447
1448                /* warm reset CAS limited ports stuck in polling/compliance */
1449                if ((xhci->quirks & XHCI_MISSING_CAS) &&
1450                    (hcd->speed >= HCD_USB3) &&
1451                    xhci_port_missing_cas_quirk(port_index, port_array)) {
1452                        xhci_dbg(xhci, "reset stuck port %d\n", port_index);
1453                        continue;
1454                }
1455                if (DEV_SUPERSPEED_ANY(temp))
1456                        temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
1457                else
1458                        temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
1459                if (test_bit(port_index, &bus_state->bus_suspended) &&
1460                    (temp & PORT_PLS_MASK)) {
1461                        set_bit(port_index, &port_was_suspended);
1462                        if (!DEV_SUPERSPEED_ANY(temp)) {
1463                                xhci_set_link_state(xhci, port_array,
1464                                                port_index, XDEV_RESUME);
1465                                need_usb2_u3_exit = true;
1466                        }
1467                } else
1468                        writel(temp, port_array[port_index]);
1469        }
1470
1471        if (need_usb2_u3_exit) {
1472                spin_unlock_irqrestore(&xhci->lock, flags);
1473                msleep(USB_RESUME_TIMEOUT);
1474                spin_lock_irqsave(&xhci->lock, flags);
1475        }
1476
1477        port_index = max_ports;
1478        while (port_index--) {
1479                if (!(port_was_suspended & BIT(port_index)))
1480                        continue;
1481                /* Clear PLC to poll it later after XDEV_U0 */
1482                xhci_test_and_clear_bit(xhci, port_array, port_index, PORT_PLC);
1483                xhci_set_link_state(xhci, port_array, port_index, XDEV_U0);
1484        }
1485
1486        port_index = max_ports;
1487        while (port_index--) {
1488                if (!(port_was_suspended & BIT(port_index)))
1489                        continue;
1490                /* Poll and Clear PLC */
1491                sret = xhci_handshake(port_array[port_index], PORT_PLC,
1492                                      PORT_PLC, 10 * 1000);
1493                if (sret)
1494                        xhci_warn(xhci, "port %d resume PLC timeout\n",
1495                                  port_index);
1496                xhci_test_and_clear_bit(xhci, port_array, port_index, PORT_PLC);
1497                slot_id = xhci_find_slot_id_by_port(hcd, xhci, port_index + 1);
1498                if (slot_id)
1499                        xhci_ring_device(xhci, slot_id);
1500        }
1501
1502        (void) readl(&xhci->op_regs->command);
1503
1504        bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
1505        /* re-enable irqs */
1506        temp = readl(&xhci->op_regs->command);
1507        temp |= CMD_EIE;
1508        writel(temp, &xhci->op_regs->command);
1509        temp = readl(&xhci->op_regs->command);
1510
1511        spin_unlock_irqrestore(&xhci->lock, flags);
1512        return 0;
1513}
1514
1515#endif  /* CONFIG_PM */
Note: See TracBrowser for help on using the repository browser.