perf python: Do not force closing original perf descriptor in evlist.get_pollfd()

[linux/fpc-iii.git] / drivers / usb / wusbcore / wa-rpipe.c

// SPDX-License-Identifier: GPL-2.0
/*
 * WUSB Wire Adapter
 * rpipe management
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *
 * FIXME: docs
 *
 * RPIPE
 *
 *   Targeted at different downstream endpoints
 *
 *   Descriptor: use to config the remote pipe.
 *
 *   The number of blocks could be dynamic (wBlocks in descriptor is
 *   0)--need to schedule them then.
 *
 * Each bit in wa->rpipe_bm represents if an rpipe is being used or
 * not. Rpipes are represented with a 'struct wa_rpipe' that is
 * attached to the hcpriv member of a 'struct usb_host_endpoint'.
 *
 * When you need to xfer data to an endpoint, you get an rpipe for it
 * with wa_ep_rpipe_get(), which gives you a reference to the rpipe
 * and keeps a single one (the first one) with the endpoint. When you
 * are done transferring, you drop that reference. At the end the
 * rpipe is always allocated and bound to the endpoint. There it might
 * be recycled when not used.
 *
 * Addresses:
 *
 *  We use a 1:1 mapping mechanism between port address (0 based
 *  index, actually) and the address. The USB stack knows about this.
 *
 *  USB Stack port number    4 (1 based)
 *  WUSB code port index     3 (0 based)
 *  USB Address             5 (2 based -- 0 is for default, 1 for root hub)
 *
 *  Now, because we don't use the concept as default address exactly
 *  like the (wired) USB code does, we need to kind of skip it. So we
 *  never take addresses from the urb->pipe, but from the
 *  urb->dev->devnum, to make sure that we always have the right
 *  destination address.
 */
#include <linux/atomic.h>
#include <linux/bitmap.h>
#include <linux/slab.h>
#include <linux/export.h>

#include "wusbhc.h"
#include "wa-hc.h"

static int __rpipe_get_descr(struct wahc *wa,
                             struct usb_rpipe_descriptor *descr, u16 index)
{
        ssize_t result;
        struct device *dev = &wa->usb_iface->dev;

        /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
         * function because the arguments are different.
         */
        result = usb_control_msg(
                wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
                USB_REQ_GET_DESCRIPTOR,
                USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
                USB_CTRL_GET_TIMEOUT);
        if (result < 0) {
                dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
                        index, (int)result);
                goto error;
        }
        if (result < sizeof(*descr)) {
                dev_err(dev, "rpipe %u: got short descriptor "
                        "(%zd vs %zd bytes needed)\n",
                        index, result, sizeof(*descr));
                result = -EINVAL;
                goto error;
        }
        result = 0;

error:
        return result;
}

/*
 *
 * The descriptor is assumed to be properly initialized (ie: you got
 * it through __rpipe_get_descr()).
 */
static int __rpipe_set_descr(struct wahc *wa,
                             struct usb_rpipe_descriptor *descr, u16 index)
{
        ssize_t result;
        struct device *dev = &wa->usb_iface->dev;

        /* we cannot use the usb_get_descriptor() function because the
         * arguments are different.
         */
        result = usb_control_msg(
                wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                USB_REQ_SET_DESCRIPTOR,
                USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
                USB_CTRL_SET_TIMEOUT);
        if (result < 0) {
                dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
                        index, (int)result);
                goto error;
        }
        if (result < sizeof(*descr)) {
                dev_err(dev, "rpipe %u: sent short descriptor "
                        "(%zd vs %zd bytes required)\n",
                        index, result, sizeof(*descr));
                result = -EINVAL;
                goto error;
        }
        result = 0;

error:
        return result;

}

static void rpipe_init(struct wa_rpipe *rpipe)
{
        kref_init(&rpipe->refcnt);
        spin_lock_init(&rpipe->seg_lock);
        INIT_LIST_HEAD(&rpipe->seg_list);
        INIT_LIST_HEAD(&rpipe->list_node);
}

static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
{
        unsigned long flags;

        spin_lock_irqsave(&wa->rpipe_lock, flags);
        rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
        if (rpipe_idx < wa->rpipes)
                set_bit(rpipe_idx, wa->rpipe_bm);
        spin_unlock_irqrestore(&wa->rpipe_lock, flags);

        return rpipe_idx;
}

static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
{
        unsigned long flags;

        spin_lock_irqsave(&wa->rpipe_lock, flags);
        clear_bit(rpipe_idx, wa->rpipe_bm);
        spin_unlock_irqrestore(&wa->rpipe_lock, flags);
}

void rpipe_destroy(struct kref *_rpipe)
{
        struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
        u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

        if (rpipe->ep)
                rpipe->ep->hcpriv = NULL;
        rpipe_put_idx(rpipe->wa, index);
        wa_put(rpipe->wa);
        kfree(rpipe);
}
EXPORT_SYMBOL_GPL(rpipe_destroy);

/*
 * Locate an idle rpipe, create an structure for it and return it
 *
 * @wa    is referenced and unlocked
 * @crs   enum rpipe_attr, required endpoint characteristics
 *
 * The rpipe can be used only sequentially (not in parallel).
 *
 * The rpipe is moved into the "ready" state.
 */
static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
                          gfp_t gfp)
{
        int result;
        unsigned rpipe_idx;
        struct wa_rpipe *rpipe;
        struct device *dev = &wa->usb_iface->dev;

        rpipe = kzalloc(sizeof(*rpipe), gfp);
        if (rpipe == NULL)
                return -ENOMEM;
        rpipe_init(rpipe);

        /* Look for an idle pipe */
        for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
                rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
                if (rpipe_idx >= wa->rpipes)    /* no more pipes :( */
                        break;
                result =  __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
                if (result < 0)
                        dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
                                rpipe_idx, result);
                else if ((rpipe->descr.bmCharacteristics & crs) != 0)
                        goto found;
                rpipe_put_idx(wa, rpipe_idx);
        }
        *prpipe = NULL;
        kfree(rpipe);
        return -ENXIO;

found:
        set_bit(rpipe_idx, wa->rpipe_bm);
        rpipe->wa = wa_get(wa);
        *prpipe = rpipe;
        return 0;
}

static int __rpipe_reset(struct wahc *wa, unsigned index)
{
        int result;
        struct device *dev = &wa->usb_iface->dev;

        result = usb_control_msg(
                wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                USB_REQ_RPIPE_RESET,
                USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
        if (result < 0)
                dev_err(dev, "rpipe %u: reset failed: %d\n",
                        index, result);
        return result;
}

/*
 * Fake companion descriptor for ep0
 *
 * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
 */
static struct usb_wireless_ep_comp_descriptor epc0 = {
        .bLength = sizeof(epc0),
        .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
        .bMaxBurst = 1,
        .bMaxSequence = 2,
};

/*
 * Look for EP companion descriptor
 *
 * Get there, look for Inara in the endpoint's extra descriptors
 */
static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
                struct device *dev, struct usb_host_endpoint *ep)
{
        void *itr;
        size_t itr_size;
        struct usb_descriptor_header *hdr;
        struct usb_wireless_ep_comp_descriptor *epcd;

        if (ep->desc.bEndpointAddress == 0) {
                epcd = &epc0;
                goto out;
        }
        itr = ep->extra;
        itr_size = ep->extralen;
        epcd = NULL;
        while (itr_size > 0) {
                if (itr_size < sizeof(*hdr)) {
                        dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
                                "at offset %zu: only %zu bytes left\n",
                                ep->desc.bEndpointAddress,
                                itr - (void *) ep->extra, itr_size);
                        break;
                }
                hdr = itr;
                if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
                        epcd = itr;
                        break;
                }
                if (hdr->bLength > itr_size) {
                        dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
                                "at offset %zu (type 0x%02x) "
                                "length %d but only %zu bytes left\n",
                                ep->desc.bEndpointAddress,
                                itr - (void *) ep->extra, hdr->bDescriptorType,
                                hdr->bLength, itr_size);
                        break;
                }
                itr += hdr->bLength;
                itr_size -= hdr->bLength;
        }
out:
        return epcd;
}

/*
 * Aim an rpipe to its device & endpoint destination
 *
 * Make sure we change the address to unauthenticated if the device
 * is WUSB and it is not authenticated.
 */
static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
                     struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
{
        int result = -ENOMSG;   /* better code for lack of companion? */
        struct device *dev = &wa->usb_iface->dev;
        struct usb_device *usb_dev = urb->dev;
        struct usb_wireless_ep_comp_descriptor *epcd;
        u32 ack_window, epcd_max_sequence;
        u8 unauth;

        epcd = rpipe_epc_find(dev, ep);
        if (epcd == NULL) {
                dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
                        ep->desc.bEndpointAddress);
                goto error;
        }
        unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
        __rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
        atomic_set(&rpipe->segs_available,
                le16_to_cpu(rpipe->descr.wRequests));
        /* FIXME: block allocation system; request with queuing and timeout */
        /* FIXME: compute so seg_size > ep->maxpktsize */
        rpipe->descr.wBlocks = cpu_to_le16(16);         /* given */
        /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
        if (usb_endpoint_xfer_isoc(&ep->desc))
                rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
        else
                rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;

        rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
                                epcd->bMaxBurst, 16U), 1U);
        rpipe->descr.hwa_bDeviceInfoIndex =
                        wusb_port_no_to_idx(urb->dev->portnum);
        /* FIXME: use maximum speed as supported or recommended by device */
        rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
                UWB_PHY_RATE_53 : UWB_PHY_RATE_200;

        dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
                urb->dev->devnum, urb->dev->devnum | unauth,
                le16_to_cpu(rpipe->descr.wRPipeIndex),
                usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);

        rpipe->descr.hwa_reserved = 0;

        rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
        /* FIXME: bDataSequence */
        rpipe->descr.bDataSequence = 0;

        /* start with base window of hwa_bMaxBurst bits starting at 0. */
        ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
        rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
        epcd_max_sequence = max(min_t(unsigned int,
                        epcd->bMaxSequence, 32U), 2U);
        rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
        rpipe->descr.bInterval = ep->desc.bInterval;
        if (usb_endpoint_xfer_isoc(&ep->desc))
                rpipe->descr.bOverTheAirInterval = epcd->bOverTheAirInterval;
        else
                rpipe->descr.bOverTheAirInterval = 0;   /* 0 if not isoc */
        /* FIXME: xmit power & preamble blah blah */
        rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
                                        USB_ENDPOINT_XFERTYPE_MASK);
        /* rpipe->descr.bmCharacteristics RO */
        rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
        /* FIXME: use for assessing link quality? */
        rpipe->descr.wNumTransactionErrors = 0;
        result = __rpipe_set_descr(wa, &rpipe->descr,
                                   le16_to_cpu(rpipe->descr.wRPipeIndex));
        if (result < 0) {
                dev_err(dev, "Cannot aim rpipe: %d\n", result);
                goto error;
        }
        result = 0;
error:
        return result;
}

/*
 * Check an aimed rpipe to make sure it points to where we want
 *
 * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
 * space; when it is like that, we or 0x80 to make an unauth address.
 */
static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
                           const struct usb_host_endpoint *ep,
                           const struct urb *urb, gfp_t gfp)
{
        int result = 0;
        struct device *dev = &wa->usb_iface->dev;
        u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);

#define AIM_CHECK(rdf, val, text)                                       \
        do {                                                            \
                if (rpipe->descr.rdf != (val)) {                        \
                        dev_err(dev,                                    \
                                "rpipe aim discrepancy: " #rdf " " text "\n", \
                                rpipe->descr.rdf, (val));               \
                        result = -EINVAL;                               \
                        WARN_ON(1);                                     \
                }                                                       \
        } while (0)
        AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
        AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
                        UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
                  "(%u vs %u)");
        AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
        AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
        AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
#undef AIM_CHECK
        return result;
}

#ifndef CONFIG_BUG
#define CONFIG_BUG 0
#endif

/*
 * Make sure there is an rpipe allocated for an endpoint
 *
 * If already allocated, we just refcount it; if not, we get an
 * idle one, aim it to the right location and take it.
 *
 * Attaches to ep->hcpriv and rpipe->ep to ep.
 */
int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
                    struct urb *urb, gfp_t gfp)
{
        int result = 0;
        struct device *dev = &wa->usb_iface->dev;
        struct wa_rpipe *rpipe;
        u8 eptype;

        mutex_lock(&wa->rpipe_mutex);
        rpipe = ep->hcpriv;
        if (rpipe != NULL) {
                if (CONFIG_BUG == 1) {
                        result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
                        if (result < 0)
                                goto error;
                }
                __rpipe_get(rpipe);
                dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
                        ep->desc.bEndpointAddress,
                        le16_to_cpu(rpipe->descr.wRPipeIndex));
        } else {
                /* hmm, assign idle rpipe, aim it */
                result = -ENOBUFS;
                eptype = ep->desc.bmAttributes & 0x03;
                result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
                if (result < 0)
                        goto error;
                result = rpipe_aim(rpipe, wa, ep, urb, gfp);
                if (result < 0) {
                        rpipe_put(rpipe);
                        goto error;
                }
                ep->hcpriv = rpipe;
                rpipe->ep = ep;
                __rpipe_get(rpipe);     /* for caching into ep->hcpriv */
                dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
                        ep->desc.bEndpointAddress,
                        le16_to_cpu(rpipe->descr.wRPipeIndex));
        }
error:
        mutex_unlock(&wa->rpipe_mutex);
        return result;
}

/*
 * Allocate the bitmap for each rpipe.
 */
int wa_rpipes_create(struct wahc *wa)
{
        wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes);
        wa->rpipe_bm = bitmap_zalloc(wa->rpipes, GFP_KERNEL);
        if (wa->rpipe_bm == NULL)
                return -ENOMEM;
        return 0;
}

void wa_rpipes_destroy(struct wahc *wa)
{
        struct device *dev = &wa->usb_iface->dev;

        if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
                WARN_ON(1);
                dev_err(dev, "BUG: pipes not released on exit: %*pb\n",
                        wa->rpipes, wa->rpipe_bm);
        }
        bitmap_free(wa->rpipe_bm);
}

/*
 * Release resources allocated for an endpoint
 *
 * If there is an associated rpipe to this endpoint, Abort any pending
 * transfers and put it. If the rpipe ends up being destroyed,
 * __rpipe_destroy() will cleanup ep->hcpriv.
 *
 * This is called before calling hcd->stop(), so you don't need to do
 * anything else in there.
 */
void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
{
        struct wa_rpipe *rpipe;

        mutex_lock(&wa->rpipe_mutex);
        rpipe = ep->hcpriv;
        if (rpipe != NULL) {
                u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

                usb_control_msg(
                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                        USB_REQ_RPIPE_ABORT,
                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                        0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
                rpipe_put(rpipe);
        }
        mutex_unlock(&wa->rpipe_mutex);
}
EXPORT_SYMBOL_GPL(rpipe_ep_disable);

/* Clear the stalled status of an RPIPE. */
void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
{
        struct wa_rpipe *rpipe;

        mutex_lock(&wa->rpipe_mutex);
        rpipe = ep->hcpriv;
        if (rpipe != NULL) {
                u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

                usb_control_msg(
                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                        USB_REQ_CLEAR_FEATURE,
                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                        RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
        }
        mutex_unlock(&wa->rpipe_mutex);
}
EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);