xhci: Store endpoint bandwidth information.

In the upcoming patches, we'll use some stored endpoint information to
make software keep track of the worst-case bandwidth schedule.  We need to
store several variables associated with each periodic endpoint:
 - the type of endpoint
 - Max Packet Size
 - Mult
 - Max ESIT payload
 - Max Burst Size (aka number of packets, stored in one-based form)
 - the endpoint interval (normalized to powers of 2 microframes)

All this information is available to the hardware, and stored in its
device output context.  However, we need to ensure that the new
information is stored before the xHCI driver drops the xhci->lock to wait
on the Configure Endpoint command, so that another driver requesting a
configuration or alt setting change will see the update.  The Configure
Endpoint command will never fail on the hardware that needs this software
bandwidth checking (assuming the slot is enabled and the flags are set
properly), so updating the endpoint info before the command completes
should be fine.

Until we add in the bandwidth checking code, just update the endpoint
information after the Configure Endpoint command completes, and after a
Reset Device command completes.  Don't bother to clear the endpoint
bandwidth info when a device is being freed, since the xhci_virt_ep is
just going to be freed anyway.

Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 5efb0afff5f6af9dd36cedbdf2b650254d0c80fe..9451d94b78d9e6f5b040e14171851500b0ad84e4 100644 (file)
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1410,6 +1410,69 @@ void xhci_endpoint_zero(struct xhci_hcd *xhci,
         */
 }
 
+void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info)
+{
+       bw_info->ep_interval = 0;
+       bw_info->mult = 0;
+       bw_info->num_packets = 0;
+       bw_info->max_packet_size = 0;
+       bw_info->type = 0;
+       bw_info->max_esit_payload = 0;
+}
+
+void xhci_update_bw_info(struct xhci_hcd *xhci,
+               struct xhci_container_ctx *in_ctx,
+               struct xhci_input_control_ctx *ctrl_ctx,
+               struct xhci_virt_device *virt_dev)
+{
+       struct xhci_bw_info *bw_info;
+       struct xhci_ep_ctx *ep_ctx;
+       unsigned int ep_type;
+       int i;
+
+       for (i = 1; i < 31; ++i) {
+               bw_info = &virt_dev->eps[i].bw_info;
+
+               /* We can't tell what endpoint type is being dropped, but
+                * unconditionally clearing the bandwidth info for non-periodic
+                * endpoints should be harmless because the info will never be
+                * set in the first place.
+                */
+               if (!EP_IS_ADDED(ctrl_ctx, i) && EP_IS_DROPPED(ctrl_ctx, i)) {
+                       /* Dropped endpoint */
+                       xhci_clear_endpoint_bw_info(bw_info);
+                       continue;
+               }
+
+               if (EP_IS_ADDED(ctrl_ctx, i)) {
+                       ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, i);
+                       ep_type = CTX_TO_EP_TYPE(le32_to_cpu(ep_ctx->ep_info2));
+
+                       /* Ignore non-periodic endpoints */
+                       if (ep_type != ISOC_OUT_EP && ep_type != INT_OUT_EP &&
+                                       ep_type != ISOC_IN_EP &&
+                                       ep_type != INT_IN_EP)
+                               continue;
+
+                       /* Added or changed endpoint */
+                       bw_info->ep_interval = CTX_TO_EP_INTERVAL(
+                                       le32_to_cpu(ep_ctx->ep_info));
+                       bw_info->mult = CTX_TO_EP_MULT(
+                                       le32_to_cpu(ep_ctx->ep_info));
+                       /* Number of packets is zero-based in the input context,
+                        * but we want one-based for the interval table.
+                        */
+                       bw_info->num_packets = CTX_TO_MAX_BURST(
+                                       le32_to_cpu(ep_ctx->ep_info2)) + 1;
+                       bw_info->max_packet_size = MAX_PACKET_DECODED(
+                                       le32_to_cpu(ep_ctx->ep_info2));
+                       bw_info->type = ep_type;
+                       bw_info->max_esit_payload = CTX_TO_MAX_ESIT_PAYLOAD(
+                                       le32_to_cpu(ep_ctx->tx_info));
+               }
+       }
+}
+
 /* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy.
  * Useful when you want to change one particular aspect of the endpoint and then
  * issue a configure endpoint command.

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 1657041c19cf69850ec2fd3724fd0c56d1f73a03..827914643f3e84c79ecdf4560ff8aecd623fbd3d 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1912,6 +1912,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                    !(le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1))))
                        xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
        }
+       xhci_update_bw_info(xhci, virt_dev->in_ctx, ctrl_ctx, virt_dev);
        xhci_zero_in_ctx(xhci, virt_dev);
        /*
         * Install any rings for completely new endpoints or changed endpoints,
@@ -2668,6 +2669,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                        xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
                        last_freed_endpoint = i;
                }
+               xhci_clear_endpoint_bw_info(&virt_dev->eps[i].bw_info);
        }
        xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
        xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);

diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index eee47c8a6ee8e2a29bd37cbfe258d2523da72f39..af15b903e06197a09c4568c9aaf2774ddf5d656b 100644 (file)
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -611,11 +611,13 @@ struct xhci_ep_ctx {
 #define EP_STATE_ERROR         4
 /* Mult - Max number of burtst within an interval, in EP companion desc. */
 #define EP_MULT(p)             (((p) & 0x3) << 8)
+#define CTX_TO_EP_MULT(p)      (((p) >> 8) & 0x3)
 /* bits 10:14 are Max Primary Streams */
 /* bit 15 is Linear Stream Array */
 /* Interval - period between requests to an endpoint - 125u increments. */
 #define EP_INTERVAL(p)         (((p) & 0xff) << 16)
 #define EP_INTERVAL_TO_UFRAMES(p)              (1 << (((p) >> 16) & 0xff))
+#define CTX_TO_EP_INTERVAL(p)  (((p) >> 16) & 0xff)
 #define EP_MAXPSTREAMS_MASK    (0x1f << 10)
 #define EP_MAXPSTREAMS(p)      (((p) << 10) & EP_MAXPSTREAMS_MASK)
 /* Endpoint is set up with a Linear Stream Array (vs. Secondary Stream Array) */
@@ -640,6 +642,7 @@ struct xhci_ep_ctx {
 /* bit 6 reserved */
 /* bit 7 is Host Initiate Disable - for disabling stream selection */
 #define MAX_BURST(p)   (((p)&0xff) << 8)
+#define CTX_TO_MAX_BURST(p)    (((p) >> 8) & 0xff)
 #define MAX_PACKET(p)  (((p)&0xffff) << 16)
 #define MAX_PACKET_MASK                (0xffff << 16)
 #define MAX_PACKET_DECODED(p)  (((p) >> 16) & 0xffff)
@@ -652,6 +655,7 @@ struct xhci_ep_ctx {
 /* tx_info bitmasks */
 #define AVG_TRB_LENGTH_FOR_EP(p)       ((p) & 0xffff)
 #define MAX_ESIT_PAYLOAD_FOR_EP(p)     (((p) & 0xffff) << 16)
+#define CTX_TO_MAX_ESIT_PAYLOAD(p)     (((p) >> 16) & 0xffff)
 
 /* deq bitmasks */
 #define EP_CTX_CYCLE_MASK              (1 << 0)
@@ -670,6 +674,11 @@ struct xhci_input_control_ctx {
        __le32  rsvd2[6];
 };
 
+#define        EP_IS_ADDED(ctrl_ctx, i) \
+       (le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1)))
+#define        EP_IS_DROPPED(ctrl_ctx, i)       \
+       (le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1)))
+
 /* Represents everything that is needed to issue a command on the command ring.
  * It's useful to pre-allocate these for commands that cannot fail due to
  * out-of-memory errors, like freeing streams.
@@ -731,6 +740,22 @@ struct xhci_stream_info {
 #define        SMALL_STREAM_ARRAY_SIZE         256
 #define        MEDIUM_STREAM_ARRAY_SIZE        1024
 
+/* Some Intel xHCI host controllers need software to keep track of the bus
+ * bandwidth.  Keep track of endpoint info here.  Each root port is allocated
+ * the full bus bandwidth.  We must also treat TTs (including each port under a
+ * multi-TT hub) as a separate bandwidth domain.  The direct memory interface
+ * (DMI) also limits the total bandwidth (across all domains) that can be used.
+ */
+struct xhci_bw_info {
+       unsigned int            ep_interval;
+       /* mult and num_packets are zero-based */
+       unsigned int            mult;
+       unsigned int            num_packets;
+       unsigned int            max_packet_size;
+       unsigned int            max_esit_payload;
+       unsigned int            type;
+};
+
 struct xhci_virt_ep {
        struct xhci_ring                *ring;
        /* Related to endpoints that are configured to use stream IDs only */
@@ -772,6 +797,7 @@ struct xhci_virt_ep {
         * process the missed tds on the endpoint ring.
         */
        bool                    skip;
+       struct xhci_bw_info     bw_info;
 };
 
 enum xhci_overhead_type {
@@ -1485,6 +1511,11 @@ unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc);
 unsigned int xhci_get_endpoint_flag_from_index(unsigned int ep_index);
 unsigned int xhci_last_valid_endpoint(u32 added_ctxs);
 void xhci_endpoint_zero(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, struct usb_host_endpoint *ep);
+void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info);
+void xhci_update_bw_info(struct xhci_hcd *xhci,
+               struct xhci_container_ctx *in_ctx,
+               struct xhci_input_control_ctx *ctrl_ctx,
+               struct xhci_virt_device *virt_dev);
 void xhci_endpoint_copy(struct xhci_hcd *xhci,
                struct xhci_container_ctx *in_ctx,
                struct xhci_container_ctx *out_ctx,